Move on Sui入门 004-在sui链上发布Coin合约和Faucet Coin合约

Gavin
更新于 1天前
阅读 104

一、知识点一次性见证（OneTimeWitness）设计模式coin模块的使用transfer模块public_transfer和public_share_object的用法和理解发行代币的理解二、代码1、发行一个Coin合约创建项目运行命令：suimove

### 一、知识点
1. 一次性见证（One Time Witness）设计模式
2. coin模块的使用
3. transfer模块 public_transfer 和 public_share_object 的用法和理解
4. 发行代币的理解

### 二、代码
#### 1、发行一个Coin合约
1. 创建项目
+ 运行命令：sui move new privatecoin
+ 修改项目依赖，Move.toml文件中的git地址，将github替换为gitee
+ 删除privatecoin.move中的注释部分

2. 创建一次性见证结构体
+ 只有drop能力
+ 没有字段
+ 不是泛型字段
+ 以module名称的大写字母命名

```
// 一次性见证结构体，one-time-witness，要有drop能力
public struct PRIVATECOIN has drop {}
```

3. 初始化init函数
+ 使用coin::create_currency()方法创建代币
+ 使用transfer::public_transfer()方法转移铸币的权限凭证给合约部署者

```
// 初始化init函数
// witness：一次性证明，用于验证代币的唯一性和创造者的权限。
// ctx：交易上下文，用于处理交易中的各种状态和信息。
fun init(otw: PRIVATECOIN, ctx: &mut TxContext) {
    // 使用 coin 模块的 create_currency 函数来创建代币
    // treasuryCap：权限凭证，持有此凭证者有权铸造代币，coinMetadata：代币的元数据，如名称、符号、描述等信息。
    let (treasuryCap, coinMetadata) = coin::create_currency(
        otw, // 一次性证明，用于确认铸币操作的合法性
        6, // 代币的小数位数
        b"private coin", // 代币的符号
        b"private coin", // 代币的名称
        b"this is a private coin", // 代币的信息描述
                 option::some(url::new_unsafe_from_bytes(b"https://himg.bdimg.com/sys/portraitn/item/public.1.e9f8c73.BSHSEfneCaeAXqEhmsNv0A")), // 代币的图标
        ctx // 交易上下文对象
    );
    // 冻结代币元数据，阻止后续的修改，把对象变成不可变对象
    transfer::public_freeze_object(coinMetadata);
    // treasury 是一个特殊的对象，它控制着代币的铸造权限。只有拥有 TreasuryCap 的实体才能铸造新的代币
    // 将铸币的权限凭证转移到合约部署者，拥有铸币权才能铸造代币
    transfer::public_transfer(treasuryCap, ctx.sender());
}
```

4. 实现铸币方法
+ 第一种方法：使用coin::mint()方法铸币，使用transfer::public_transfer()方法转移代币
+ 第二种方法：使用coin::mint_and_transfer()方法铸造并转移代币
+ 以上两种方法都要传入铸币权限、铸币数量、接收者地址和 TxContext交易上下文对象

```
// 铸造代币函数，需要参数：铸币权限、铸币数量、接收代币地址、交易上下文
public entry fun mint(treasuryCap: &mut coin::TreasuryCap<PRIVATECOIN>, amount: u64, recipient: address, ctx: &mut TxContext) {
    // 方法一：使用coin::mint()函数铸币，使用transfer::public_transfer()方法转移代币
    let coin = coin::mint(treasuryCap, amount, ctx);
    transfer::public_transfer(coin, recipient);
    // 方法二：使用coin::mint_and_transfer()完成铸币和转移
    // coin::mint_and_transfer(treasuryCap, amount, recipient, ctx)
}
```

5. 实现销毁代币方法
+ 使用coin::burn()方法销毁代币

```
// 销毁代币，使用coin::burn()方法
public entry fun burn(treasuryCap: &mut coin::TreasuryCap<PRIVATECOIN>, coin: Coin<PRIVATECOIN>) {
    coin::burn(treasuryCap, coin);
}
```

6. 完整代码

```
module privatecoin::privatecoin;
use std::option;
use sui::coin;
use sui::coin::Coin;
use sui::transfer;
use sui::url;

// 一次性见证结构体，one-time-witness，要有drop能力
public struct PRIVATECOIN has drop {}

// 初始化init函数
// witness：一次性证明，用于验证代币的唯一性和创造者的权限。
// ctx：交易上下文，用于处理交易中的各种状态和信息。
fun init(otw: PRIVATECOIN, ctx: &mut TxContext) {
    // 使用 coin 模块的 create_currency 函数来创建代币
    // treasuryCap：权限凭证，持有此凭证者有权铸造代币，coinMetadata：代币的元数据，如名称、符号、描述等信息。
    let (treasuryCap, coinMetadata) = coin::create_currency(
        otw, // 一次性证明，用于确认铸币操作的合法性
        6, // 代币的小数位数
        b"private coin", // 代币的符号
        b"private coin", // 代币的名称
        b"this is a private coin", // 代币的信息描述
        option::some(url::new_unsafe_from_bytes(b"https://himg.bdimg.com/sys/portraitn/item/public.1.e9f8c73.BSHSEfneCaeAXqEhmsNv0A")), // 代币的图标
        ctx // 交易上下文对象
    );
    // 冻结代币元数据，阻止后续的修改，把对象变成不可变对象
    transfer::public_freeze_object(coinMetadata);
    // treasury 是一个特殊的对象，它控制着代币的铸造权限。只有拥有 TreasuryCap 的实体才能铸造新的代币
    // 将铸币的权限凭证转移到合约部署者，拥有铸币权才能铸造代币
    transfer::public_transfer(treasuryCap, ctx.sender());
}

// 铸造代币函数，需要参数：铸币权限、铸币数量、接收代币地址、交易上下文
public entry fun mint(treasuryCap: &mut coin::TreasuryCap<PRIVATECOIN>, amount: u64, recipient: address, ctx: &mut TxContext) {
    // 方法一：使用coin::mint()函数铸币，使用transfer::public_transfer()方法转移代币
    let coin = coin::mint(treasuryCap, amount, ctx);
    transfer::public_transfer(coin, recipient);
    // 方法二：使用coin::mint_and_transfer()完成铸币和转移
    // coin::mint_and_transfer(treasuryCap, amount, recipient, ctx)
}
// 销毁代币，使用coin::burn()方法
public entry fun burn(treasuryCap: &mut coin::TreasuryCap<PRIVATECOIN>, coin: Coin<PRIVATECOIN>) {
    coin::burn(treasuryCap, coin);
}
```

#### 2、发行一个Faucet Coin合约
1. 创建项目
+ 运行命令：sui move new publiccoin
+ 修改项目依赖，Move.toml文件中的git地址，将github替换为gitee
+ 删除publiccoin.move中的注释部分

2. 创建一次性见证结构体
+ 只有drop能力
+ 没有字段
+ 不是泛型字段
+ 以module名称的大写字母命名

```
// 一次性见证结构体，one-time-witness，要有drop能力
public struct PUBLICCOIN has drop {}
```

3. 初始化init函数
+ 使用coin::create_currency()方法创建代币
+ 使用transfer::public_share_object()方法共享铸币权

```
// 初始化init函数
// witness：一次性证明，用于验证代币的唯一性和创造者的权限。
// ctx：交易上下文，用于处理交易中的各种状态和信息。
fun init(otw: PUBLICCOIN, ctx: &mut TxContext) {
    // 使用 coin 模块的 create_currency 函数来创建代币
    // treasuryCap：权限凭证，持有此凭证者有权铸造代币，coinMetadata：代币的元数据，如名称、符号、描述等信息。
    let (treasuryCap, coinMetadata) = coin::create_currency(
        otw, // 一次性证明，用于确认铸币操作的合法性
        6, // 代币的小数位数
        b"public coin", // 代币的符号
        b"public coin", // 代币的名称
        b"this is a public coin", // 代币的信息描述
        option::some(url::new_unsafe_from_bytes(b"https://himg.bdimg.com/sys/portraitn/item/public.1.e9f8c73.BSHSEfneCaeAXqEhmsNv0A")), // 代币的图标
        ctx // 交易上下文对象
    );
    // 冻结代币元数据，阻止后续的修改，把对象变成不可变对象
    transfer::public_freeze_object(coinMetadata);
    // treasury 是一个特殊的对象，它控制着代币的铸造权限。只有拥有 TreasuryCap 的实体才能铸造新的代币
    // 共享铸币权
    transfer::public_share_object(treasuryCap);
```

```
// 铸造代币函数，需要参数：铸币权限、铸币数量、接收代币地址、交易上下文
public entry fun mint(treasuryCap: &mut coin::TreasuryCap<PUBLICCOIN>, amount: u64, recipient: address, ctx: &mut TxContext) {
    // 方法一：使用coin::mint()函数铸币，使用transfer::public_transfer()方法转移代币
    let coin = coin::mint(treasuryCap, amount, ctx);
    transfer::public_transfer(coin, recipient);
    // 方法二：使用coin::mint_and_transfer()完成铸币和转移
    // coin::mint_and_transfer(treasuryCap, amount, recipient, ctx)
}
```

5. 实现销毁代币方法
+ 使用coin::burn()方法销毁代币

```
// 销毁代币，使用coin::burn()方法
public entry fun burn(treasuryCap: &mut coin::TreasuryCap<PUBLICCOIN>, coin: Coin<PUBLICCOIN>) {
    coin::burn(treasuryCap, coin);
}
```

6. 完整代码

```
module publiccoin::publiccoin;
use std::option;
use sui::coin;
use sui::coin::Coin;
use sui::transfer;
use sui::url;

// 一次性见证结构体，one-time-witness，要有drop能力
public struct PUBLICCOIN has drop {}

// 初始化init函数
// witness：一次性证明，用于验证代币的唯一性和创造者的权限。
// ctx：交易上下文，用于处理交易中的各种状态和信息。
fun init(otw: PUBLICCOIN, ctx: &mut TxContext) {
    // 使用 coin 模块的 create_currency 函数来创建代币
    // treasuryCap：权限凭证，持有此凭证者有权铸造代币，coinMetadata：代币的元数据，如名称、符号、描述等信息。
    let (treasuryCap, coinMetadata) = coin::create_currency(
        otw, // 一次性证明，用于确认铸币操作的合法性
        6, // 代币的小数位数
        b"public coin", // 代币的符号
        b"public coin", // 代币的名称
        b"this is a public coin", // 代币的信息描述
        option::some(url::new_unsafe_from_bytes(b"https://himg.bdimg.com/sys/portraitn/item/public.1.e9f8c73.BSHSEfneCaeAXqEhmsNv0A")), // 代币的图标
        ctx // 交易上下文对象
    );
    // 冻结代币元数据，阻止后续的修改，把对象变成不可变对象
    transfer::public_freeze_object(coinMetadata);
    // treasury 是一个特殊的对象，它控制着代币的铸造权限。只有拥有 TreasuryCap 的实体才能铸造新的代币
    // 共享铸币权
    transfer::public_share_object(treasuryCap);
}

// 铸造代币函数，需要参数：铸币权限、铸币数量、接收代币地址、交易上下文
public entry fun mint(treasuryCap: &mut coin::TreasuryCap<PUBLICCOIN>, amount: u64, recipient: address, ctx: &mut TxContext) {
    // 方法一：使用coin::mint()函数铸币，使用transfer::public_transfer()方法转移代币
    let coin = coin::mint(treasuryCap, amount, ctx);
    transfer::public_transfer(coin, recipient);
    // 方法二：使用coin::mint_and_transfer()完成铸币和转移
    // coin::mint_and_transfer(treasuryCap, amount, recipient, ctx)
}
// 销毁代币，使用coin::burn()方法
public entry fun burn(treasuryCap: &mut coin::TreasuryCap<PUBLICCOIN>, coin: Coin<PUBLICCOIN>) {
    coin::burn(treasuryCap, coin);
}
```

#### 3、两个Coin合约对比
通过代码对比可以看到，两个项目的代码差别只有一处，就是关于铸币权限凭证 treasuryCap 的处理，privatecoin项目将铸币权限凭证 treasuryCap 转移给了合约部署者，publiccoin项目将铸币权限凭证 treasuryCap 共享给了所有用户。

### 三、调用
两个合约的调用方法基本一致

+ 编译合约：sui move build
+ 发布合约：sui client publish
    - 发布成功，找到项目 Transaction Digest，在sui浏览器输入打开
    - 找到合约相关object ID，提供给mint和burn方法

![1732245705896.jpg](https://img.learnblockchain.cn/attachments/2024/11/66tIkM8y673ffe8990a83.jpg)

+ 调用mint方法：
```
sui client call --package <package ID> --module <module> --function <function> --args <args1 args2 ...>
```
    - 铸币成功后，找到 Transaction Digest，在sui浏览器输入打开
    - 找到代币object ID，提供给burn方法使用

![1732246199054.jpg](https://img.learnblockchain.cn/attachments/2024/11/AbKLgc0i673ffe9586512.jpg)

+ 调用burn方法：
```
sui client call --package <package ID> --module <module> --function <function> --args <args1 args2 ...>
```
### 四、结论
通过不同合约的方法调用我们可以得出以下结论

+ privatecoin合约：合约发布者拥有铸币凭证权限，可以给不同地址铸造代币，但是合约发布者只能销毁自己拥有的代币；其他地址既不能铸造代币，也不能销毁代币
+ publiccoin合约：所用地址都拥有铸币凭证权限，可以给不同地址铸造代币，但只能销毁自己拥有的代币
+ 不管有没有权限凭证，每个地址拥有的资产只能由该地址销毁

一、知识点

一次性见证（One Time Witness）设计模式
coin模块的使用
transfer模块 public_transfer 和 public_share_object 的用法和理解
发行代币的理解

二、代码

1、发行一个Coin合约

创建项目
- 运行命令：sui move new privatecoin
- 修改项目依赖，Move.toml文件中的git地址，将github替换为gitee
- 删除privatecoin.move中的注释部分
创建一次性见证结构体
- 只有drop能力
- 没有字段
- 不是泛型字段
- 以module名称的大写字母命名

// 一次性见证结构体，one-time-witness，要有drop能力
public struct PRIVATECOIN has drop {}

初始化init函数
- 使用coin::create_currency()方法创建代币
- 使用transfer::public_transfer()方法转移铸币的权限凭证给合约部署者

// 初始化init函数
// witness：一次性证明，用于验证代币的唯一性和创造者的权限。
// ctx：交易上下文，用于处理交易中的各种状态和信息。
fun init(otw: PRIVATECOIN, ctx: &mut TxContext) {
    // 使用 coin 模块的 create_currency 函数来创建代币
    // treasuryCap：权限凭证，持有此凭证者有权铸造代币，coinMetadata：代币的元数据，如名称、符号、描述等信息。
    let (treasuryCap, coinMetadata) = coin::create_currency(
        otw, // 一次性证明，用于确认铸币操作的合法性
        6, // 代币的小数位数
        b"private coin", // 代币的符号
        b"private coin", // 代币的名称
        b"this is a private coin", // 代币的信息描述
                 option::some(url::new_unsafe_from_bytes(b"https://himg.bdimg.com/sys/portraitn/item/public.1.e9f8c73.BSHSEfneCaeAXqEhmsNv0A")), // 代币的图标
        ctx // 交易上下文对象
    );
    // 冻结代币元数据，阻止后续的修改，把对象变成不可变对象
    transfer::public_freeze_object(coinMetadata);
    // treasury 是一个特殊的对象，它控制着代币的铸造权限。只有拥有 TreasuryCap 的实体才能铸造新的代币
    // 将铸币的权限凭证转移到合约部署者，拥有铸币权才能铸造代币
    transfer::public_transfer(treasuryCap, ctx.sender());
}

实现铸币方法
- 第一种方法：使用coin::mint()方法铸币，使用transfer::public_transfer()方法转移代币
- 第二种方法：使用coin::mint_and_transfer()方法铸造并转移代币
- 以上两种方法都要传入铸币权限、铸币数量、接收者地址和 TxContext交易上下文对象

// 铸造代币函数，需要参数：铸币权限、铸币数量、接收代币地址、交易上下文
public entry fun mint(treasuryCap: &mut coin::TreasuryCap&lt;PRIVATECOIN>, amount: u64, recipient: address, ctx: &mut TxContext) {
    // 方法一：使用coin::mint()函数铸币，使用transfer::public_transfer()方法转移代币
    let coin = coin::mint(treasuryCap, amount, ctx);
    transfer::public_transfer(coin, recipient);
    // 方法二：使用coin::mint_and_transfer()完成铸币和转移
    // coin::mint_and_transfer(treasuryCap, amount, recipient, ctx)
}

实现销毁代币方法
- 使用coin::burn()方法销毁代币

// 销毁代币，使用coin::burn()方法
public entry fun burn(treasuryCap: &mut coin::TreasuryCap&lt;PRIVATECOIN>, coin: Coin&lt;PRIVATECOIN>) {
    coin::burn(treasuryCap, coin);
}

完整代码

module privatecoin::privatecoin;
use std::option;
use sui::coin;
use sui::coin::Coin;
use sui::transfer;
use sui::url;

// 一次性见证结构体，one-time-witness，要有drop能力
public struct PRIVATECOIN has drop {}

// 初始化init函数
// witness：一次性证明，用于验证代币的唯一性和创造者的权限。
// ctx：交易上下文，用于处理交易中的各种状态和信息。
fun init(otw: PRIVATECOIN, ctx: &mut TxContext) {
    // 使用 coin 模块的 create_currency 函数来创建代币
    // treasuryCap：权限凭证，持有此凭证者有权铸造代币，coinMetadata：代币的元数据，如名称、符号、描述等信息。
    let (treasuryCap, coinMetadata) = coin::create_currency(
        otw, // 一次性证明，用于确认铸币操作的合法性
        6, // 代币的小数位数
        b"private coin", // 代币的符号
        b"private coin", // 代币的名称
        b"this is a private coin", // 代币的信息描述
        option::some(url::new_unsafe_from_bytes(b"https://himg.bdimg.com/sys/portraitn/item/public.1.e9f8c73.BSHSEfneCaeAXqEhmsNv0A")), // 代币的图标
        ctx // 交易上下文对象
    );
    // 冻结代币元数据，阻止后续的修改，把对象变成不可变对象
    transfer::public_freeze_object(coinMetadata);
    // treasury 是一个特殊的对象，它控制着代币的铸造权限。只有拥有 TreasuryCap 的实体才能铸造新的代币
    // 将铸币的权限凭证转移到合约部署者，拥有铸币权才能铸造代币
    transfer::public_transfer(treasuryCap, ctx.sender());
}

// 铸造代币函数，需要参数：铸币权限、铸币数量、接收代币地址、交易上下文
public entry fun mint(treasuryCap: &mut coin::TreasuryCap&lt;PRIVATECOIN>, amount: u64, recipient: address, ctx: &mut TxContext) {
    // 方法一：使用coin::mint()函数铸币，使用transfer::public_transfer()方法转移代币
    let coin = coin::mint(treasuryCap, amount, ctx);
    transfer::public_transfer(coin, recipient);
    // 方法二：使用coin::mint_and_transfer()完成铸币和转移
    // coin::mint_and_transfer(treasuryCap, amount, recipient, ctx)
}
// 销毁代币，使用coin::burn()方法
public entry fun burn(treasuryCap: &mut coin::TreasuryCap&lt;PRIVATECOIN>, coin: Coin&lt;PRIVATECOIN>) {
    coin::burn(treasuryCap, coin);
}

2、发行一个Faucet Coin合约

创建项目
- 运行命令：sui move new publiccoin
- 修改项目依赖，Move.toml文件中的git地址，将github替换为gitee
- 删除publiccoin.move中的注释部分
创建一次性见证结构体
- 只有drop能力
- 没有字段
- 不是泛型字段
- 以module名称的大写字母命名

// 一次性见证结构体，one-time-witness，要有drop能力
public struct PUBLICCOIN has drop {}

初始化init函数
- 使用coin::create_currency()方法创建代币
- 使用transfer::public_share_object()方法共享铸币权

// 初始化init函数
// witness：一次性证明，用于验证代币的唯一性和创造者的权限。
// ctx：交易上下文，用于处理交易中的各种状态和信息。
fun init(otw: PUBLICCOIN, ctx: &mut TxContext) {
    // 使用 coin 模块的 create_currency 函数来创建代币
    // treasuryCap：权限凭证，持有此凭证者有权铸造代币，coinMetadata：代币的元数据，如名称、符号、描述等信息。
    let (treasuryCap, coinMetadata) = coin::create_currency(
        otw, // 一次性证明，用于确认铸币操作的合法性
        6, // 代币的小数位数
        b"public coin", // 代币的符号
        b"public coin", // 代币的名称
        b"this is a public coin", // 代币的信息描述
        option::some(url::new_unsafe_from_bytes(b"https://himg.bdimg.com/sys/portraitn/item/public.1.e9f8c73.BSHSEfneCaeAXqEhmsNv0A")), // 代币的图标
        ctx // 交易上下文对象
    );
    // 冻结代币元数据，阻止后续的修改，把对象变成不可变对象
    transfer::public_freeze_object(coinMetadata);
    // treasury 是一个特殊的对象，它控制着代币的铸造权限。只有拥有 TreasuryCap 的实体才能铸造新的代币
    // 共享铸币权
    transfer::public_share_object(treasuryCap);

实现铸币方法
- 第一种方法：使用coin::mint()方法铸币，使用transfer::public_transfer()方法转移代币
- 第二种方法：使用coin::mint_and_transfer()方法铸造并转移代币
- 以上两种方法都要传入铸币权限、铸币数量、接收者地址和 TxContext交易上下文对象

// 铸造代币函数，需要参数：铸币权限、铸币数量、接收代币地址、交易上下文
public entry fun mint(treasuryCap: &mut coin::TreasuryCap&lt;PUBLICCOIN>, amount: u64, recipient: address, ctx: &mut TxContext) {
    // 方法一：使用coin::mint()函数铸币，使用transfer::public_transfer()方法转移代币
    let coin = coin::mint(treasuryCap, amount, ctx);
    transfer::public_transfer(coin, recipient);
    // 方法二：使用coin::mint_and_transfer()完成铸币和转移
    // coin::mint_and_transfer(treasuryCap, amount, recipient, ctx)
}

实现销毁代币方法
- 使用coin::burn()方法销毁代币

// 销毁代币，使用coin::burn()方法
public entry fun burn(treasuryCap: &mut coin::TreasuryCap&lt;PUBLICCOIN>, coin: Coin&lt;PUBLICCOIN>) {
    coin::burn(treasuryCap, coin);
}

完整代码

module publiccoin::publiccoin;
use std::option;
use sui::coin;
use sui::coin::Coin;
use sui::transfer;
use sui::url;

// 一次性见证结构体，one-time-witness，要有drop能力
public struct PUBLICCOIN has drop {}

// 初始化init函数
// witness：一次性证明，用于验证代币的唯一性和创造者的权限。
// ctx：交易上下文，用于处理交易中的各种状态和信息。
fun init(otw: PUBLICCOIN, ctx: &mut TxContext) {
    // 使用 coin 模块的 create_currency 函数来创建代币
    // treasuryCap：权限凭证，持有此凭证者有权铸造代币，coinMetadata：代币的元数据，如名称、符号、描述等信息。
    let (treasuryCap, coinMetadata) = coin::create_currency(
        otw, // 一次性证明，用于确认铸币操作的合法性
        6, // 代币的小数位数
        b"public coin", // 代币的符号
        b"public coin", // 代币的名称
        b"this is a public coin", // 代币的信息描述
        option::some(url::new_unsafe_from_bytes(b"https://himg.bdimg.com/sys/portraitn/item/public.1.e9f8c73.BSHSEfneCaeAXqEhmsNv0A")), // 代币的图标
        ctx // 交易上下文对象
    );
    // 冻结代币元数据，阻止后续的修改，把对象变成不可变对象
    transfer::public_freeze_object(coinMetadata);
    // treasury 是一个特殊的对象，它控制着代币的铸造权限。只有拥有 TreasuryCap 的实体才能铸造新的代币
    // 共享铸币权
    transfer::public_share_object(treasuryCap);
}

// 铸造代币函数，需要参数：铸币权限、铸币数量、接收代币地址、交易上下文
public entry fun mint(treasuryCap: &mut coin::TreasuryCap&lt;PUBLICCOIN>, amount: u64, recipient: address, ctx: &mut TxContext) {
    // 方法一：使用coin::mint()函数铸币，使用transfer::public_transfer()方法转移代币
    let coin = coin::mint(treasuryCap, amount, ctx);
    transfer::public_transfer(coin, recipient);
    // 方法二：使用coin::mint_and_transfer()完成铸币和转移
    // coin::mint_and_transfer(treasuryCap, amount, recipient, ctx)
}
// 销毁代币，使用coin::burn()方法
public entry fun burn(treasuryCap: &mut coin::TreasuryCap&lt;PUBLICCOIN>, coin: Coin&lt;PUBLICCOIN>) {
    coin::burn(treasuryCap, coin);
}

3、两个Coin合约对比

通过代码对比可以看到，两个项目的代码差别只有一处，就是关于铸币权限凭证 treasuryCap 的处理，privatecoin项目将铸币权限凭证 treasuryCap 转移给了合约部署者，publiccoin项目将铸币权限凭证 treasuryCap 共享给了所有用户。

三、调用

两个合约的调用方法基本一致

编译合约：sui move build
发布合约：sui client publish
- 发布成功，找到项目 Transaction Digest，在sui浏览器输入打开
- 找到合约相关object ID，提供给mint和burn方法

调用mint方法：
```
sui client call --package &lt;package ID> --module &lt;module> --function &lt;function> --args &lt;args1 args2 ...>
```
- 铸币成功后，找到 Transaction Digest，在sui浏览器输入打开
- 找到代币object ID，提供给burn方法使用

调用burn方法：

sui client call --package &lt;package ID> --module &lt;module> --function &lt;function> --args &lt;args1 args2 ...>

四、结论

通过不同合约的方法调用我们可以得出以下结论

privatecoin合约：合约发布者拥有铸币凭证权限，可以给不同地址铸造代币，但是合约发布者只能销毁自己拥有的代币；其他地址既不能铸造代币，也不能销毁代币
publiccoin合约：所用地址都拥有铸币凭证权限，可以给不同地址铸造代币，但只能销毁自己拥有的代币
不管有没有权限凭证，每个地址拥有的资产只能由该地址销毁

原创
学分: 4
分类: Move
标签: Sui Sui Move Move

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。