Comment transférer une quantité spécifique de jetons SUI : gestion des objets Coin

Le défi

Contrairement aux blockchains traditionnelles où les soldes de jetons sont de simples chiffres, SUI stocke les jetons sous forme d'objetsindividuels. Cela signifie que si vous avez 3 jetons SUI, ils existent sous la forme de trois objets distincts (par exemple, 1 SUI + 1 SUI + 1 SUI = 3 au total), et non sous la forme d'un solde unique de « 3 SUI ».

Lorsque vous souhaitez transférer un montant spécifique (par exemple 2,5 SUI), vous devez : 1.Fusionnerplusieurs pièces si nécessaire 2.Divisez les pièces pour obtenir le montant exact 3.Transférerla pièce résultante

Exemple de code : transfert de 2.5 SUI

Voici un exemple TypeScript complet montrant comment gérer cela :

import { SuiClient, getFullnodeUrl } from '@mysten/sui.js/client';
import { TransactionBlock } from '@mysten/sui.js/transactions';
import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';

// Initialize client and keypair
const client = new SuiClient({ url: getFullnodeUrl('testnet') });
const keypair = Ed25519Keypair.fromSecretKey(YOUR_SECRET_KEY);
const senderAddress = keypair.getPublicKey().toSuiAddress();

async function transferSUI(recipientAddress: string, amountInSUI: number) {
  try {
    // Convert SUI to MIST (1 SUI = 1,000,000,000 MIST)
    const amountInMist = Math.floor(amountInSUI * 1_000_000_000);
    
    // Step 1: Get all SUI coin objects owned by sender
    const coinObjects = await client.getCoins({
      owner: senderAddress,
      coinType: '0x2::sui::SUI'
    });
    
    if (coinObjects.data.length === 0) {
      throw new Error('No SUI coins found');
    }
    
    console.log(`Found ${coinObjects.data.length} SUI coin objects`);
    coinObjects.data.forEach((coin, index) => {
      console.log(`Coin ${index + 1}: ${coin.balance} MIST`);
    });
    
    // Step 2: Create transaction block
    const txb = new TransactionBlock();
    
    // Step 3: Handle coin merging and splitting
    let primaryCoin;
    
    if (coinObjects.data.length === 1) {
      // Single coin - just split it
      primaryCoin = coinObjects.data[0].coinObjectId;
    } else {
      // Multiple coins - merge them first
      primaryCoin = coinObjects.data[0].coinObjectId;
      const coinsToMerge = coinObjects.data.slice(1).map(coin => coin.coinObjectId);
      
      if (coinsToMerge.length > 0) {
        txb.mergeCoins(primaryCoin, coinsToMerge);
        console.log(`Merging ${coinsToMerge.length} coins into primary coin`);
      }
    }
    
    // Step 4: Split the exact amount needed
    const [transferCoin] = txb.splitCoins(primaryCoin, [amountInMist]);
    
    // Step 5: Transfer the split coin
    txb.transferObjects([transferCoin], recipientAddress);
    
    // Step 6: Set gas budget and execute
    txb.setGasBudget(10000000); // 0.01 SUI in MIST
    
    const result = await client.signAndExecuteTransactionBlock({
      signer: keypair,
      transactionBlock: txb,
      options: {
        showEffects: true,
        showObjectChanges: true,
      },
    });
    
    console.log('Transaction successful!');
    console.log('Digest:', result.digest);
    console.log('Gas used:', result.effects?.gasUsed);
    
    return result;
    
  } catch (error) {
    console.error('Transfer failed:', error);
    throw error;
  }
}

// Usage example
async function main() {
  const recipientAddress = '0x742d35cc6db7e3b6c7e4c46e7f8c7e6f1234567890abcdef';
  const amountToTransfer = 2.5; // SUI
  
  await transferSUI(recipientAddress, amountToTransfer);
}

// Run the transfer
main().catch(console.error);

Répartition étape par étape

1.Récupérez des objets en pièces

const coinObjects = await client.getCoins({
  owner: senderAddress,
  coinType: '0x2::sui::SUI'
});

Cela permet de récupérer toutes les pièces SUI appartenant à votre adresse.

###2.Fusionner plusieurs pièces (si nécessaire)

if (coinObjects.data.length > 1) {
  const primaryCoin = coinObjects.data[0].coinObjectId;
  const coinsToMerge = coinObjects.data.slice(1).map(coin => coin.coinObjectId);
  txb.mergeCoins(primaryCoin, coinsToMerge);
}

Si vous possédez plusieurs pièces, fusionnez-les en une seule pièce plus grande.

3.Montant exact fractionné

const [transferCoin] = txb.splitCoins(primaryCoin, [amountInMist]);

Divisez le montant exact que vous souhaitez transférer à partir de la pièce fusionnée.

##4.Transférez la pièce fractionnée

txb.transferObjects([transferCoin], recipientAddress);

Transférez la pièce nouvellement créée au destinataire.

Points clés à retenir

-MIST contre SUI : convertissez toujours SUI en MIST (multipliez par 1 000 000 000) lorsque vous travaillez avec des transactions -Budget gaz : définissez un budget de gaz approprié (généralement, 0,01 SUI suffit) -Identifiants d'objet : chaque pièce possède un identifiant d'objet unique que vous référencez lors de vos transactions -Opérations atomiques : toutes les opérations de fusion, de scission et de transfert sont effectuées en une seule transaction

Conseils de gestion des erreurs

// Check if you have enough balance
const totalBalance = coinObjects.data.reduce((sum, coin) => 
  sum + parseInt(coin.balance), 0
);

if (totalBalance < amountInMist) {
  throw new Error(`Insufficient balance. Have: ${totalBalance/1e9} SUI, Need: ${amountInSUI} SUI`);
}

Alternative : utilisation de la méthode intégrée du SDK SUI

Pour des cas d'utilisation plus simples, vous pouvez utiliser la méthode pratique du SDK :

const txb = new TransactionBlock();
const [coin] = txb.splitCoins(txb.gas, [amountInMist]);
txb.transferObjects([coin], recipientAddress);

Cela utilise la pièce à gaz pour le transfert, ce qui fonctionne bien pour les petites quantités. Toutefois, si la pièce à gaz n'a pas la quantité requise de SUI, l'approche ci-dessus est requise/