Объединение двух объектов монет в модели программирования Sui Move очень важно, поскольку Sui использует объектно-ориентированную архитектуру, в которой каждый токен представляет собой отдельный объект со своим идентификатором. В этой системе владение тремя монетами стоимостью 1 SUI означает владение тремя разными объектами, а не одним балансом из 3 SUI. Для взаимодействия с протоколами или осуществления переводов часто необходимо объединить их в один объект.

Стандартная библиотека Sui предоставляет функцию слияния в модуле sui: :coin. Для этого нужны две монеты одного типа: одна изменчива и останется, а другая будет израсходована. После слияния стоимость второй монеты прибавляется к стоимости первой, а второй монетный объект уничтожается. Оба монетных предмета должны принадлежать звонящему.

Вот базовая реализация Move:

используйте sui: :coin:: {Self, Coin};

публичный фонд merge_example ( coin_primary: &mut Coin, вторичная монета: монета ) { монета: слияние (монета_первичная монета, вторичная монета); }

В командной строке вы можете объединить монеты с помощью интерфейса командной строки Sui следующим образом:

sui клиент merge-coin
<primary_object_id>--основная монета
--монета для слияния<secondary_object_id>
--бюджет на газ 10000

При этом совокупный баланс будет сохранен в основной монете. Вторичная монета израсходована и больше не может быть использована.

В Sui SDK (например, в TypeScript) ту же операцию можно выполнить программно:

подождите Suiclient.mergeCoin ({ подписавший: «Мой адрес», Основная монета: coin1_id, Слияние монет: coin2_id, Бюджет газа: 10 000 000 долл. США, });

С точки зрения хранения меньшее количество монет снижает сложность хранения и снижает затраты на газ. Перед отправкой, размещением ставок или взаимодействием с контрактами DeFi рекомендуется объединять монеты. Однако могут возникнуть некоторые ошибки. К ним относятся использование неправильного идентификатора объекта, недостаточное количество газа или отсутствие владельца обеих монет.

Чтобы предотвратить ошибки и следовать рекомендациям по безопасности, избегайте повторного использования монеты после ее слияния, следите за согласованностью типов и всегда проверяйте владельца. Объектная модель Sui делает поведение монет более понятным и отслеживаемым, чем модели, основанные на учетных записях.

На практике кошельки обычно автоматически объединяют небольшие монеты, чтобы упростить пользовательский интерфейс. Протоколы DeFi используют это для консолидации вознаграждений или эффективного управления объединенными средствами.

Если вы создаете что-то, связанное с обработкой большого количества монетных объектов, вам будет полезно написать вспомогательные функции, которые можно объединить, прежде чем отправлять транзакции или делать ставки. Эта схема позволяет предотвратить фрагментацию балансов и снизить количество сбоев в транзакциях в блокчейне.

Чтобы объединить два монетных объекта в Move on the Sui Network, вы можете использовать Coinмодуль для перевода баланса одной монеты в другую. Монеты Sui управляются Coinмодулем, и при слиянии обычно происходит перенос всех активов из одного монетного объекта в другой с последующим удалением исходного объекта.

Ключевые понятия:

Coin::merge*Объединение монет: с помощью этой функции вы можете перевести весь баланс с одной монеты на другую. *Пример кода перемещения:

 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для взаимодействия с контрактом после развертывания, например:

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

Лучшие практики:

Coin<u64>* Убедитесь, что монеты одного типа (например, оба).

• Правильно обращайтесь с монетами и проверяйте их право собственности перед слиянием.

Объединение двух монетных объектов в Sui (ход)

В игре Sui монеты представлены в виде объектов Move. Объединение двух монетных объектов подразумевает перенос их стоимости в один монетный объект. Строгая модель владения монетами Move означает, что вы не можете напрямую комбинировать монеты; вместо этого вы можете переводить стоимость одной монеты в другую, фактически «объединяя» монеты.

Ключевые понятия:

*Язык перемещения: созданные монетные объекты остаются неизменными. Объединить их напрямую нельзя, но их стоимость можно перевести в одну монету. *Sui Network: Sui использует ресурсную модель языка Move для обеспечения владения ресурсами (монетами) и контроля над ними.

Шаги по объединению монет:

1.Перенесите стоимость одной монеты в другу. 2.Сожгите вторую монету(необязательно, если вы хотите ее «удалить»).

Пример кода перемещения:

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

Пример интерфейса командной строки:

Объединение монет не является прямой операцией в интерфейсе командной строки, но ее можно выполнить, вызвав функцию в контракте:

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

Распространенные ошибки:

&mut*Проблемы владения: убедитесь, что у вас есть правильные изменяемые ссылки () на объекты монет. *Неверные типы монет: убедитесь, что монеты, которые вы пытаетесь объединить, относятся к одному и тому же типу.

Лучшие практики:

*Избегайте двойных расходов: перед сжиганием всегда проверяйте правильность перевода монет. *Протестируйте в Localnet/Testnet: проверьте логику перед развертыванием, чтобы избежать ошибок в реальных транзакциях.

Чтобы объединить два Coinобъекта в Sui Move, используйте coin::joinфункцию из фреймворка Sui, которая объединяет баланс двух монет одного типа в одну. Во-первых, убедитесь, что обе монеты могут быть изменены и принадлежат лицу, подписавшему транзакцию, поскольку модель владения Суи требует явного разрешения на модификацию объектов. Функция потребляет введенные монеты и создает новую объединенную монету в соответствии с системой линейных типов Sui, где объекты нельзя дублировать или неявно копировать. Эта операция отличается от цепочек EVM, где балансы токенов хранятся в контрактах, а не в виде отдельных объектов.

Чтобы объединить два монетных объекта в Move on the Sui Network, вы используете функцию coin::merge``0x2::coinмодуля. Эта утилита позволяет комбинировать стоимость одного монетного объекта с другим тем же типом, уничтожая источник и сохраняя цель. Это очень важно при работе с фрагментированными балансами в результате нескольких транзакций, особенно для dApps, протоколов DeFi и торговых площадок.

В свой собственный модуль Move вам необходимо включить:

use sui::coin;

Пример кода (в движении):

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

Эта функция принимает изменяемую ссылку на целевую монету и значение исходной монеты. Функция добавляет стоимость исходной монеты в целевую монету и при этом уничтожает исходную монету.

Лучшие практики:

• Убедитесь, что обе монеты относятся к одному типу**(например, обе монеты — SUI или обе — USDC).
• Не указывайте один и тот же объект в обоих аргументах — это вызовет панику.
• Используйте, coin::value(&coin)если вы хотите проверить балансы перед объединением.
• Избегайте изменения стоимости монет в общих объектах без необходимости, чтобы уменьшить количество конфликтов транзакций.

Использование интерфейса командной строки Sui:

sui clientЕсли вы работаете с интерфейсом командной строки, используйте команду для слияния:

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

Таким образом, вторая монета объединяется с первой. Вторая монета будет израсходована.

В TypeScript SDK:

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

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

Распространенные ошибки:

• TypeMismatchвозникает, если типы монет не совпадают.
• Object not mutableесли вы попытаетесь слиться в неизменяемую или заимствованную монету.
• Object not foundкогда вы ссылаетесь на удаленные или собранные в мусор объекты в Testnet после стирания.

Объединение монетных объектов крайне важно для контроля баланса в стиле UTXO в игре Sui. Это также помогает снизить расход газа при выполнении нескольких транзакций. Подробнее о управлении монетами можно прочитать в документации Sui Move.

Объединение монетных объектов в Sui Move

Coin::joinВ объектной модели Sui монеты — это первоклассные объекты, которые необходимо явно объединить с помощью 0x2::coinфункции из стандартной библиотеки (). В отличие от цепочек EVM, где балансы токенов хранятся в виде сопоставлений, Sui представляет баланс каждой монеты как отдельный объект.

Базовая реализация

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

Ключевые технические сведения

1.Требования к владению объектом:

• Обе монеты должны принадлежать отправителю транзакции
• object::is_owner()Перед слиянием проверьте
• Никогда не объединяйте общие объекты (это может привести к ошибке во время выполнения)

2.Оптимизация газа:

• Объединение значительно дешевле, чем разделение (одно слияние вместо нескольких)
• Избегайте ненужных слияний: кошельки Sui а��томатически консолидируют монеты
• Идеальная схема: объединяйтесь перед крупными переводами, разделяйте их только при необходимости

3.Пример использования 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

Особенности специфики и EVM

-Нет отслеживания баланса: каждая монета представляет собой отдельный объект (EVM использует хранилище с единым балансом) -Линейные типы: после слияния coin_to_mergeрасходуется (не может использоваться снова) -Нет рисков, связанных с повторным вхождением: монетные объекты относятся к линейным типам (функция Move автоматически вводит их в действие) -Последствия для газов: слияние позволяет сократить количество объектов и снизить затраты на газ в будущем

Распространенные ошибки и способы их устранения

Шаблон передовой практики для проектов 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);
}

Помните: в объектной модели Суи объединение монет уменьшает количество объектов, принадлежащих вашему адресу, что напрямую влияет на будущие затраты на газ (меньшее количество объектов = снижение платы за хранение). В отличие от EVM, где консолидация баланса происходит автоматически, Sui требует, чтобы операции слияния были частью логики приложения.

В Sui монеты — это отдельные объекты, а не балансы на счетах, как в Ethereum. Когда вы получаете несколько монетных объектов (например, монету), каждый из них представляет собой отдельный объект со своим идентификатором. Чтобы упростить использование или сократить расход газа, вы можете объединить два или более монетных предмета в один.

Почему слияние монет важно

Уменьшает количество монетных объектов, что помогает минимизировать размер транзакции и потребление газа.

В некоторых децентрализованных приложениях и смарт-контрактах в качестве входных данных используется один монетный объект.

Для повышения эффективности кошельки обычно предпочитают управлять меньшим количеством объектов с монетами.

Как работает слияние монет в Move

Sui предоставляет функцию слияния в модуле sui: :coin. Вот как это работает в модуле Move:

используйте sui: :coin:: {Self, Coin};

публичный фонд merge_example ( coin_primary: &mut Coin, вторичная монета: монета ) { монета: слияние (монета_первичная монета, вторичная монета); }

coin_primary — это изменяемая ссылка на монету, которая получит средства.

coin_secondary — это монета, которая объединяется и будет уничтожена после слияния.

Вы должны владеть обоими монетами, так как в Суи действует строгое право собственности на эти объекты.

Использование интерфейса командной строки Sui для объединения монет

Вы также можете объединить монеты с помощью интерфейса командной строки:

подходящий клиент: merge-coin
<primary_coin_object_id>--основная монета
--монета для слияния<secondary_coin_object_id>
--бюджет газа 1000

Эта команда объединяет значение secondary_coin_object_id в primary_coin_object_id.

Рекомендации по разработке

Всегда следите за тем, чтобы оба монетных предмета принадлежали к одному типу (например, обе монеты).

Если вы не проверите владельца или несовпадающие типы, это может привести к ошибкам.

Объединение необратимо; объединенная монета уничтожается.

При работе со смарт-контрактами проверяйте типы монет с помощью generics и type_of.

Лучшие практики

Регулярно объединяйте монеты меньшего размера, чтобы уменьшить раздутие денег и оптимизировать хранение.

Во время переводов предварительно объедините монеты, чтобы отправить одну монету.

Протестируйте с помощью sui test в localnet и используйте sui: :coin: :value для подтверждения итоговых результатов до и после слияния.

Понимая, как функционируют монетные объекты в Sui, и правильно объединяя их, вы сможете писать более чистый код, снизить затраты на газ и повысить надежность смарт-контрактов.

Используйте coin::joinв Move, чтобы объединить две монеты одного типа:

####Функция перемещения

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

####Пример CLI

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

###Ключевые примечания

1. TТолько монеты одного типа: монеты должны быть одинакового типа (). 2.Эффективное использование газа: слияние сокращает количество сетевых объектов. 3.Безопасность: подписи не нужны (чистая передача стоимости).

Используйте sui::coin::joinдля объединения двух монет одного типа в Move:

1. use sui::coinМодуль импорта монет—.
2. joinВызов— уничтожает одну монету и повышает ее стоимость другой.

###Пример:

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

Ключевые примечания: ✔ Объединять можно только монеты одного типа. ✔ Требуется изменяемая ссылка на целевую монету.

Альтернатива CLI:

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

В Sui объединение двух объектов монет предполагает объединение баланса одной монеты в другую с использованием семантики Move, подобной transfer: :merge, а именно с использованием функции sui: :coin: :merge. Монеты в Sui — это просто объекты типа Coin, где T — тип актива (например, SUI или специальные токены). Каждая монета имеет уникальный идентификатор объекта, и вы можете объединить их, чтобы консолидировать балансы и сократить расходы на газ, связанные с управлением несколькими монетами.

Как это работает:

1. Функция Sui Move: используйте функцию sui: :coin: :merge (coin1: &mut Coin, coin2: Coin), чтобы объединить две монеты.

2. Поведение: Это переносит весь баланс coin2 в coin1 и уничтожает coin2.

3. Право собственности: обе монеты должны принадлежать одному и тому же адресу/объекту при слиянии.

Пример кода перемещения

используйте sui: :coin:: {Self, Coin}; используйте sui: :tx_context:: {Self, TxContext};

приложение для публичного входа merge_my_coins ( coin_primary: &mut Coin, вторичная монета: монета, ) { монета: слияние (монета_первичная монета, вторичная монета); }

Пример интерфейса командной строки

Если вы делаете это с помощью интерфейса командной строки или SDK (например, TypeScript):

<PACKAGE_ID>для клиента вызовите --package
<MODULE_NAME>--модуль
--функция merge_my_coins
<PRIMARY_COIN_ID><SECONDARY_COIN_ID>--аргументы
--газовый бюджет 50000 000

Ключевые примечания:

Убедитесь, что CoinType правильный и одинаковый для обеих монет.

После слияния вторичная монета (coin2) расходуется и удаляется.

Всегда моделируйте транзакцию с помощью специального клиента dry-run, чтобы выявить сбои перед отправкой.

При использовании динамических монет (например, вознаграждений или комиссий) их слияние поможет уменьшить беспорядок в объектах и сэкономить на бензине при последующих операциях.

Ошибки, на которые следует обратить внимание:

Объект не найден: указывает неправильный или отсутствующий идентификатор объекта.

Несоответствие типов: если типы монет отличаются.

Неверный владелец: если монета не принадлежит отправителю.

Освоив coin: :merge, вы упростите управление объектами и оптимизируете размер транзакций для операций с кошельком и DeFi в Sui.

Чтобы объединить два монетных объекта в Sui с помощью Move, вы используете mergeфункцию 0x2::coinмодуля. Это позволяет объединить стоимость двух монет одного типа в один объект и уничтожить другой. Эта функция полезна, когда у пользователей есть много мелких монетных предметов (часто называемых «пылью») и они хотят объединить их в меньшее количество объектов, чтобы сэкономить газ и упростить отслеживание.

В Move синтаксис выглядит следующим образом:

use 0x2::coin;

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

Здесь coin1объединенный баланс сохраняет, при этом coin2расходуется и уничтожается. Вы должны передавать одну монету в качестве изменчивого эталона, а другую — в качестве собственной ценности.

Если вы используете интерфейс командной строки Sui или SDK, слияние происходит в следующих транзакциях:

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

Или если вы создаете транзакцию программно (например, с помощью TypeScript SDK):

tx.mergeCoins(primaryCoin, [coinToMerge]);

Ключевой особенностью Sui является то, что каждая монета — это настоящий объект с уникальным идентификатором, в отличие от цепочек EVM, где балансы хранятся в виде чисел в сопоставлениях. Таким образом, когда вы работаете с монетами на Sui, вы работаете с физическими объектами, а не просто с цифрами. Вот почему вы должны объединять или разделять их напрямую, а не обновлять переменную баланса.

К распространенным ошибкам относятся попытки объединить монеты разных типов (например, SUI и USDC), которые не увенчаются успехом, или передача одной и той же монеты дважды, что может вызвать панику. Кроме того, не стоит полагать, что объединённые монеты меняют идентификатор объекта — это не так, ведь исходный идентификатор основной монеты сохраняется.

Подробнее об объединении монет можно прочитать в документации Sui: https://docs.sui.io/concepts/cryptoeconomics#coin-objects

В языке Sui монеты представляют собой объекты типа Coin и могут быть объединены с помощью sui: :coin: :merge. Функция слияния переносит весь баланс с одной монеты на другую и удаляет исходную монету. Обе монеты должны быть одного типа и принадлежать отправителю. Используйте sui client call или SDK, чтобы вызвать функцию слияния в своем смарт-контракте. Заранее смоделируйте слияния, чтобы избежать таких ошибок, как несовпадение прав собственности или конфликты типов.

###1. Основной механизм coinМодуль Sui предоставляет встроенные функции для объединения монет одного типа. В отличие от ERC-20 от EVM (в котором используются обновления баланса), Sui физически объединяет разные монетные объекты.

####Ключевые преимущества -Atomic: операция слияния по принципу «все или ничего» -Эффективное использование газа: отсутствие промежуточных записей в хранилище -Composable: работает с нестандартными типами монет

###2. Внедрение перемещения ####Базовое слияние

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

####Общая версия (любой тип монеты)

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

###3. Использование CLI ####Объединение вручную

# 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

####Программное слияние (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. Архитектурные соображения ####Оптимизация газов

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

####Паттерны безопасности

###5. Обработка ошибок ####Распространенные ошибки

####Переместить тестовый кейс

#[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. Примеры из реальной жизни ####Депозит в пуле Defi

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

####Торговая площадка 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. Бенчмарки производительности | Эксплуатация | Стоимость газа (SUI) | Примечания | -----------| ---------------| | -------| | Объединить 2 монеты | 1 500 | Базовая стоимость | | Пакетное слияние (10 монет) | 3800 | На 60% дешевле последовательного слияния | | Неудачное слияние | 400 | Прервать несоответствие типов |

###Лучшие практики 1.Проверка перед слиянием

  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.Интеграция кошелька

• Периодически объединяйте пылевые монеты
• Результаты слияния кэшей для UX

3.Стратегия тестирования

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