Une photo de Shodipo Ayomide
Tous les articles

Simplifier les transactions cross-chain grâce aux intents

·
18 sept. 2025
·
7 min de lecture
·
••• vues
·
••• j'aime

Traduit de l'article original en anglais. Lire en anglais

Simplifier les transactions cross-chain grâce aux intents

Prenons ce scénario - Vous essayez d'échanger 1,000 USDC sur Ethereum contre du SOL sur Solana. Avec les bridges traditionnels, il vous faudrait wrapper vos USDC, trouver un bridge (en espérant qu'il ne se fasse pas hacker), attendre 20 minutes ou plus pour la finalité, payer des frais ridicules, puis unwrapper de l'autre côté. Le temps que vous terminiez, le prix a bougé, vous avez cramé $50 en gas, et vous remettez en question vos choix de vie, Bon sang !

Et si je vous disais qu'il existe une meilleure solution ? Et si vous pouviez simplement dire je veux 100 SOL contre mes 1000 USDC et laisser la blockchain se charger du reste ? C'est exactement ce que font les intents. Ils vous permettent de déclarer précisément ce que vous voulez, au lieu de vous embêter à devoir l'obtenir vous-même.

Que sont les intents ?

Voyez les intents comme la différence entre dire à quelqu'un « roule jusqu'au supermarché, tourne à gauche sur ilford high road, gare-toi à la place 11 et marche jusqu'au rayon 5... » et simplement lui dire « ramène-moi du lait ». Le résultat est au fond le même, mais une approche est déclarative (exactement ce que vous voulez) tandis que l'autre est impérative (des instructions étape par étape).

En termes techniques, les intents sont des messages signés qui expriment le résultat souhaité par un utilisateur sans préciser les détails d'exécution. Au lieu de construire vous-même des séquences de transactions complexes, vous diffusez votre intent à un réseau de solvers (des acteurs sophistiqués) qui se font ensuite concurrence pour satisfaire votre demande.

Voici à quoi ressemble un exemple d'intent :

 {
  "user": "alice.near",
  "intent_type": "token_swap",
  "give": {
    "token": "usdc.near",
    "amount": "1000000000"
  },
  "receive": {
    "token": "sol.near", 
    "min_amount": "100000000000"
  },
  "deadline": 1735689600,
  "signature": "0x..."
}

Plutôt simple, non ? Alice se moque complètement de la complexité du routage, elle veut juste ses SOL en échange de ses USDC, et c'est tout.

Pourquoi les intents existent - Le problème du cross-chain

Les protocoles DeFi cross-chain sont assez complexes pour l'utilisateur lambda. Il doit comprendre différents protocoles, gérer plusieurs tokens de gas et naviguer au milieu d'une tonne de risques de sécurité. Les solutions traditionnelles impliquent souvent :

  1. Des workflows complexes en plusieurs étapes sur différentes chaînes
  2. Des failles de sécurité liées au wrapping et au bridging des actifs
  3. Une mauvaise expérience pour l'utilisateur lambda, qui exige des connaissances techniques poussées
  4. Une liquidité fragmentée et des prix sous-optimaux

Les intents renversent ce modèle. Au lieu de repousser la complexité vers les utilisateurs, le système l'absorbe dans un réseau concurrentiel de solvers. Les utilisateurs expriment leurs souhaits, les solvers trouvent comment les exécuter, et tout le monde y gagne 🔥.

Que sont les solvers et comment fonctionnent-ils ?

Dans ce contexte, les solvers sont la colonne vertébrale des systèmes basés sur les intents. Ce sont des acteurs spécialisés, qui peuvent être des market makers, des agents IA ou des traders sophistiqués - et qui se font concurrence pour satisfaire les intents des utilisateurs au sein du système.

Voici comment ça marche : quand vous diffusez un intent, plusieurs solvers l'analysent et soumettent des cotations concurrentes. Ils peuvent router via différents DEXs, utiliser de la liquidité off-chain, ou même regrouper votre intent avec d'autres pour obtenir un meilleur prix. La meilleure solution l'emporte.

Maintenant, voyez les solvers comme vos assistants de trading personnels, qui connaissent chaque protocole connecté, chaque source de liquidité et chaque astuce d'optimisation de la DeFi. Ils gagnent de l'argent en offrant une meilleure exécution que celle que vous pourriez obtenir vous-même, et ils vous font gagner beaucoup de temps.

Les intents traditionnels

Les architectures basées sur les intents ne sont pas un concept entièrement nouveau. UniswapX a été pionnier de ce concept sur Ethereum, avec plus de 2 milliards de dollars de volume traités via des Dutch auctions où des « fillers » se font concurrence pour exécuter les demandes de swap.

CoW Protocol a étendu ce modèle avec des batch auctions et une protection contre le MEV, accumulant plus de 15 milliards de dollars de volume de trading. Leur idée ? En regroupant les intents et en trouvant des coïncidences de besoins, ils pouvaient éliminer le MEV tout en améliorant l'exécution.

Mais ces systèmes restent des solutions mono-chaîne. UniswapX fonctionne très bien pour les trades dans l'écosystème ETH, mais en cross-chain ? Vous replongez dans l'enfer de la complexité, bon retour parmi nous !

Comment NEAR Protocol a résolu ce problème

NEAR Protocol a construit le premier système d'intents véritablement cross-chain. Les chiffres parlent d'eux-mêmes : plus de 1,075 milliard de dollars de volume total, une finalité de 2 à 3 secondes, et une prise en charge native de Bitcoin sans wrapping.

Comment y sont-ils parvenus ? Grâce aux Chain Signatures. Grâce au calcul multipartite (MPC), les validateurs NEAR peuvent signer collectivement des transactions sur des blockchains externes sans qu'aucune partie ne détienne seule les clés privées. C'est comme avoir une télécommande universelle pour tout l'écosystème crypto.

Créer un intent

import { createIntent, signIntent } from '@defuse-protocol/intents-sdk';
 
const intent = createIntent({
  from: 'alice.near',
  give: { token: 'usdc.near', amount: '1000000000' },
  receive: { token: 'sol.near', minAmount: '100000000000' },
  expiry: Date.now() + 300000
});
 
const signedIntent = await signIntent(intent, wallet);
await broadcastIntent(signedIntent);

Organigramme montrant le pipeline Création de l'intent → Compétition entre solvers → Règlement, avec trois phases et acteurs distincts

Organigramme montrant le pipeline Création de l'intent → Compétition entre solvers → Règlement
Organigramme montrant le pipeline Création de l'intent → Compétition entre solvers → Règlement

L'architecture en trois couches

La logique de vérification principale :

fn execute_token_diff_intents(intents: &[TokenDiff]) -> Result<(), Error> {
    let mut net_changes: HashMap<TokenId, i128> = HashMap::new();
    
    for intent in intents {
        *net_changes.entry(intent.token_in).or_default() -= intent.amount_in;
        *net_changes.entry(intent.token_out).or_default() += intent.amount_out;
    }
    
    for (_, net_change) in net_changes.iter() {
        if *net_change != 0 {
            return Err("Non-zero sum transaction".into());
        }
    }
    Ok(())
}

Ce petit bout de code garantit un équilibre parfait, pour chaque token qui sort, un montant équivalent entre, sur l'ensemble des intents regroupés.

Diagramme montrant la pile à trois couches avec les flux de données entre Distribution, Réseaux de solvers et le Vérificateur, y compris des composants spécifiques comme 1Click API, MPC Network et Chain Signatures

Diagramme montrant la pile à trois couches avec les flux de données
Diagramme montrant la pile à trois couches avec les flux de données

Parlons de la 1Click API

Une partie du secret pour faire fonctionner tout ça à grande échelle, c'est la 1Click API, qui fait disparaître toute la complexité de bout en bout. Les développeurs peuvent créer des intents cross-chain sans se soucier du MPC, des Chain Signatures ou du solver routing. Elle se charge de récupérer les cotations de plusieurs solvers, sélectionne le meilleur chemin à travers les DEXs et les bridges, surveille l'exécution, gère les nouvelles tentatives, et s'occupe même de l'optimisation du gas et du timing, le tout en un seul appel d'API, tout le reste est géré en coulisses.

Construire avec la 1Click API

Voici à quoi ça ressemble :

import { IntentsSDK } from '@near-intents/sdk';
 
const sdk = new IntentsSDK({
  network: 'mainnet',
  apiKey: process.env.NEAR_INTENTS_API_KEY
});
 
async function createSwapIntent(fromToken, toToken, amount) {
    const quote = await sdk.getQuote({
      tokenIn: fromToken,
      tokenOut: toToken,
      amountIn: amount,
    slippage: 0.005
    });
    
    const intent = await sdk.createIntent({
    tokenIn: { address: fromToken, amount },
      tokenOut: { address: toToken, minAmount: quote.amountOut },
    deadline: Date.now() + 300000
    });
    
    // watch the execution
  sdk.watchIntent(intent.id)
    .on('executed', (result) => console.log(`Done! TX: ${result.hash}`))
    .on('failed', (error) => console.error(`Failed: ${error.reason}`));
}

Pour en savoir plus, c'est par ici.

Zoom sur Defuse Protocol

Defuse montre simplement comment construire des interfaces de DEX de production avec les intents. Au lieu de gérer une logique de routage complexe, vous obtenez :

import { DefuseKit } from '@defuse-protocol/intents-sdk';
 
const defuse = new DefuseKit({ network: 'mainnet' });
 
const quotes = await defuse.requestQuotes({
  tokenIn: 'ethereum:0x...', 
  tokenOut: 'solana:native',
  amountIn: amount
});
 
const bestQuote = quotes.reduce((best, current) => 
  BigInt(current.amountOut) > BigInt(best.amountOut) ? current : best
);
        
const result = await defuse.executeIntent(bestQuote);

Cela vous apporte :

Le client gère toute la complexité, les utilisateurs voient simplement le meilleur prix et l'exécution la plus rapide, puis passent à autre chose.

Zoom sur Paycrest

Paycrest fait le pont entre les intents blockchain et les systèmes de paiement traditionnels. Voici comment ça fonctionne :

  1. Création de l'intent : l'utilisateur dit « paie cette facture avec n'importe quel token »
  2. Découverte du chemin : le système trouve le chemin de conversion crypto-to-fiat optimal
  3. Exécution : il échange automatiquement la crypto contre un actif stable, puis la convertit en paiement fiat
func (a *Aggregator) ProcessPaymentIntent(intent *PaymentIntent) error {
    routes := a.findPaymentRoutes(intent)
    bestRoute := a.selectOptimalRoute(routes)
    
    switch bestRoute.Type {
    case "crypto_to_fiat":
        return a.executeCrossSystemPayment(intent, bestRoute)
    case "direct_crypto":
        return a.executeCryptoPayment(intent, bestRoute)
    }
}

Le principal défi réside dans les paiements inter-systèmes qui font le pont entre crypto et fiat. Paycrest gère cela en plusieurs étapes :

Pourquoi ça passe à l'échelle

  1. Compétition entre solvers : Un marché concurrentiel de solvers garantit une exécution efficace on-chain. À mesure que le nombre de solvers sur le réseau augmente, la concurrence fait baisser les coûts et améliore la vitesse d'exécution pour les utilisateurs. Ce marché ouvert encourage aussi la prise en charge d'une plus grande variété d'actifs et permet l'intégration de solvers avancés, comme des agents IA, capables d'opérations algorithmiques complexes.

  2. Effets de réseau du batching : un volume plus élevé d'intents utilisateurs permet à un verifier d'agréger plusieurs opérations en une seule transaction on-chain optimisée, ce qui répartit progressivement les coûts fixes (comme les frais de gas) entre de nombreux utilisateurs, avec à la clé des frais plus bas et une meilleure efficacité du capital pour tout le monde sur le réseau.

  3. Parallélisation multi-chaîne : les intents peuvent être parallélisés et exécutés sur plusieurs blockchains, ce qui améliore nettement le modèle de traitement séquentiel de nombreux bridges traditionnels. Un trade complexe impliquant des actifs sur Ethereum, Solana et Bitcoin peut être réglé de manière concurrente, ce qui réduit le temps total et la latence des transactions cross-chain.

Simplifier le routage complexe

Ces mécanismes masquent à l'utilisateur la complexité opérationnelle sous-jacente. L'extrait ci-dessous montre comment un utilisateur peut spécifier, en une seule requête, une transaction cross-chain multi-hop et optimisée en gas :

const response = await fetch('https://api.near-intents.org/v1/quote', {
  method: 'POST',
  body: JSON.stringify({
    tokenIn: 'usdc.near',
    tokenOut: 'bitcoin:native',
    routing: {
      maxHops: 3,
      excludeProtocols: ['slow_bridge'],
      preferredSolvers: ['defuse', 'paycrest'],
      gasOptimization: true
    }
  })
});

L'API gère automatiquement l'optimisation, le timing et la reprise après échec.

Réflexions finales

NEAR n'est pas le seul à faire ça. UniswapX domine le trading sur Ethereum, CoW Protocol excelle dans la protection contre le MEV, 1inch Fusion propose de l'agrégation de DEX.

Liens essentiels

•••
Partager cet article :

Restez informé

Recevez les derniers articles dans votre boîte mail.