La fusion de deux pièces dans le modèle de programmation Sui Move est essentielle car Sui utilise une architecture basée sur les objets où chaque jeton est un objet distinct avec son propre identifiant. Dans ce système, posséder trois pièces d'une valeur de 1 SUI chacune signifie détenir trois objets différents, et non un solde de 3 SUI. Pour interagir avec des protocoles ou effectuer des transferts, il est souvent nécessaire de les fusionner en un seul objet.

La bibliothèque standard Sui fournit une fonction de fusion dans le module sui : :coin. Il faut deux pièces du même type : l'une est mutable et restera, et l'autre sera consommée. Après la fusion, la valeur de la deuxième pièce est ajoutée à la première et la deuxième pièce est détruite. Les deux pièces doivent appartenir à l'appelant.

Voici une implémentation de base dans Move :

utilisez sui : :coin : : {Self, Coin} ;

merge_example (public fun merge_example) coin_primary : &mut Coin, coin_secondary : Pièce ) { coin : :merge (coin_primary, coin_secondary) ; }

Sur la ligne de commande, vous pouvez fusionner des pièces à l'aide de la CLI Sui avec :

sur le client merge-coin 
<primary_object_id>--pièce principale 
<secondary_object_id>--pièce à fusionner 
--budget gazier 10000000

Cela stockera le solde combiné dans la pièce principale. La pièce secondaire est consommée et ne peut plus être utilisée.

Dans le SDK Sui (par exemple, avec TypeScript), la même opération peut être effectuée par programmation :

attendez Suiclient.mergeCoin ({ signataire : MyAddress, Pièce principale : coin1_id, CoinToMerge : coin2_id, Budget du gaz : 100 000 }) ;

Du point de vue du stockage, la diminution du nombre de pièces réduit la complexité et les coûts de gaz. La fusion de pièces est une bonne pratique avant d'envoyer, de staker ou d'interagir avec des contrats DeFi. Cependant, certaines erreurs peuvent survenir. Il s'agit notamment d'utiliser le mauvais identifiant d'objet, de ne pas avoir suffisamment d'essence ou de ne pas être le propriétaire des deux pièces.

Pour éviter les bogues et suivre les meilleures pratiques de sécurité, évitez de réutiliser une pièce après sa fusion, assurez-vous de la cohérence des caractères et vérifiez toujours la propriété. Le modèle d'objet de Sui rend le comportement des pièces plus explicite et traçable que les modèles basés sur les comptes.

Dans la pratique, les portefeuilles fusionnent généralement automatiquement les petites pièces pour simplifier l'expérience utilisateur. Les protocoles DeFi l'utilisent pour consolider les récompenses ou gérer efficacement les fonds mis en commun.

Si vous créez quelque chose qui implique la gestion de nombreux objets en monnaie, il est utile d'écrire des fonctions utilitaires de fusion avant de soumettre des transactions ou de jalonner. Ce modèle peut empêcher la fragmentation des soldes et réduire les échecs de transactions en chaîne.

Pour fusionner deux pièces dans Move on the Sui Network, vous pouvez utiliser le Coinmodule pour transférer le solde d'une pièce dans une autre. Les pièces Sui sont gérées par le Coinmodule, et la fusion implique généralement le transfert de tous les actifs d'un objet de pièce à un autre, puis la suppression de l'objet source.

Concepts clés :

Coin::merge*Fusionner des pièces : vous pouvez transférer tout le solde d'une pièce à l'autre à l'aide de cette fonction. *Exemple de code de déplacement :

 module MergeCoins {
     use sui::coin::Coin;

     public fun merge_coins(
         coin1: &mut Coin<u64>,
         coin2: &mut Coin<u64>
     ) {
         Coin::merge(coin1, coin2);  // Merges the balance of coin2 into coin1
     }
 }

*CLI : sui clientà utiliser pour interagir avec le contrat après le déploiement, comme ceci :

 sui client call --function merge_coins --package <package-id> --module <module-name> --args <coin1-id> <coin2-id>

Meilleures pratiques :

• Assurez-vous que les pièces sont du même type (par exemple, les deuxCoin<u64>).
• Manipulez et vérifiez correctement la propriété des pièces avant de les fusionner.

Fusion de deux objets en monnaie dans Sui (Move)

En Sui, les pièces sont représentées sous forme d'objets Move. La fusion de deux pièces implique le transfert de leur valeur dans une seule pièce. Le modèle de propriété strict de Move signifie que vous ne pouvez pas combiner directement des pièces ; au lieu de cela, vous transféreriez la valeur d'une pièce dans l'autre, les « fusionnant » efficacement.

Concepts clés :

*Déplacer la language : les objets Coin sont immuables une fois créés. Vous ne pouvez pas les fusionner directement, mais vous pouvez transférer leur valeur en une seule pièce. *Réseau Sui : Sui utilise le modèle de ressources du langage Move pour renforcer la propriété et le contrôle des ressources (pièces).

Étapes pour fusionner des pièces :

1.Transférez la valeur d'une pièce à une autre. 2.Gravez la deuxième pièce(facultatif, si vous souhaitez la « supprimer »).

Exemple de code de déplacement :

public fun merge_coins(coin1: &mut Coin, coin2: &mut Coin) {
    // Transfer value from coin2 to coin1
    Coin::deposit(&mut coin1, Coin::withdraw(&mut coin2));
    // Optionally, burn coin2
    Coin::burn(&mut coin2);
}

Exemple de CLI :

La fusion de pièces n'est pas une opération directe de la CLI mais peut être réalisée en appelant la fonction dans un contrat :

sui client publish --gas-budget 10000 --module <module-path>

Erreurs courantes :

*Problèmes de propriété : Assurez-vous d'avoir les bonnes références mutables (&mut) aux objets de la monnaie. *Types de pièces invalides : assurez-vous que les pièces que vous essayez de fusionner sont du même type.

Meilleures pratiques :

*Évitez de dépenser deux fois : assurez-vous toujours que les pièces sont correctement transférées avant de les brûler. *Testez sur Localnet/Testnet : validez la logique avant le déploiement pour éviter les erreurs dans les transactions réelles.

Pour fusionner deux Coinobjets dans Sui Move, utilisez la coin::joinfonction du framework Sui, qui combine le solde de deux pièces du même type en une seule. Tout d'abord, assurez-vous que les deux pièces sont modifiables et appartiennent au signataire de la transaction, car le modèle de propriété de Sui nécessite une autorisation explicite pour modifier les objets. La fonction consomme les pièces entrées et crée une nouvelle pièce fusionnée, suivant le système de type linéaire de Sui où les objets ne peuvent pas être dupliqués ou copiés implicitement. Cette opération diffère des chaînes EVM où les soldes de jetons sont stockés dans des contrats plutôt que sous forme d'objets distincts.

Pour fusionner deux pièces dans Move on the Sui Network, vous utilisez la fonction coin::mergedu 0x2::coinmodule. Cet utilitaire vous permet de combiner la valeur d'une pièce avec une autre du même type, en détruisant la source et en préservant la cible. Cela est essentiel lorsqu'il s'agit de soldes fragmentés provenant de plusieurs transactions, en particulier pour les DApps, les protocoles DeFi et les places de marché.

Dans votre module Move personnalisé, vous devez inclure :

use sui::coin;

Exemple de code (dans Move) :

public entry fun merge_coins<CoinType>(
    target: &mut coin::Coin<CoinType>,
    source: coin::Coin<CoinType>
) {
    coin::merge(target, source);
}

Cette fonction prend une référence mutable à la pièce cible et une valeur pour la pièce source. La fonction ajoute la valeur de la pièce source à la cible et détruit la source au cours du processus.

Meilleures pratiques :

• Assurez-vous que les deux pièces sont dumême type(par exemple, les deux sont SUI ou les deux sont en USDC).
• Évitez de transmettre le même objet aux deux arguments, cela provoquerait la panique.
• À utiliser coin::value(&coin)si vous souhaitez inspecter les soldes avant la fusion.
• Évitez de muter la valeur des pièces dans les objets partagés, sauf si cela est nécessaire, afin de réduire les conflits de transactions.

À l'aide de la CLI Sui :

Si vous utilisez la CLI, utilisez la sui clientcommande pour fusionner :

sui client merge-coin \
  --primary-coin <coin_object_id_to_keep> \
  --coin-to-merge <coin_object_id_to_destroy> \
  --gas-budget 20000000

Cela permet de fusionner la deuxième pièce avec la première. La deuxième pièce sera consommée.

Dans le SDK TypeScript :

import { TransactionBlock } from "@mysten/sui.js";

const tx = new TransactionBlock();
tx.mergeCoins(
  tx.object(primaryCoinId),
  [tx.object(secondaryCoinId)]
);

Erreurs courantes :

• TypeMismatchapparaît si les types de pièces ne correspondent pas.
• Object not mutablesi vous essayez de fusionner avec une pièce immuable ou empruntée.
• Object not foundlorsque vous faites référence à des objets supprimés ou collectés à la poubelle sur Testnet après un effacement.

La fusion d'objets en pièces est cruciale pour contrôler les soldes de style Utxo en Sui. Cela permet également de réduire la consommation de gaz lors de l'exécution de plusieurs transactions. Vous pouvez en savoir plus sur la gestion des pièces dans la documentation Sui Move.

Fusion d'objets de monnaie dans Sui Move

Dans le modèle d'objet de Sui, les pièces sont des objets de première classe qui doivent être fusionnés explicitement à l'aide de la Coin::joinfonction de la bibliothèque standard (0x2::coin). Contrairement aux chaînes EVM où les soldes de jetons sont stockés dans des mappages, Sui représente chaque solde de pièces comme un objet distinct.

Mise en œuvre de base

use sui::coin::{Self, Coin};
use sui::transfer;

public entry fun merge_coins(
    mut primary_coin: Coin,
    coin_to_merge: Coin,
    ctx: &mut TxContext
) {
    // Validate ownership (both coins must belong to sender)
    assert!(object::is_owner(&primary_coin, tx_context::sender(ctx)), 0x1);
    
    // Join the coins (adds value of coin_to_merge to primary_coin)
    Coin::join(&mut primary_coin, coin_to_merge);
    
    // Transfer the merged coin back to sender
    transfer::transfer(primary_coin, tx_context::sender(ctx));
}

Détails techniques clés

1.Exigences relatives à la propriété des objets :

• Les deux pièces doivent appartenir à l'expéditeur de la transaction
• Vérifiez auprès de vous object::is_owner()avant de fusionner
• Ne jamais fusionner des objets partagés (cela provoquerait une erreur d'exécution)

2.Optimisation du gaz :

• La fusion est nettement moins coûteuse que la division (1 fusion contre plusieurs divisions)
• Évitez les fusions inutiles : les portefeuilles Sui consolident automatiquement les pièces
• Modèle idéal : fusionnez avant les transferts importants, divisez uniquement en cas de besoin

3.Exemple d'utilisation de la CLI :

  # First, get coin IDs
  sui client objects --address $MY_ADDRESS
  
  # Merge two coins (primary first, then the one to merge)
  sui client call \
    --package 0x2 \
    --module coin \
    --function join \
    --args "$PRIMARY_COIN_ID" "$COIN_TO_MERGE_ID" \
    --gas-budget 10000

Considérations spécifiques à Sui-Specific par rapport à EVM

-Pas de suivi du solde : chaque pièce est un objet distinct (EVM utilise un stockage de solde unique) -Types linéaires : après la fusion, coin_to_mergeils sont consommés (ne peuvent plus être utilisés) -Aucun risque de réentrée : les objets en pièces sont de type linéaire (automatiquement appliqué par Move) -Implications sur le gaz : la fusion réduit le nombre d'objets et réduit les coûts futurs du gaz

Erreurs courantes et solutions

Modèle de meilleures pratiques pour les projets DeFi/NFT

// Always validate before merging
public entry fun safe_merge(
    mut target: Coin,
    source: Coin,
    ctx: &mut TxContext
) acquires /* any resources */ {
    let sender = tx_context::sender(ctx);
    assert!(object::is_owner(&target, sender), E_NOT_OWNER);
    assert!(object::is_owner(&source, sender), E_NOT_OWNER);
    assert!(Coin::type_url(&target) == Coin::type_url(&source), E_MISMATCHED_TYPES);
    
    Coin::join(&mut target, source);
    transfer::transfer(target, sender);
}

N'oubliez pas : dans le modèle d'objet de Sui, la fusion de pièces réduit le nombre d'objets que possède votre adresse, ce qui a un impact direct sur les futurs coûts du gaz (moins d'objets = moins de frais de stockage). Contrairement à EVM où la consolidation de l'équilibre s'effectue automatiquement, Sui nécessite des opérations de fusion explicites dans le cadre de la logique de votre application.

Dans Sui, les pièces sont des objets individuels plutôt que des soldes basés sur des comptes, comme dans Ethereum. Lorsque vous recevez plusieurs pièces (telles que des pièces), chacune d'entre elles est autonome et possède son propre identifiant. Pour simplifier l'utilisation ou réduire la consommation d'essence, vous souhaiterez peut-être fusionner deux pièces ou plus en un seul.

Pourquoi la fusion de pièces est importante

Réduit le nombre de pièces, ce qui permet de minimiser la taille des transactions et la consommation d'essence.

Certains DApps et contrats intelligents s'attendent à ce qu'un seul objet soit une pièce en entrée.

Les portefeuilles préfèrent généralement gérer moins de pièces pour plus d'efficacité.

Comment fonctionne la fusion de pièces dans Move

Sui fournit une fonction de fusion dans le module sui : :coin. Voici comment cela fonctionne dans un module Move :

utilisez sui : :coin : : {Self, Coin} ;

merge_example (public fun merge_example) coin_primary : &mut Coin, coin_secondary : Pièce ) { coin : :merge (coin_primary, coin_secondary) ; }

coin_primary est la référence mutable à la pièce qui recevra les fonds.

coin_secondary est la pièce en cours de fusion et sera détruite après la fusion.

Vous devez posséder les deux pièces, car Sui impose une propriété stricte des objets.

Utilisation de la CLI Sui pour fusionner des pièces

Vous pouvez également fusionner des pièces à l'aide de la CLI :

sur le client merge-coin 
<primary_coin_object_id>--pièce principale 
<secondary_coin_object_id>--pièce à fusionner 
--budget gazier 10000

Cette commande combine la valeur de secondary_coin_object_id avec primary_coin_object_id.

Considérations relatives au développement

Assurez-vous toujours que les deux pièces sont du même type (par exemple, les deux pièces).

Si vous ne vérifiez pas la propriété ou si les types ne correspondent pas, des erreurs se produiront.

La fusion est irréversible ; la pièce fusionnée est détruite.

Si vous travaillez dans le cadre de contrats intelligents, vérifiez les types de pièces à l'aide de generics et de type_of.

Meilleures pratiques

Fusionnez régulièrement des pièces plus petites pour réduire le gonflement de l'état et optimiser le stockage.

Lors des transferts, fusionnez au préalable pour envoyer une seule pièce.

Testez avec sui test dans localnet et utilisez sui : :coin : :value pour confirmer les totaux avant et après la fusion.

En comprenant le fonctionnement des pièces de monnaie dans Sui et en les fusionnant correctement, vous pouvez écrire un code plus propre, réduire les coûts de gaz et améliorer la fiabilité des contrats intelligents.

coin::joinÀ utiliser dans Move pour fusionner deux pièces du même type :

####Fonction de déplacement

use sui::coin;

// Merge `coin2` into `coin1` (destroys coin2)
public entry fun merge_coins<T>(
    coin1: &mut coin::Coin<T>,
    coin2: coin::Coin<T>,
) {
    coin::join(coin1, coin2);
}

####Exemple de CLI

sui client call \
    --function merge_coins \
    --module your_module \
    --package 0xYOUR_PACKAGE \
    --args 0xCOIN1_ID 0xCOIN2_ID \
    --gas-budget 10000000

###Remarques clés

1. TMême type seulement : les pièces doivent être du même type (). 2.Économe en gaz : la fusion réduit le nombre d'objets sur la chaîne. 3.Sécurité : aucune signature n'est requise (transfert de valeur pur).

Permet sui::coin::joinde fusionner deux pièces du même type dans Move :

1. use sui::coinModule d'importation de pièces—. 2.Appelez join— Détruit une pièce et ajoute sa valeur à une autre.

###Exemple :

let coin1 = coin::withdraw(&mut treasury, 100);  
let merged = coin::join(coin1, &mut coin2); // coin2 now has +100  

Remarques principales : ✔ Seules les pièces du même type peuvent être fusionnées. ✔ Nécessite une référence mutable à la pièce cible.

Alternative CLI :

sui client merge-coin --primary-coin 0x123 --coin-to-merge 0x456  

Dans Sui, la fusion de deux objets en pièces implique de combiner le solde d'une pièce avec celui d'une autre en utilisant la sémantique de type transfer : :merge de Move, mais plus particulièrement en utilisant la fonction sui : :coin : :merge. Les pièces en Sui ne sont que des objets de type Coin, où T est le type d'actif (par exemple, SUI ou jetons personnalisés). Chaque pièce possède un identifiant d'objet unique, et vous pouvez les fusionner pour consolider les soldes et réduire les frais de gaz liés à la gestion de plusieurs pièces.

Comment ça fonctionne :

1. Fonction Sui Move : utilisez la fonction sui : :coin : :merge (coin1 : &mut Coin, coin2 : Coin) pour fusionner deux pièces.

2. Comportement : Cela transfère la totalité du solde de coin2 dans coin1 et détruit coin2.

3. Propriété : les deux pièces doivent appartenir à la même adresse/au même objet lors de la fusion.

Exemple de code de déplacement

utilisez sui : :coin : : {Self, Coin} ; utilisez sui : :tx_context : : {Self, TxContext} ;

fonds d'entrée publique merge_my_coins ( coin_primary : &mut Coin, coin_secondary : Pièce, ) { coin : :merge (coin_primary, coin_secondary) ; }

Exemple de Sui CLI

Si vous le faites via la CLI ou le SDK (comme TypeScript) :

<PACKAGE_ID>lors de l'appel client --package 
<MODULE_NAME>--module 
--fonction merge_my_coins 
<PRIMARY_COIN_ID><SECONDARY_COIN_ID>--arguments 
--budget gazier 50000000

Remarques principales :

Assurez-vous que le CoinType est correct et cohérent pour les deux pièces.

La pièce secondaire (coin2) est consommée et supprimée après la fusion.

Simulez toujours la transaction à l'aide de l'exécution à sec du client pour détecter les échecs avant de la soumettre.

Si vous utilisez des pièces dynamiques (par exemple, des récompenses ou des frais), leur fusion peut réduire l'encombrement des objets et économiser de l'essence lors des opérations ultérieures.

Erreurs à surveiller :

Objet introuvable : indique un identifiant d'objet erroné ou manquant.

Incompatibilité de type : si les types de pièces diffèrent.

Propriétaire non valide : si la pièce n'appartient pas à l'expéditeur.

En maîtrisant coin : :merge, vous maintenez une gestion plus propre des objets et optimisez la taille des transactions pour les opérations de portefeuille et DeFi sur Sui.

Pour fusionner deux objets en monnaie dans Sui à l'aide de Move, vous utilisez la mergefonction du 0x2::coinmodule. Cela vous permet de combiner la valeur de deux pièces du même type dans un objet et de détruire l'autre. Cette fonctionnalité est utile lorsque les utilisateurs possèdent de nombreuses petites pièces (souvent appelées « poussière ») et souhaitent les regrouper en un plus petit nombre d'objets afin d'économiser de l'essence et de simplifier le suivi.

Dans Move, la syntaxe ressemble à ceci :

use 0x2::coin;

public entry fun merge_coins(coin1: &mut Coin<T>, coin2: Coin<T>) {
    coin::merge(coin1, coin2);
}

Ici, coin1conserve le solde fusionné, tout en coin2étant consommé et détruit au cours du processus. Vous devez transmettre une pièce en tant que référence mutable et l'autre en tant que valeur possédée.

Si vous utilisez la CLI ou le SDK Sui, la fusion s'effectue dans les transactions suivantes :

sui client merge-coin --primary-coin <COIN1_ID> --coin-to-merge <COIN2_ID> --gas-budget 1000000

Ou si vous créez une transaction par programmation (par exemple, à l'aide du SDK TypeScript) :

tx.mergeCoins(primaryCoin, [coinToMerge]);

Un détail clé de Sui est que chaque pièce est un objet réel doté d'un identifiant unique, contrairement aux chaînes EVM où les soldes sont stockés sous forme de chiffres dans des mappages. Ainsi, lorsque vous manipulez des pièces sur Sui, vous travaillez avec des objets physiques plutôt qu'avec de simples chiffres. C'est pourquoi vous devez les fusionner ou les fractionner directement au lieu de mettre à jour une variable de solde.

Les erreurs les plus courantes incluent le fait d'essayer de fusionner des pièces de différents types (comme le SUI et l'USDC), ce qui échouera, ou de passer deux fois la même pièce, ce qui provoquera la panique. Veillez également à ne pas partir du principe que les pièces fusionnées modifient l'identifiant de l'objet. Ce n'est pas le cas. La pièce principale conserve son identifiant d'origine.

Vous pouvez en savoir plus sur la fusion de pièces dans la documentation Sui : https://docs.sui.io/concepts/cryptoeconomics#coin-objects

Dans Sui, les pièces sont des objets de type Coin et peuvent être fusionnées à l'aide de sui : :coin : :merge. La fonction de fusion transfère la totalité du solde d'une pièce à l'autre et supprime la pièce source. Les deux pièces doivent être du même type et appartenir à l'expéditeur. Utilisez l'appel client sui ou le SDK pour invoquer une fonction de fusion dans votre contrat intelligent. Simulez les fusions à l'avance pour éviter des erreurs telles que des incohérences de propriété ou des conflits de types.

###1. Mécanisme de base coinLe module de Sui fournit des fonctions natives pour fusionner des pièces du même type. Contrairement à l'ERC-20 d'EVM (qui utilise des mises à jour de solde), Sui fusionne physiquement des pièces distinctes.

####Principaux avantages -Atomique : l'opération de fusion est tout ou rien -Économe en gaz : aucune écriture de stockage intermédiaire -Composable : fonctionne avec des types de pièces personnalisés

###2. Implémentation de Move ####Fusion de base

module my_module::coin_merger {
    use sui::coin;
    use sui::tx_context;

    // Merge two SUI coins
    public entry fun merge_sui(
        coin1: coin::Coin<SUI>,
        coin2: coin::Coin<SUI>,
        ctx: &mut tx_context::TxContext
    ) {
        let merged_coin = coin::join(&mut coin1, coin2);
        transfer::public_transfer(merged_coin, tx_context::sender(ctx));
    }
}

####Version générique (n'importe quel type de pièce)

public entry fun merge_coins<T>(
        coin1: &mut coin::Coin<T>,
        coin2: coin::Coin<T>
    ) {
    coin::join(coin1, coin2);
}

###3. Utilisation de la CLI ####Fusion manuelle

# 1. Find coins to merge
sui client coins --coin-type 0x2::sui::SUI

# 2. Execute merge
sui client merge-coin \
  --primary-coin 0x123... \
  --coin-to-merge 0x456... \
  --gas-budget 10000000

####Fusion programmatique (TypeScript)

const tx = new TransactionBlock();
tx.mergeCoins(
  tx.object(PRIMARY_COIN_ID),
  [tx.object(SECONDARY_COIN_ID)]
);
await client.signAndExecuteTransactionBlock({
  transactionBlock: tx,
  signer: wallet
});

###4. Considérations architecturales ####Optimisation du gaz

// Batch merging (for wallets/exchanges)
public entry fun batch_merge(
    coins: vector<Coin<SUI>>,
    ctx: &mut TxContext
) {
    let merged = coin::zero(ctx);
    while (!vector::is_empty(&coins)) {
        coin::join(&mut merged, vector::pop_back(&mut coins));
    }
    transfer::public_transfer(merged, sender(ctx));
}

####Modèles de sécurité | Schéma | Mise en œuvre | Objectif | | -------------------------| ---------| |Contrôle de propriété| | assert!(coin::owner(coin) == sender, EOWNER)Empêcher les fusions non autorisées | |Zero-Coin Guard| | Évitez les opérations inutiles assert!(coin::value(coin) > 0, EZERO)|

###5. Gestion des erreurs ####Erreurs courantes | Code d'erreur | Motif | Solution | | --------------------| ----------| ECoinTypeMismatch| coin::coin_type()| Fusion de différents types de pièces | Vérifier | | ECoinBalanceExceeded| Le résultat dépasse u64::MAX| Diviser en plus petites fusions | | EImmutable| Tentative de fusion de pièces immuables | Utiliser la &mutréférence |

####Déplacer le dossier de test

#[test]
fun test_merge_failure() {
    let (coin1, coin2) = test_coins();
    assert!(coin::value(&coin1) + coin::value(&coin2) > MAX, 0);
    let merged = coin::join(&mut coin1, coin2); // Should abort
}

###6. Exemples du monde réel ####Dépôt DeFi Pool

module defi::pool {
    public entry fun deposit(
        user_coin: coin::Coin<USDC>,
        pool: &mut Pool,
        ctx: &mut TxContext
    ) {
        let merged = coin::join(&mut pool.vault, user_coin);
        pool.vault = merged; // Update storage
    }
}

####Place de marché NFT

module market {
    public entry fun consolidate_fees(
        fees: vector<Coin<SUI>>,
        ctx: &mut TxContext
    ) {
        let total = coin::zero(ctx);
        while (!vector::is_empty(&fees)) {
            coin::join(&mut total, vector::pop_back(&mut fees));
        }
        transfer::transfer(total, treasury);
    }
}

###7. Critères de performance | Fonctionnement | Coût du gaz (SUI) | Remarques | | --------------------------| -------| | Fusionner 2 pièces | 1 500 | Coût de base | | Fusion par lots (10 pièces) | 3 800 | 60 % moins chère que la série séquentielle | | Échec de la fusion | 400 | Annulation de l'incompatibilité de type |

###Meilleures pratiques 1.Validation préalable à la fusion

  fun safe_merge(
      coin1: &mut Coin<SUI>,
      coin2: Coin<SUI>
  ) {
      assert!(coin::is_immutable(coin1) == false, EIMMUTABLE);
      assert!(coin::coin_type(coin1) == coin::coin_type(coin2), ETYPE);
      coin::join(coin1, coin2);
  }

2.Intégration du portefeuille

• Fusionnez périodiquement les pièces à poussière
• Résultats de la fusion du cache pour UX

3.Stratégie de test

  sui move test --gas-stats # Profile merge costs