# Simplifier les transactions cross-chain grâce aux intents

> 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 ?

Par Shodipo Ayomide, publié le 18 sept. 2025. Version web : https://blog.shodipoayomide.com/fr/simplifying-cross-chain-transactions-using-intents

![Simplifier les transactions cross-chain grâce aux intents](https://blog.shodipoayomide.com/banners/Simplifying-Cross-Chain-Transactions-Using-Intents.png)

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 :

```json
 {
  "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

```typescript
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](https://i.ibb.co/ymmnn7ym/Screenshot-2025-09-18-at-9-29-13-PM.png)

### L'architecture en trois couches

- **Distribution** : les apps, wallets et exchanges où les utilisateurs créent ces intents.

- **Réseaux de solvers** : des market makers décentralisés, des agents IA ou des acteurs similaires qui se font concurrence pour satisfaire les demandes. Ils accèdent à la liquidité des CEXs, des DEXs ou de sources off-chain.

- **Vérificateur** : le smart contract NEAR qui garantit le règlement atomique des intents.

La logique de vérification principale :

```rust
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](https://i.ibb.co/JRwJPB28/Screenshot-2025-09-18-at-9-30-22-PM.png)

### 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 :

```javascript
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](https://docs.near-intents.org/near-intents/integration/distribution-channels/1click-api).

### 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 :

```typescript
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 :

- Plusieurs solvers en concurrence pour les meilleurs prix
- Un règlement cross-chain
- Des cotations en temps réel toutes les 10 secondes

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](https://paycrest.io) 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

```go
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 :

- Étape 1 : convertir la crypto de l'utilisateur en actif stable (USDC)
- Étape 2 : faire l'off-ramp du stable vers le fiat via des partenaires de paiement
- Étape 3 : livrer le paiement fiat au destinataire

## 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 :

```javascript
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](https://x.uniswap.org/) domine le trading sur `Ethereum`, [CoW Protocol](https://cow.fi) excelle dans la protection contre le MEV, [1inch Fusion](https://fusion.1inch.io) propose de l'agrégation de DEX.

## Liens essentiels

- [Documentation officielle de NEAR Intents](https://docs.near.org/chain-abstraction/intents/overview) - Vue d'ensemble technique complète et guides d'intégration
- [Hub du projet NEAR Intents](https://near-intents.org/) - Site principal du projet, avec les actualités de l'écosystème
- [Documentation de la 1Click API](https://docs.near-intents.org/near-intents/integration/distribution-channels/1click-api) - Référence de l'API REST pour les développeurs
- [Documentation du SDK NEAR Intents](https://docs.near-intents.org/near-intents/sdk) - Référence complète du SDK et exemples
- [Contrats principaux de NEAR Intents](https://github.com/near/intents) - Implémentations des smart contracts et code Rust
- [SDK Defuse Protocol](https://www.npmjs.com/package/@defuse-protocol/intents-sdk) - Package NPM pour l'intégration de DEX cross-chain
- [Implémentation frontend de Defuse](https://github.com/defuse-protocol/defuse-frontend) - Frontend de DEX en production utilisant les intents
- [Paycrest Aggregator](https://github.com/paycrest/aggregator) - Traitement des intents de paiement et intégration inter-systèmes
- [Paycrest NoBlocks](https://github.com/paycrest/noblocks) - Exécution de transactions sans gas pour les intents