Contrats Intelligents

En résumé
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.

Prérequis

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

Clé API

Obtenez votre clé API depuis le Tableau de bord Yiksi Pay. Naviguez vers Paramètres → Clés API pour en générer une.

Portefeuille Créé

Créez un portefeuille via l’API Créer Portefeuille ou le tableau de bord. Vous aurez besoin du walletId pour toutes les opérations de contrat intelligent.

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 pour estimer les coûts avant l’exécution.

Blockchains Supportées

L’API Contrats Intelligents supporte toutes les blockchains compatibles EVM et Tron disponibles sur Yiksi Pay. Voir Intégrations pour la liste complète des réseaux supportés et les liens vers les faucets.

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.

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

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.

Opérations de Lecture

Récupérez des données de n’importe quel contrat intelligent sur les blockchains supportées.

Opérations d'Écriture

Exécutez des fonctions de contrat intelligent avec une gestion complète des transactions.

Estimation des Frais

Calculez les coûts de gas avant l’exécution pour garantir des fonds suffisants.

Opérations par Lot

Exécutez plusieurs appels de contrat en une seule requête API.

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 :

Portefeuille Principal

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.

Adresse Enfant

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.

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

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.

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

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"
    }]
  }'

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'
      }]
    })
  }
);

Exemple de Lecture depuis une Adresse Enfant

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"
    }]
  }'

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'
      }]
    })
  }
);

Réponse de Lecture

{
  "message": "Contract read successfully",
  "statusCode": 200,
  "data": "10052335235393043"
}

Réponses d’Erreur de Lecture

Adresse de Contrat Invalide

{
  "message": "Invalid contract address",
  "statusCode": 400,
  "error": "BAD_REQUEST"
}

Méthode Non Trouvée

{
  "message": "Method 'balanceOf' not found in ABI",
  "statusCode": 400,
  "error": "ABI_METHOD_NOT_FOUND"
}

Exécution du Contrat Annulée

{
  "message": "Contract execution reverted",
  "statusCode": 400,
  "error": "EXECUTION_REVERTED",
  "data": {
    "reason": "ERC20: balance query for zero address"
  }
}

Paramètres Invalides

{
  "message": "Parameter count mismatch. Expected 1, got 2",
  "statusCode": 400,
  "error": "INVALID_PARAMETERS"
}

Écriture sur les Contrats

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

Exemple d’Écriture depuis le Portefeuille Principal

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"
    }]
  }'

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'
      }]
    })
  }
);

Exemple d’Écriture depuis une Adresse Enfant

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"
    }]
  }'

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'
      }]
    })
  }
);

Réponse d’Écriture

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

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.

Réponses d’Erreur d’Écriture

Gas Insuffisant

{
  "message": "Insufficient native token balance for gas",
  "statusCode": 400,
  "error": "INSUFFICIENT_GAS",
  "data": {
    "required": "0.005",
    "available": "0.001",
    "token": "ETH"
  }
}

Solde Insuffisant

{
  "message": "Insufficient token balance",
  "statusCode": 400,
  "error": "INSUFFICIENT_BALANCE",
  "data": {
    "required": "1000000000000000000",
    "available": "500000000000000000"
  }
}

Transaction Annulée

{
  "message": "Transaction would revert",
  "statusCode": 400,
  "error": "EXECUTION_REVERTED",
  "data": {
    "reason": "ERC20: transfer amount exceeds allowance"
  }
}

ABI Invalide

{
  "message": "Invalid ABI format",
  "statusCode": 400,
  "error": "INVALID_ABI",
  "data": {
    "details": "Missing 'inputs' field in ABI definition"
  }
}

Portefeuille Non Trouvé

{
  "message": "Wallet not found",
  "statusCode": 404,
  "error": "NOT_FOUND"
}

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

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

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

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

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

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

Attendez toujours le webhook custom-smart-contract.success confirmant que la transaction d’approbation a été minée avant d’exécuter l’échange.

Étape 3 : Estimer les Frais d’Échange

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

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.

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.

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

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

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

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

{
  "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	Lire l’état du contrat
Écrire Contrat	Exécuter des fonctions de contrat
Frais Réseau	Estimer les coûts de gas
Signature Seule	Signer sans diffuser

Endpoints de l’Adresse Enfant

Endpoint	Description
Lire Contrat	Lire l’état du contrat
Écrire Contrat	Exécuter des fonctions de contrat
Frais Réseau	Estimer les coûts de gas
Signature Seule	Signer sans diffuser

Support

Email : partner@yiksi.com
Documentation : Référence API

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.

​Prérequis

​Blockchains Supportées

​Introduction

Opérations de Lecture

Opérations d'Écriture

Estimation des Frais

Opérations par Lot

​Cas d’Utilisation

​Portefeuille Principal vs Adresse Enfant

Portefeuille Principal

Adresse Enfant

​Endpoints du Portefeuille Principal

​Endpoints de l’Adresse Enfant

​Structure des Requêtes

​Comprendre les ABIs

​Lecture des Données de Contrat

​Exemple de Lecture depuis le Portefeuille Principal

​Exemple de Lecture depuis une Adresse Enfant

​Réponse de Lecture

​Réponses d’Erreur de Lecture

​Écriture sur les Contrats

​Exemple d’Écriture depuis le Portefeuille Principal

​Exemple d’Écriture depuis une Adresse Enfant

​Réponse d’Écriture

​Réponses d’Erreur d’Écriture

​Estimation des Frais Réseau

​Estimation des Frais du Portefeuille Principal

​Estimation des Frais de l’Adresse Enfant

​Réponse des Frais

​Exemple Pratique : Échange d’Actifs sur Uniswap

​Exemple 1 : Échange d’Actifs SANS Opérations par Lot

​Étape 1 : Vérifier le Solde d’Actifs

​Étape 2 : Approuver la Dépense d’Actifs

​Étape 3 : Estimer les Frais d’Échange

​Étape 4 : Exécuter l’Échange

​Exemple 2 : Échange d’Actifs AVEC Opérations par Lot

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

​Réponse par Lot

​Gestion des Échecs Partiels dans les Lots

​Règles des Opérations par Lot

​Quand Utiliser Chaque Approche

​Événements Webhook

​Payload du Webhook

​Meilleures Pratiques

​Sécurité

​Gestion du Gas

​Gestion des Erreurs

​Référence API

​Endpoints du Portefeuille Principal

​Endpoints de l’Adresse Enfant

​Support

Prérequis

Blockchains Supportées

Introduction

Cas d’Utilisation

Portefeuille Principal vs Adresse Enfant

Endpoints du Portefeuille Principal

Endpoints de l’Adresse Enfant

Structure des Requêtes

Comprendre les ABIs

Lecture des Données de Contrat

Exemple de Lecture depuis le Portefeuille Principal

Exemple de Lecture depuis une Adresse Enfant

Réponse de Lecture

Réponses d’Erreur de Lecture

Écriture sur les Contrats

Exemple d’Écriture depuis le Portefeuille Principal

Exemple d’Écriture depuis une Adresse Enfant

Réponse d’Écriture

Réponses d’Erreur d’Écriture

Estimation des Frais Réseau

Estimation des Frais du Portefeuille Principal

Estimation des Frais de l’Adresse Enfant

Réponse des Frais

Exemple Pratique : Échange d’Actifs sur Uniswap

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

Étape 1 : Vérifier le Solde d’Actifs

Étape 2 : Approuver la Dépense d’Actifs

Étape 3 : Estimer les Frais d’Échange

Étape 4 : Exécuter l’Échange

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

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

Réponse par Lot

Gestion des Échecs Partiels dans les Lots

Règles des Opérations par Lot

Quand Utiliser Chaque Approche

Événements Webhook

Payload du Webhook

Meilleures Pratiques

Sécurité

Gestion du Gas

Gestion des Erreurs

Référence API

Endpoints du Portefeuille Principal

Endpoints de l’Adresse Enfant

Support