> ## Documentation Index
> Fetch the complete documentation index at: https://docs.yiksipay.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Contrats Intelligents

> Interagissez avec n'importe quel contrat intelligent directement depuis votre portefeuille Yiksi Pay

<Note>
  En résumé<br />
  L'API Contrats Intelligents de Yiksi Pay vous permet d'interagir avec n'importe quel contrat intelligent directement depuis votre portefeuille sans avoir à gérer les endpoints RPC, les flux de signature ou les déploiements de contrats vous-même.
</Note>

## Prérequis

Avant d'utiliser l'API Contrats Intelligents, assurez-vous d'avoir :

<Steps>
  <Step title="Clé API">
    Obtenez votre clé API depuis le [Tableau de bord Yiksi Pay](https://dashboard.yiksipay.com). Naviguez vers **Paramètres → Clés API** pour en générer une.
  </Step>

  <Step title="Portefeuille Créé">
    Créez un portefeuille via l'[API Créer Portefeuille](/fr/api-reference/wallets/create-wallet) ou le tableau de bord. Vous aurez besoin du `walletId` pour toutes les opérations de contrat intelligent.
  </Step>

  <Step title="Solde en Monnaie Native">
    Alimentez votre portefeuille avec de la monnaie native (ETH, BNB, MATIC, etc.) pour couvrir les frais de gas. Utilisez l'[endpoint Frais Réseau](#estimation-des-frais-réseau) pour estimer les coûts avant l'exécution.
  </Step>
</Steps>

## Blockchains Supportées

L'API Contrats Intelligents supporte **toutes les blockchains compatibles EVM et Tron** disponibles sur Yiksi Pay. Voir [Intégrations](/fr/essentials/integrations) pour la liste complète des réseaux supportés et les liens vers les faucets.

<Warning>
  **Solana n'est pas supporté** pour les interactions avec les contrats intelligents. L'API Contrats Intelligents fonctionne uniquement avec les chaînes compatibles EVM et Tron.
</Warning>

<Tip>
  Commencez avec les testnets pendant le développement pour éviter de dépenser des fonds réels.
</Tip>

## Introduction

L'API Contrats Intelligents transforme Yiksi Pay d'une infrastructure de portefeuille en une couche d'exécution programmable. Vous pouvez lire l'état des contrats, exécuter des fonctions de contrat, estimer les frais de gas et signer des transactions—le tout via une surface API unifiée.

<CardGroup cols={2}>
  <Card title="Opérations de Lecture" icon="book-open">
    Récupérez des données de n'importe quel contrat intelligent sur les blockchains supportées.
  </Card>

  <Card title="Opérations d'Écriture" icon="pen">
    Exécutez des fonctions de contrat intelligent avec une gestion complète des transactions.
  </Card>

  <Card title="Estimation des Frais" icon="calculator">
    Calculez les coûts de gas avant l'exécution pour garantir des fonds suffisants.
  </Card>

  <Card title="Opérations par Lot" icon="layer-group">
    Exécutez plusieurs appels de contrat en une seule requête API.
  </Card>
</CardGroup>

## Cas d'Utilisation

L'API Contrats Intelligents débloque des capacités puissantes pour les développeurs fintech :

* **Intégration DeFi** : Connectez-vous à des protocoles comme Uniswap, Aave ou Compound pour la gestion de rendement et de liquidité
* **Opérations de Trésorerie** : Automatisez la gestion de trésorerie au sein de votre plateforme fintech
* **Actifs Tokenisés** : Intégrez des actifs du monde réel dans vos flux de produits
* **Règlements Programmables** : Exécutez des vérifications de conformité et des règlements automatisés
* **Actifs Personnalisés** : Gérez des actifs personnalisés, des systèmes de récompenses et des programmes de fidélité

## Portefeuille Principal vs Adresse Enfant

L'API Contrats Intelligents est disponible à deux niveaux :

<CardGroup cols={2}>
  <Card title="Portefeuille Principal" icon="wallet">
    Exécutez des opérations de contrat directement depuis votre portefeuille principal. Idéal pour les opérations de trésorerie et la gestion centralisée des fonds.
  </Card>

  <Card title="Adresse Enfant" icon="address-card">
    Exécutez des opérations de contrat depuis des adresses enfants individuelles. Parfait pour les opérations spécifiques aux utilisateurs et la gestion séparée des fonds.
  </Card>
</CardGroup>

### Endpoints du Portefeuille Principal

| Opération       | Endpoint                                            | Description                                     |
| --------------- | --------------------------------------------------- | ----------------------------------------------- |
| Lecture         | `POST /v1/wallets/{walletId}/contracts/read`        | Récupérer des données des contrats intelligents |
| Écriture        | `POST /v1/wallets/{walletId}/contracts/write`       | Exécuter des fonctions de contrat intelligent   |
| Frais Réseau    | `POST /v1/wallets/{walletId}/contracts/network-fee` | Estimer les coûts de gas                        |
| Signature Seule | `POST /v1/wallets/{walletId}/contracts/write/sign`  | Signer sans diffuser                            |

### Endpoints de l'Adresse Enfant

| Opération       | Endpoint                                                                  | Description                                     |
| --------------- | ------------------------------------------------------------------------- | ----------------------------------------------- |
| Lecture         | `POST /v1/wallets/{walletId}/addresses/{addressId}/contracts/read`        | Récupérer des données des contrats intelligents |
| Écriture        | `POST /v1/wallets/{walletId}/addresses/{addressId}/contracts/write`       | Exécuter des fonctions de contrat intelligent   |
| Frais Réseau    | `POST /v1/wallets/{walletId}/addresses/{addressId}/contracts/network-fee` | Estimer les coûts de gas                        |
| Signature Seule | `POST /v1/wallets/{walletId}/addresses/{addressId}/contracts/write/sign`  | Signer sans diffuser                            |

## Structure des Requêtes

Toutes les requêtes de contrat intelligent nécessitent ces paramètres :

| Paramètre    | Type   | Requis | Description                                                                      |
| ------------ | ------ | ------ | -------------------------------------------------------------------------------- |
| `address`    | string | Oui    | L'adresse blockchain du contrat intelligent                                      |
| `method`     | string | Oui    | Le nom de la fonction à appeler                                                  |
| `parameters` | array  | Oui    | Arguments correspondant à l'ordre de l'ABI de la fonction                        |
| `abi`        | array  | Oui    | L'Interface Binaire d'Application du contrat                                     |
| `reference`  | string | Non    | Votre ID de suivi interne pour la transaction                                    |
| `metadata`   | object | Non    | Paires clé-valeur personnalisées pour des détails de transaction supplémentaires |

<Info>
  Les champs `reference` et `metadata` ne sont applicables que pour les opérations d'écriture. Les opérations de lecture ne prennent pas en charge ces champs.
</Info>

### Comprendre les ABIs

L'ABI (Application Binary Interface) définit comment interagir avec un contrat intelligent. Vous pouvez obtenir des ABIs depuis :

* **Explorateurs de blocs** : Etherscan, BscScan, PolygonScan (contrats vérifiés)
* **Documentation des protocoles** : Docs officiels des protocoles DeFi
* **Code source du contrat** : Compiler depuis le code source Solidity

## Lecture des Données de Contrat

Utilisez l'endpoint de lecture pour interroger l'état du contrat sans modifier la blockchain.

### Exemple de Lecture depuis le Portefeuille Principal

<CodeGroup>
  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.yiksipay.com/v1/wallets/{walletId}/contracts/read \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "address": "0x337610d27c682E347C9cD60BD4b3b107C9d34dDd",
      "method": "balanceOf",
      "parameters": ["0x947514e4B803e312C312da0F1B41fEDdbe15ae7a"],
      "abi": [{
        "constant": true,
        "inputs": [{"name": "account", "type": "address"}],
        "name": "balanceOf",
        "outputs": [{"name": "", "type": "uint256"}],
        "stateMutability": "view",
        "type": "function"
      }]
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    `https://api.yiksipay.com/v1/wallets/${walletId}/contracts/read`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': '<api-key>'
      },
      body: JSON.stringify({
        address: '0x337610d27c682E347C9cD60BD4b3b107C9d34dDd',
        method: 'balanceOf',
        parameters: ['0x947514e4B803e312C312da0F1B41fEDdbe15ae7a'],
        abi: [{
          constant: true,
          inputs: [{ name: 'account', type: 'address' }],
          name: 'balanceOf',
          outputs: [{ name: '', type: 'uint256' }],
          stateMutability: 'view',
          type: 'function'
        }]
      })
    }
  );
  ```
</CodeGroup>

### Exemple de Lecture depuis une Adresse Enfant

<CodeGroup>
  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.yiksipay.com/v1/wallets/{walletId}/addresses/{addressId}/contracts/read \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "address": "0x337610d27c682E347C9cD60BD4b3b107C9d34dDd",
      "method": "balanceOf",
      "parameters": ["0x947514e4B803e312C312da0F1B41fEDdbe15ae7a"],
      "abi": [{
        "constant": true,
        "inputs": [{"name": "account", "type": "address"}],
        "name": "balanceOf",
        "outputs": [{"name": "", "type": "uint256"}],
        "stateMutability": "view",
        "type": "function"
      }]
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    `https://api.yiksipay.com/v1/wallets/${walletId}/addresses/${addressId}/contracts/read`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': '<api-key>'
      },
      body: JSON.stringify({
        address: '0x337610d27c682E347C9cD60BD4b3b107C9d34dDd',
        method: 'balanceOf',
        parameters: ['0x947514e4B803e312C312da0F1B41fEDdbe15ae7a'],
        abi: [{
          constant: true,
          inputs: [{ name: 'account', type: 'address' }],
          name: 'balanceOf',
          outputs: [{ name: '', type: 'uint256' }],
          stateMutability: 'view',
          type: 'function'
        }]
      })
    }
  );
  ```
</CodeGroup>

### Réponse de Lecture

```json theme={null}
{
  "message": "Contract read successfully",
  "statusCode": 200,
  "data": "10052335235393043"
}
```

### Réponses d'Erreur de Lecture

<AccordionGroup>
  <Accordion title="Adresse de Contrat Invalide">
    ```json theme={null}
    {
      "message": "Invalid contract address",
      "statusCode": 400,
      "error": "BAD_REQUEST"
    }
    ```
  </Accordion>

  <Accordion title="Méthode Non Trouvée">
    ```json theme={null}
    {
      "message": "Method 'balanceOf' not found in ABI",
      "statusCode": 400,
      "error": "ABI_METHOD_NOT_FOUND"
    }
    ```
  </Accordion>

  <Accordion title="Exécution du Contrat Annulée">
    ```json theme={null}
    {
      "message": "Contract execution reverted",
      "statusCode": 400,
      "error": "EXECUTION_REVERTED",
      "data": {
        "reason": "ERC20: balance query for zero address"
      }
    }
    ```
  </Accordion>

  <Accordion title="Paramètres Invalides">
    ```json theme={null}
    {
      "message": "Parameter count mismatch. Expected 1, got 2",
      "statusCode": 400,
      "error": "INVALID_PARAMETERS"
    }
    ```
  </Accordion>
</AccordionGroup>

## Écriture sur les Contrats

Exécutez des fonctions qui modifient l'état sur les contrats intelligents.

### Exemple d'Écriture depuis le Portefeuille Principal

<CodeGroup>
  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.yiksipay.com/v1/wallets/{walletId}/contracts/write \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "address": "0xYOUR_TOKEN_CONTRACT",
      "method": "approve",
      "parameters": ["0xYOUR_SPENDER_ADDRESS", "1000000000000000000"],
      "abi": [{
        "inputs": [
          {"name": "spender", "type": "address"},
          {"name": "amount", "type": "uint256"}
        ],
        "name": "approve",
        "outputs": [{"name": "", "type": "bool"}],
        "stateMutability": "nonpayable",
        "type": "function"
      }]
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    `https://api.yiksipay.com/v1/wallets/${walletId}/contracts/write`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': '<api-key>'
      },
      body: JSON.stringify({
        address: '0xYOUR_TOKEN_CONTRACT',
        method: 'approve',
        parameters: ['0xYOUR_SPENDER_ADDRESS', '1000000000000000000'],
        abi: [{
          inputs: [
            { name: 'spender', type: 'address' },
            { name: 'amount', type: 'uint256' }
          ],
          name: 'approve',
          outputs: [{ name: '', type: 'bool' }],
          stateMutability: 'nonpayable',
          type: 'function'
        }]
      })
    }
  );
  ```
</CodeGroup>

### Exemple d'Écriture depuis une Adresse Enfant

<CodeGroup>
  ```bash Curl theme={null}
  curl --request POST \
    --url https://api.yiksipay.com/v1/wallets/{walletId}/addresses/{addressId}/contracts/write \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: <api-key>' \
    --data '{
      "address": "0xYOUR_TOKEN_CONTRACT",
      "method": "approve",
      "parameters": ["0xYOUR_SPENDER_ADDRESS", "1000000000000000000"],
      "abi": [{
        "inputs": [
          {"name": "spender", "type": "address"},
          {"name": "amount", "type": "uint256"}
        ],
        "name": "approve",
        "outputs": [{"name": "", "type": "bool"}],
        "stateMutability": "nonpayable",
        "type": "function"
      }]
    }'
  ```

  ```javascript JavaScript theme={null}
  const response = await fetch(
    `https://api.yiksipay.com/v1/wallets/${walletId}/addresses/${addressId}/contracts/write`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': '<api-key>'
      },
      body: JSON.stringify({
        address: '0xYOUR_TOKEN_CONTRACT',
        method: 'approve',
        parameters: ['0xYOUR_SPENDER_ADDRESS', '1000000000000000000'],
        abi: [{
          inputs: [
            { name: 'spender', type: 'address' },
            { name: 'amount', type: 'uint256' }
          ],
          name: 'approve',
          outputs: [{ name: '', type: 'bool' }],
          stateMutability: 'nonpayable',
          type: 'function'
        }]
      })
    }
  );
  ```
</CodeGroup>

### Réponse d'Écriture

```json theme={null}
{
  "message": "Contract write initiated",
  "statusCode": 200,
  "data": {
    "id": "tx-uuid",
    "hash": "0x...",
    "status": "PENDING"
  }
}
```

<Warning>
  Les opérations d'écriture sont asynchrones. La réponse initiale affiche le statut `PENDING`. Écoutez le webhook `custom-smart-contract.success` pour confirmer l'achèvement de la transaction.
</Warning>

### Réponses d'Erreur d'Écriture

<AccordionGroup>
  <Accordion title="Gas Insuffisant">
    ```json theme={null}
    {
      "message": "Insufficient native token balance for gas",
      "statusCode": 400,
      "error": "INSUFFICIENT_GAS",
      "data": {
        "required": "0.005",
        "available": "0.001",
        "token": "ETH"
      }
    }
    ```
  </Accordion>

  <Accordion title="Solde Insuffisant">
    ```json theme={null}
    {
      "message": "Insufficient token balance",
      "statusCode": 400,
      "error": "INSUFFICIENT_BALANCE",
      "data": {
        "required": "1000000000000000000",
        "available": "500000000000000000"
      }
    }
    ```
  </Accordion>

  <Accordion title="Transaction Annulée">
    ```json theme={null}
    {
      "message": "Transaction would revert",
      "statusCode": 400,
      "error": "EXECUTION_REVERTED",
      "data": {
        "reason": "ERC20: transfer amount exceeds allowance"
      }
    }
    ```
  </Accordion>

  <Accordion title="ABI Invalide">
    ```json theme={null}
    {
      "message": "Invalid ABI format",
      "statusCode": 400,
      "error": "INVALID_ABI",
      "data": {
        "details": "Missing 'inputs' field in ABI definition"
      }
    }
    ```
  </Accordion>

  <Accordion title="Portefeuille Non Trouvé">
    ```json theme={null}
    {
      "message": "Wallet not found",
      "statusCode": 404,
      "error": "NOT_FOUND"
    }
    ```
  </Accordion>
</AccordionGroup>

## Estimation des Frais Réseau

Estimez toujours les frais avant d'exécuter des opérations d'écriture pour vous assurer que votre portefeuille dispose de suffisamment de monnaie native.

### Estimation des Frais du Portefeuille Principal

```bash theme={null}
curl --request POST \
  --url https://api.yiksipay.com/v1/wallets/{walletId}/contracts/network-fee \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '{
    "address": "0xYOUR_TOKEN_CONTRACT",
    "method": "approve",
    "parameters": ["0xYOUR_SPENDER_ADDRESS", "1000000000000000000"],
    "abi": [{
      "inputs": [
        {"name": "spender", "type": "address"},
        {"name": "amount", "type": "uint256"}
      ],
      "name": "approve",
      "outputs": [{"name": "", "type": "bool"}],
      "stateMutability": "nonpayable",
      "type": "function"
    }]
  }'
```

### Estimation des Frais de l'Adresse Enfant

```bash theme={null}
curl --request POST \
  --url https://api.yiksipay.com/v1/wallets/{walletId}/addresses/{addressId}/contracts/network-fee \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '{
    "address": "0xYOUR_TOKEN_CONTRACT",
    "method": "approve",
    "parameters": ["0xYOUR_SPENDER_ADDRESS", "1000000000000000000"],
    "abi": [{
      "inputs": [
        {"name": "spender", "type": "address"},
        {"name": "amount", "type": "uint256"}
      ],
      "name": "approve",
      "outputs": [{"name": "", "type": "bool"}],
      "stateMutability": "nonpayable",
      "type": "function"
    }]
  }'
```

### Réponse des Frais

```json theme={null}
{
  "message": "Network fee retrieved",
  "statusCode": 200,
  "data": {
    "networkFee": "0.00001247904",
    "networkFeeInUSD": "0.01",
    "nativeBalance": "0.5",
    "nativeBalanceInUSD": "450.00",
    "estimatedArrivalTime": 30
  }
}
```

***

## Exemple Pratique : Échange d'Actifs sur Uniswap

Cette section démontre deux approches pour exécuter un échange d'actifs : **sans opérations par lot** (appels séquentiels) et **avec opérations par lot** (appel API unique).

### Exemple 1 : Échange d'Actifs SANS Opérations par Lot

Cette approche effectue des appels API individuels pour chaque étape. Utilisez-la lorsque vous avez besoin d'un contrôle précis sur chaque transaction ou lorsque les opérations dépendent des résultats des appels précédents.

#### Étape 1 : Vérifier le Solde d'Actifs

```javascript theme={null}
const balanceOfAbi = {
  constant: true,
  inputs: [{ name: 'account', type: 'address' }],
  name: 'balanceOf',
  outputs: [{ name: '', type: 'uint256' }],
  stateMutability: 'view',
  type: 'function'
};

const balance = await fetch(
  `https://api.yiksipay.com/v1/wallets/${walletId}/contracts/read`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey },
    body: JSON.stringify({
      address: TOKEN_ADDRESS,
      method: 'balanceOf',
      parameters: [walletAddress],
      abi: [balanceOfAbi]
    })
  }
).then(r => r.json());

console.log('Solde d\'Actifs:', balance.data);
```

#### Étape 2 : Approuver la Dépense d'Actifs

```javascript theme={null}
const approveAbi = {
  inputs: [
    { name: 'spender', type: 'address' },
    { name: 'amount', type: 'uint256' }
  ],
  name: 'approve',
  outputs: [{ name: '', type: 'bool' }],
  stateMutability: 'nonpayable',
  type: 'function'
};

const approval = await fetch(
  `https://api.yiksipay.com/v1/wallets/${walletId}/contracts/write`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey },
    body: JSON.stringify({
      address: TOKEN_ADDRESS,
      method: 'approve',
      parameters: [UNISWAP_ROUTER, amountIn],
      abi: [approveAbi]
    })
  }
).then(r => r.json());

console.log('TX Approbation:', approval.data.hash);
// IMPORTANT: Attendez la confirmation du webhook avant de continuer
```

<Warning>
  Attendez toujours le webhook `custom-smart-contract.success` confirmant que la transaction d'approbation a été minée avant d'exécuter l'échange.
</Warning>

#### Étape 3 : Estimer les Frais d'Échange

```javascript theme={null}
const swapAbi = {
  inputs: [
    { name: 'amountIn', type: 'uint256' },
    { name: 'amountOutMin', type: 'uint256' },
    { name: 'path', type: 'address[]' },
    { name: 'to', type: 'address' },
    { name: 'deadline', type: 'uint256' }
  ],
  name: 'swapExactTokensForTokens',
  outputs: [{ name: 'amounts', type: 'uint256[]' }],
  stateMutability: 'nonpayable',
  type: 'function'
};

const fees = await fetch(
  `https://api.yiksipay.com/v1/wallets/${walletId}/contracts/network-fee`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey },
    body: JSON.stringify({
      address: UNISWAP_ROUTER,
      method: 'swapExactTokensForTokens',
      parameters: [
        amountIn,
        amountOutMin,
        [TOKEN_A, TOKEN_B],
        walletAddress,
        deadline
      ],
      abi: [swapAbi]
    })
  }
).then(r => r.json());

console.log('Frais Estimés:', fees.data.networkFee);
```

#### Étape 4 : Exécuter l'Échange

```javascript theme={null}
const swap = await fetch(
  `https://api.yiksipay.com/v1/wallets/${walletId}/contracts/write`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey },
    body: JSON.stringify({
      address: UNISWAP_ROUTER,
      method: 'swapExactTokensForTokens',
      parameters: [
        amountIn,
        amountOutMin,
        [TOKEN_A, TOKEN_B],
        walletAddress,
        deadline
      ],
      abi: [swapAbi]
    })
  }
).then(r => r.json());

console.log('TX Échange:', swap.data.hash);
```

***

### Exemple 2 : Échange d'Actifs AVEC Opérations par Lot

Cette approche combine approbation + échange en un seul appel API utilisant le tableau `calls`. Utilisez ceci pour l'efficacité lorsque vous voulez mettre en file d'attente plusieurs opérations ensemble.

<Note>
  Les opérations par lot s'exécutent séquentiellement. Chaque opération est soumise comme une transaction séparée, mais vous n'avez besoin que d'un seul appel API.
</Note>

#### Requête par Lot : Approbation + Échange en Un Appel

```javascript theme={null}
const approveAbi = {
  inputs: [
    { name: 'spender', type: 'address' },
    { name: 'amount', type: 'uint256' }
  ],
  name: 'approve',
  outputs: [{ name: '', type: 'bool' }],
  stateMutability: 'nonpayable',
  type: 'function'
};

const swapAbi = {
  inputs: [
    { name: 'amountIn', type: 'uint256' },
    { name: 'amountOutMin', type: 'uint256' },
    { name: 'path', type: 'address[]' },
    { name: 'to', type: 'address' },
    { name: 'deadline', type: 'uint256' }
  ],
  name: 'swapExactTokensForTokens',
  outputs: [{ name: 'amounts', type: 'uint256[]' }],
  stateMutability: 'nonpayable',
  type: 'function'
};

const batchSwap = await fetch(
  `https://api.yiksipay.com/v1/wallets/${walletId}/contracts/write`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey },
    body: JSON.stringify({
      calls: [
        {
          address: TOKEN_ADDRESS,
          method: 'approve',
          parameters: [UNISWAP_ROUTER, amountIn],
          abi: [approveAbi],
          reference: 'approve-tx',
          metadata: { step: 'approbation' }
        },
        {
          address: UNISWAP_ROUTER,
          method: 'swapExactTokensForTokens',
          parameters: [
            amountIn,
            amountOutMin,
            [TOKEN_A, TOKEN_B],
            walletAddress,
            deadline
          ],
          abi: [swapAbi],
          reference: 'swap-tx',
          metadata: { step: 'échange' }
        }
      ]
    })
  }
).then(r => r.json());

console.log('Résultat par Lot:', batchSwap.data);
```

#### Réponse par Lot

```json theme={null}
{
  "message": "Batch contract write initiated successfully",
  "statusCode": 200,
  "data": {
    "success": [
      {
        "index": 0,
        "id": "tx-uuid-1",
        "hash": "0xapprove...",
        "status": "PENDING",
        "reference": "approve-tx"
      },
      {
        "index": 1,
        "id": "tx-uuid-2",
        "hash": "0xswap...",
        "status": "PENDING",
        "reference": "swap-tx"
      }
    ],
    "errors": []
  }
}
```

#### Gestion des Échecs Partiels dans les Lots

```javascript theme={null}
const result = await batchSwap.json();

// Vérifier les opérations réussies
result.data.success.forEach(tx => {
  console.log(`✓ ${tx.reference}: ${tx.hash}`);
});

// Vérifier les opérations échouées
result.data.errors.forEach(error => {
  console.error(`✗ Opération ${error.index} (${error.method}): ${error.error}`);
});
```

### Règles des Opérations par Lot

| Règle                  | Valeur                                                              |
| ---------------------- | ------------------------------------------------------------------- |
| Taille maximale du lot | 20 opérations                                                       |
| Ordre d'exécution      | Séquentiel                                                          |
| Gestion des erreurs    | Succès partiel (les échecs n'arrêtent pas les opérations suivantes) |

### Quand Utiliser Chaque Approche

| Scénario                                                 | Approche Recommandée |
| -------------------------------------------------------- | -------------------- |
| Besoin de vérifier les résultats entre les étapes        | Sans Lot             |
| Paramètres dynamiques basés sur les résultats précédents | Sans Lot             |
| Modèles simples d'approbation + action                   | Avec Lot             |
| Plusieurs opérations indépendantes                       | Avec Lot             |
| Minimiser les appels API                                 | Avec Lot             |

***

## Événements Webhook

Les opérations de contrat intelligent déclenchent des notifications webhook :

| Événement                       | Description                               |
| ------------------------------- | ----------------------------------------- |
| `custom-smart-contract.success` | Opération de contrat terminée avec succès |
| `custom-smart-contract.failed`  | Opération de contrat échouée              |

### Payload du Webhook

```json theme={null}
{
  "event": "custom-smart-contract.success",
  "data": {
    "id": "tx-uuid",
    "hash": "0x...",
    "status": "SUCCESS",
    "method": "approve",
    "contractAddress": "0x...",
    "blockchain": {
      "name": "ethereum",
      "network": "mainnet"
    }
  }
}
```

## Meilleures Pratiques

### Sécurité

* **Vérifiez les adresses de contrat** : Vérifiez toujours les adresses de contrat avant d'interagir
* **Utilisez des ABIs fiables** : Obtenez les ABIs de sources vérifiées comme les explorateurs de blocs
* **Définissez des limites raisonnables** : Utilisez la protection contre le slippage et les plafonds de montants pour les opérations DeFi

### Gestion du Gas

* **Estimez avant d'exécuter** : Appelez toujours l'endpoint network-fee en premier
* **Surveillez le solde natif** : Assurez-vous d'avoir suffisamment d'ETH/BNB/MATIC pour les frais de gas
* **Utilisez les opérations par lot** : Réduisez les frais généraux en regroupant les opérations liées

### Gestion des Erreurs

* **Implémentez des écouteurs webhook** : Ne vous fiez pas uniquement aux réponses API
* **Gérez les échecs partiels** : Vérifiez les tableaux `success` et `errors` dans les réponses par lot
* **Réessayez avec backoff** : Implémentez un backoff exponentiel pour les échecs transitoires

## Référence API

### Endpoints du Portefeuille Principal

| Endpoint                                                                          | Description                       |
| --------------------------------------------------------------------------------- | --------------------------------- |
| [Lire Contrat](/fr/api-reference/smart-contract/master-wallet-read)               | Lire l'état du contrat            |
| [Écrire Contrat](/fr/api-reference/smart-contract/master-wallet-write)            | Exécuter des fonctions de contrat |
| [Frais Réseau](/fr/api-reference/smart-contract/master-wallet-network-fee)        | Estimer les coûts de gas          |
| [Signature Seule](/fr/api-reference/smart-contract/master-wallet-write-sign-only) | Signer sans diffuser              |

### Endpoints de l'Adresse Enfant

| Endpoint                                                                          | Description                       |
| --------------------------------------------------------------------------------- | --------------------------------- |
| [Lire Contrat](/fr/api-reference/smart-contract/child-address-read)               | Lire l'état du contrat            |
| [Écrire Contrat](/fr/api-reference/smart-contract/child-address-write)            | Exécuter des fonctions de contrat |
| [Frais Réseau](/fr/api-reference/smart-contract/child-address-network-fee)        | Estimer les coûts de gas          |
| [Signature Seule](/fr/api-reference/smart-contract/child-address-write-sign-only) | Signer sans diffuser              |

## Support

* **Email** : [partner@yiksi.com](mailto:partner@yiksi.com)
* **Documentation** : [Référence API](/fr/api-reference/smart-contract/master-wallet-read)

<Note>
  L'API Contrats Intelligents vous permet de créer des intégrations blockchain sophistiquées sans gérer la complexité de l'infrastructure. Commencez par des opérations de lecture simples et incorporez progressivement des opérations d'écriture à mesure que vous vous familiarisez avec le système.
</Note>