La fusión de dos objetos de monedas en el modelo de programación Sui Move es esencial porque Sui utiliza una arquitectura basada en objetos en la que cada token es un objeto independiente con su propio ID. En este sistema, tener tres monedas con un valor de 1 SUI cada una significa tener tres objetos diferentes, no un saldo de 3 SUI. Para interactuar con los protocolos o realizar transferencias, a menudo es necesario fusionarlos en un solo objeto.

La biblioteca estándar Sui proporciona una función de combinación en el módulo sui: :coin. Se necesitan dos monedas del mismo tipo: una es mutable y permanecerá, y la otra se consumirá. Tras la fusión, el valor de la segunda moneda se suma a la primera y el objeto de la segunda moneda se destruye. Ambos objetos monetarios deben ser propiedad de la persona que llama.

Esta es una implementación básica en Move:

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

fondo público merge_example () coin_primary: &mut Coin, coin_secondary: Moneda ) { coin: :merge (coin_primary, coin_secondary); }

En la línea de comandos, puedes combinar monedas usando la CLI de Sui con:

sui client merge-coin
<primary_object_id>--moneda principal
--moneda para fusionar<secondary_object_id>
--presupuesto de gasolina: 10 000

Esto almacenará el saldo combinado en la moneda principal. La moneda secundaria se ha consumido y ya no se puede usar.

En el SDK de Sui (por ejemplo, con TypeScript), se puede realizar la misma operación mediante programación:

espera a SuiClient.mergeCoin ({ firmante: myAddress, Moneda principal: coin1_id, CoinToMerge: coin2_id, Presupuesto de gas: 10000000, });

Desde el punto de vista del almacenamiento, un menor número de monedas reduce la complejidad y los costos de gas. Combinar monedas es una buena práctica antes de enviar, apostar o interactuar con los contratos de DeFi. Sin embargo, pueden producirse algunos errores. Estos incluyen usar un identificador de objeto incorrecto, no tener suficiente gasolina o no ser el propietario de ambas monedas.

Para evitar errores y seguir las prácticas recomendadas de seguridad, evita reutilizar una moneda una vez que se haya fusionado, asegúrate de que las letras sean coherentes y comprueba siempre la propiedad. El modelo de objetos de Sui hace que el comportamiento de las monedas sea más explícito y rastreable que los modelos basados en cuentas.

En la práctica, las carteras suelen combinar automáticamente monedas pequeñas para simplificar la experiencia del usuario. Los protocolos DeFi utilizan esto para consolidar las recompensas o administrar los fondos mancomunados de manera eficiente.

Si estás creando algo que implique manipular muchos objetos monetarios, es útil escribir funciones de utilidad para fusionarlas antes de enviar transacciones o apostar. Este patrón puede evitar la fragmentación de los saldos y reducir las fallas en las transacciones en cadena.

Para fusionar dos objetos de monedas en Move on the Sui Network, puedes usar el Coinmódulo para transferir el saldo de una moneda a otra. Las monedas Sui son gestionadas por el Coinmódulo y, por lo general, la fusión implica transferir todos los activos de un objeto monetario a otro y, a continuación, eliminar el objeto de origen.

Conceptos clave:

Coin::merge*Combinar monedas: Puedes transferir todo el saldo de una moneda a otra usando la función. *Ejemplo de código de movimiento:

 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: se usa sui clientpara interactuar con el contrato después de la implementación, de la siguiente manera:

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

Mejores prácticas:

Coin<u64>* Asegúrese de que las monedas sean del mismo tipo (por ejemplo, ambas).

• Maneje y compruebe adecuadamente la propiedad de las monedas antes de fusionarlas.

Fusión de dos objetos de monedas en Sui (movimiento)

En Sui, las monedas se representan como objetos Move. La fusión de dos objetos monetarios implica transferir su valor a un solo objeto monetario. El estricto modelo de propiedad de Move significa que no puedes combinar monedas directamente; en su lugar, puedes mover el valor de una moneda a la otra, «fusionándolas» de manera efectiva.

Conceptos clave:

*Idioma de movimiento: Los objetos monetarios son inmutables una vez creados. No puedes fusionarlos directamente, pero puedes transferir su valor a una sola moneda. *Red Sui: Sui utiliza el modelo de recursos del lenguaje Move para reforzar la propiedad y el control de los recursos (monedas).

Pasos para fusionar monedas:

1.Transfiere el valor de una moneda a otra. 2.Quema la segunda moneda(opcional, si quieres «eliminarla»).

Ejemplo de código de movimiento:

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

Ejemplo de CLI:

La fusión de monedas no es una operación directa de la CLI, pero se puede lograr llamando a la función en un contrato:

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

Errores comunes:

&mut*Problemas de propiedad: asegúrese de tener las referencias mutables correctas () a los objetos de la moneda. *Tipos de monedas inválidos: asegúrate de que las monedas que intentas fusionar sean del mismo tipo.

Mejores prácticas:

*Evite gastar doble: asegúrese siempre de que las monedas se transfieran correctamente antes de quemarlas. *Prueba en Localnet/Testnet: valida la lógica antes de la implementación para evitar errores en las transacciones reales.

Para fusionar dos Coinobjetos en Sui Move, usa coin::joinla función del marco Sui, que combina el saldo de dos monedas del mismo tipo en una sola. En primer lugar, asegúrate de que ambas monedas sean mutables y pertenezcan al firmante de la transacción, ya que el modelo de propiedad de Sui requiere un permiso explícito para modificar objetos. La función consume las monedas introducidas y crea una nueva moneda combinada, siguiendo el sistema de tipos lineales de Sui, en el que los objetos no se pueden duplicar ni copiar implícitamente. Esta operación difiere de las cadenas de EVM, en las que los saldos simbólicos se almacenan en contratos y no como objetos distintos.

Para fusionar dos objetos de monedas en Move on the Sui Network, utiliza la función coin::mergedel 0x2::coinmódulo. Esta utilidad te permite combinar el valor de un objeto monetario con otro del mismo tipo, destruyendo la fuente y preservando el objetivo. Esto es esencial cuando se trata de saldos fragmentados de múltiples transacciones, especialmente en el caso de las dApps, los protocolos DeFi y los mercados.

En tu módulo Move personalizado, debes incluir:

use sui::coin;

Código de ejemplo (en movimiento):

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

Esta función toma una referencia mutable a la moneda de destino y un valor para la moneda de origen. La función añade el valor de la moneda de origen a la moneda de destino y destruye la fuente en el proceso.

Mejores prácticas:

• Asegúrese de que ambas monedas sean del mismo tipo**(por ejemplo, ambas son SUI o ambas son USDC).
• Evita pasar el mismo objeto en ambos argumentos, ya que esto provocará pánico.
• coin::value(&coin)Utilízalo si quieres inspeccionar los saldos antes de fusionarlos.
• Evite mutar los valores de las monedas en objetos compartidos, a menos que sea necesario, para reducir los conflictos entre transacciones.

Uso de la CLI de Sui:

Si estás trabajando con la CLI, usa el sui clientcomando para fusionar:

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

Esto fusiona la segunda moneda con la primera. La segunda moneda se consumirá.

En el SDK de TypeScript:

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

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

Errores comunes:

• TypeMismatchocurre si los tipos de monedas no coinciden.
• Object not mutablesi intentas fusionarte en una moneda inmutable o prestada.
• Object not foundal hacer referencia a objetos borrados o recolectados como basura en Testnet después de borrarlos.

Combinar objetos monetarios es crucial para mantener bajo control los equilibrios al estilo de Utxo en Sui. También ayuda a reducir el consumo de gas al ejecutar múltiples transacciones. Puedes obtener más información sobre la gestión de monedas en la documentación de Sui Move.

Fusión de objetos de monedas en Sui Move

Coin::joinEn el modelo de objetos de Sui, las monedas son objetos de primera clase que deben fusionarse explícitamente mediante la 0x2::coinfunción de la biblioteca estándar (). A diferencia de las cadenas EVM, en las que los saldos simbólicos se almacenan en mapeos, Sui representa cada saldo de monedas como un objeto distinto.

Implementación básica

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

Detalles técnicos clave

1.Requisitos de propiedad del objeto:

• Ambas monedas deben ser propiedad del remitente de la transacción
• Verifica con object::is_owner()antes de fusionar
• Nunca combine objetos compartidos (podría provocar un error de tiempo de ejecución)

2.Optimización del gas:

• La fusión es significativamente más barata que la división (una fusión frente a varias divisiones)
• Evita fusiones innecesarias: las carteras Sui consolidan automáticamente las monedas
• Patrón ideal: fusionar antes de realizar grandes transferencias y dividir solo cuando sea necesario

3.Ejemplo de uso 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

Consideraciones específicas de Sui frente a EVM

-Sin seguimiento del saldo: cada moneda es un objeto independiente (la EVM utiliza un único almacenamiento de saldo) -Tipos lineales: después de fusionarse, se consume (no coin_to_mergese puede volver a usar) -Sin riesgo de reentración: los objetos con monedas son de tipo lineal (Move los aplica automáticamente) -Implicaciones en materia de gas: la fusión reduce el número de objetos y reduce los costos futuros de gas

Errores y soluciones comunes

Patrón de mejores prácticas para proyectos de 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);
}

Recuerde: en el modelo de objetos de Sui, la fusión de monedas reduce la cantidad de objetos que posee su dirección, lo que afecta directamente a los costos futuros de gas (menos objetos = tarifas de almacenamiento más bajas). A diferencia de EVM, donde la consolidación del saldo se realiza automáticamente, Sui requiere operaciones de fusión explícitas como parte de la lógica de la aplicación.

En Sui, las monedas son objetos individuales en lugar de saldos basados en cuentas como en Ethereum. Cuando recibes varios objetos monetarios (como Coin), cada uno es un objeto independiente con su propio identificador. Para simplificar el uso o reducir el consumo de gasolina, puedes combinar dos o más objetos con forma de moneda en uno solo.

Por qué es importante fusionar monedas

Reduce la cantidad de objetos con monedas, lo que ayuda a minimizar el tamaño de las transacciones y el consumo de gas.

Algunas dApps y contratos inteligentes requieren un único objeto de moneda como entrada.

Por lo general, los monederos prefieren gestionar menos objetos con monedas por motivos de eficiencia.

Cómo funciona la fusión de monedas en Move

Sui proporciona una función de fusión en el módulo sui: :coin. Así es como funciona en un módulo Move:

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

fondo público merge_example () coin_primary: &mut Coin, coin_secondary: Moneda ) { coin: :merge (coin_primary, coin_secondary); }

coin_primary es la referencia mutable a la moneda que recibirá los fondos.

coin_secondary es la moneda que se está fusionando y se destruirá después de la fusión.

Debes ser propietario de ambas monedas, ya que Sui impone una propiedad estricta de los objetos.

Uso de la CLI de Sui para fusionar monedas

También puedes combinar monedas mediante la CLI:

sui client merge-coin
<primary_coin_object_id>--moneda principal
--moneda para fusionar<secondary_coin_object_id>
--presupuesto de gasolina 10000

Este comando combina el valor de secondary_coin_object_id en primary_coin_object_id.

Consideraciones sobre el desarrollo

Asegúrese siempre de que ambas monedas sean del mismo tipo (por ejemplo, ambas monedas).

Si no se comprueba la propiedad o si los tipos no coinciden, se producirán errores.

La fusión es irreversible; la moneda fusionada se destruye.

Si trabajas con contratos inteligentes, verifica los tipos de monedas usando genéricos y type_of.

Mejores prácticas

Combina regularmente monedas más pequeñas para reducir la sobrecarga estatal y optimizar el almacenamiento.

Durante las transferencias, combínalas previamente para enviar una sola moneda.

Prueba con sui test en localnet y usa sui: :coin: :value para confirmar los totales antes y después de la fusión.

Si entiendes cómo funcionan los objetos con monedas en Sui y los combinas correctamente, puedes escribir un código más limpio, reducir los costos de gasolina y mejorar la confiabilidad de los contratos inteligentes.

Utilízalo coin::joinen Move para combinar dos monedas del mismo tipo:

####Función de movimiento

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

####Ejemplo de CLI

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

###Notas clave

1. TSolo del mismo tipo: las monedas deben ser del mismo tipo (). 2.Ahorro de gas: la fusión reduce los objetos en cadena. 3.Seguridad: no se necesitan firmas (pura transferencia de valor).

Se usa sui::coin::joinpara combinar dos monedas del mismo tipo en Move:

1. use sui::coinMódulo de importación de monedas—.
2. joinLlamad: destruye una moneda y añade su valor a otra.

###Ejemplo:

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

Notas clave: ✔ Solo se pueden fusionar monedas del mismo tipo. ✔ Requiere una referencia mutable a la moneda objetivo.

Alternativa a la CLI:

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

En Sui, la fusión de dos objetos de monedas implica combinar el saldo de una moneda con otra utilizando la semántica similar a transfer: :merge de Move, pero específicamente utilizando la función sui: :coin: :merge. En Sui, las monedas son solo objetos del tipo Coin, donde T es el tipo de activo (p. ej., SUI o fichas personalizadas). Cada moneda tiene un identificador de objeto único, y puedes combinarlas para consolidar los saldos y reducir los gastos de gasolina derivados de la gestión de varios objetos con monedas.

Cómo funciona:

1. Función Sui Move: Usa la función sui: :coin: :merge (coin1: &mut Coin, coin2: Coin) para combinar dos monedas.

2. Comportamiento: Esto transfiere todo el saldo de coin2 a coin1 y destruye la coin2.

3. Propiedad: Ambas monedas deben pertenecer a la misma dirección/objeto al ejecutar la fusión.

Ejemplo de código de movimiento

usa sui: :coin:: {Self, Coin}; usa sui: :tx_context:: {Self, txContext};

entrada pública: run merge_my_coins ( coin_primary: &mut Coin, coin_secondary: Moneda, ) { coin: :merge (coin_primary, coin_secondary); }

Ejemplo de CLI de Sui

Si lo haces mediante CLI o SDK (como TypeScript):

<PACKAGE_ID>Su cliente llama --package
<MODULE_NAME>--módulo
--función merge_my_coins
<PRIMARY_COIN_ID><SECONDARY_COIN_ID>--argumentos
--presupuesto de gas 50 000

Notas clave:

Asegúrese de que el tipo de moneda sea correcto y coherente para ambas monedas.

La moneda secundaria (coin2) se consume y se elimina tras la fusión.

Simule siempre la transacción utilizando el sistema de ejecución en seco de su cliente para detectar errores antes de enviarla.

Si utilizas monedas dinámicas (por ejemplo, recompensas o comisiones), combinarlas puede reducir el desorden de objetos y ahorrar gasolina en operaciones posteriores.

Errores a los que hay que prestar atención:

Objeto no encontrado: indica que el ID del objeto es incorrecto o falta.

Los tipos no coinciden: si los tipos de monedas son diferentes.

Propietario no válido: si la moneda no es propiedad del remitente.

Al dominar coin: :merge, mantienes una gestión más limpia de los objetos y optimizas el tamaño de las transacciones para las operaciones de monedero y DeFi en Sui.

Para fusionar dos objetos de monedas en Sui usando Move, usa la mergefunción del 0x2::coinmódulo. Esto te permite combinar el valor de dos monedas del mismo tipo en un objeto y destruir el otro. Esta función resulta útil cuando los usuarios tienen muchas monedas pequeñas (a menudo denominadas «polvo») y desean unirlas en menos objetos para ahorrar combustible y simplificar el rastreo.

En Move, la sintaxis es la siguiente:

use 0x2::coin;

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

Aquí, coin1mantiene el saldo fusionado, mientras coin2se consume y se destruye en el proceso. Debes pasar una moneda como referencia mutable y la otra como valor propio.

Si utilizas la CLI o el SDK de Sui, la fusión se produce en transacciones como las siguientes:

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

O si estás creando una transacción mediante programación (por ejemplo, usando el SDK de TypeScript):

tx.mergeCoins(primaryCoin, [coinToMerge]);

Un detalle clave de Sui es que cada moneda es un objeto real con un identificador único, a diferencia de las cadenas EVM, en las que los saldos se almacenan como números en las asignaciones. Por lo tanto, cuando trabajas con monedas en Sui, trabajas con objetos físicos y no solo con números. Por eso tienes que fusionarlos o dividirlos directamente en lugar de actualizar una variable de saldo.

Entre los errores más comunes se encuentran intentar fusionar monedas de diferentes tipos (como el SUI y el USDC), lo que fracasará, o pasar la misma moneda dos veces, lo que provocará pánico. También debes tener cuidado de no dar por sentado que las monedas combinadas cambian el ID del objeto, pero no es así. La moneda principal conserva su ID original.

Puedes obtener más información sobre la fusión de monedas en los documentos de Sui: https://docs.sui.io/concepts/cryptoeconomics#coin-objects

En Sui, las monedas son objetos de tipo Coin y se pueden combinar usando sui: :coin: :merge. La función de combinación transfiere todo el saldo de una moneda a otra y elimina la moneda de origen. Ambas monedas deben ser del mismo tipo y pertenecer al remitente. Usa sui client call o el SDK para invocar una función de fusión en tu contrato inteligente. Simule las fusiones de antemano para evitar errores como desajustes de propiedad o conflictos de tipos.

1. Mecanismo central**

El coinmódulo de Sui proporciona funciones nativas para fusionar monedas del mismo tipo. A diferencia del ERC-20 de EVM (que utiliza actualizaciones de equilibrio), Sui fusiona físicamente distintos objetos monetarios.

####Ventajas clave -Atomic: la operación de fusión es todo o nada -Eficiencia del consumo de gas: sin escrituras de almacenamiento intermedias -Composable: funciona con tipos de monedas personalizados

2. Trasladar la implementación**

####Fusión basica

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

####Versión genérica (cualquier tipo de moneda)

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

3. Uso de CLI**

####Fusión manual

# 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

####Combinación programática (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. Consideraciones arquitectónicas** ####Optimización del gas

// 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));
}

####Patrones de seguridad

###5. Gestión de errores** ####Errores comunes

####Caso de prueba de movimiento

#[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. Ejemplos del mundo real** ####DeFi Pool Deposit

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

####Mercado de 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. Puntos de referencia de rendimiento**

###Mejores Prácticas 1.Validación previa a la fusión

  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.Integración de billetera

• Combina monedas de polvo periódicamente
• Almacene en caché los resultados de la combinación para UX

3.Estrategia de pruebas

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