在ETH網路上發布代幣智能合約（在以太坊發行自己的幣種）

以太坊官方開發檔案：https://ethereum.org/zh/
以太坊小游戲代碼學習：https://cryptozombies.io/

本文介紹了以下內容，文章比較長，涉及內容較多，如果對你有幫助，麻煩點贊、收藏，感謝支持

如何搭建本地區塊鏈智能合約開發環境
如何撰寫代幣合約、及代幣合約的自定義方法
智能合約測驗、部署到開發網路、測驗網路
發布后呼叫合約
相關代碼會放到GitHub，鏈接在文章末尾

文章目錄

在ETH網路上發布代幣智能合約（在以太坊發行自己的幣種）
本文使用環境
一、環境搭建
- 1.安裝Node.js
- 2.安裝HardHat
二、智能合約開發
三、智能合約編譯
四、智能合約測驗
五、智能合約部署（本地開發網路）
六、智能合約部署（私有、公開區塊鏈[主、測驗]網路）

本文使用環境

Windows 10 x64
Node v12.14.0
Hardhat v2.6.6（npm安裝依賴會自動安裝最新，版本不影響使用）
MetaMask 瀏覽器插件（Google插件需要VPN，可以使用Edge，安裝插件不要翻墻一樣使用）
（非必須）使用Besu搭建的ETH私鏈（搭建方法參考我的另一篇文章：使用For Java的Hyperledger Besu部署以太坊的私有鏈），不搭建私鏈也可以，文章最后是在以太坊測驗鏈練習發布，免去搭建私鏈的時間

一、環境搭建

以太坊開發環境（之一Hardhat）：https://hardhat.org/
以太坊合約呼叫（之一Web3.js也可以編譯、部署合約）：https://web3js.readthedocs.io/

1.安裝Node.js

Hardhat是依賴Node環境的，先安裝Node.js
在這里插入圖片描述
下載長期維護版，并進行安裝即可（各系統的安裝流程，環境變數配置此處不做介紹，非本文核心內容），安裝完成后打開終端（cmd、PowerShell），如下測驗node環境有效性，正常輸出版本資訊即可

node -v
v12.14.0

2.安裝HardHat

（Windows版node環境）Hardhat環境搭建：

建立空檔案夾，運行npm init，初始化一個npm專案，按照提示依次輸入專案資訊

npm init

初始化完成后，運行npm install --save-dev hardhat，稍后使用的時候使用npx hardhat的方式呼叫

npm install --save-dev hardhat

安裝hardhat-waffle、hardhat-truffle5、hardhat-ethers、web3，這使得 Hardhat 與使用 Waffle 構建的測驗兼容，并支持遠程呼叫智能合約

npm install --save-dev @nomiclabs/hardhat-waffle ethereum-waffle chai @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-truffle5 @nomiclabs/hardhat-web3 web3

初始化一個hardhat專案

npx hardhat

在這里插入圖片描述

選擇第一個創建簡單的專案，這里會包含一些示例代碼
創建完畢之后，再次運行npx hardhat即可獲得幫助
開啟挖抗模式，否則后面添加合約后，不會有新的塊產出，就看不到效果，修改目錄下hardhat.config.js檔案的networks如下，其他配置可參考：HardHat網路參考

module.exports = {
  defaultNetwork: "hardhat",
  networks: {
    hardhat: {
	  // 在這種情況下，將在 3 到 6 秒的隨機延遲后挖掘一個新塊，
	  // 例如，第一個區塊可以在 4 秒后開采，第二個區塊在 5.5 秒后開采，依此類推，
      mining: {
        auto: false,
        interval: [3000, 6000]
      }
    }
  },
  solidity: "0.8.4",
};

啟動本地開發網路

npx hardhat node

看到輸出Account #1、Private Key等資訊，說明本地網路啟動成功，該網路每次啟動都是新的，但創世用戶都是固定的，僅用于開發使用，并非真正意義上的區塊鏈網路，本地開發測驗發布都需要依賴這個網路環境

Hardhat Network將公開一個JSON-RPC介面，要使用它，請將您的錢包或應用程式連接到http://localhost:8545

新建或匯入MetaMask錢包賬戶，此文不介紹該內容，錢包資訊注意妥善保管
點擊瀏覽器插件MetaMask，三個點，點擊展開視圖便于操作
點擊頭像，選擇設定
添加本地開發網路
保存后，頭像旁就變為本地網路了，說明連接成功
注意：這時的用戶還是創建錢包的默認用戶，并不是所連接網路上的用戶，選擇錢包的匯入賬戶
私鑰，填寫本地HardHat啟動時，輸出的任何一個Account下面的Private Key，點擊匯入后如圖，才可以使用該賬戶進行后續操作，如果是私鏈，則使用私鏈中的用戶，就是一定要使用對應網路中的用戶，本地HardHat環境查看創世用戶可以使用命令npm hardhat account

二、智能合約開發

所涉及的代碼都需要有，因為ERC20是代幣本身的規范，但是對代幣合約的操作以及其他方法都是需要自己開發的，我這里增加了給用戶發幣等一些方法，為了良好的體驗建議跟著往下走

EIPs/eip-20.md
點擊鏈接查看以太坊官方發布的ERC20標準說明

ERC代表“Etuereum Request for Comment”，
ERC20標準定義了一些函式介面,規定了各個代幣的基本功能，它可以快速發幣，而且使用又方便，因此空投幣和大部分基于以太坊合約的代幣基本上就是利用ERC-20標準開發的，
如果簡單理解的話就是，ERC20是以太坊的一種標準，所有符合這個標準的數字貨幣都可以成為ERC20代幣，自然也就能存入支持以太幣的錢包中了，但是這些貨幣的交易本質上還是在消耗以太坊的資源，所以交易費都還是以太幣，
這里的標準其實就是一種智能合約模版，只要滿足這個模版的代幣都稱之為ERC20代幣，你可以理解為電腦主板上的記憶體插條，只要符合一定的尺寸和接線標準的記憶體品牌都可以使用，這就等于說以太坊訂立了一個標準，其他代幣就不需要另起爐灶，全部從頭到尾再搞一遍，只要滿足這個標準就可以在以太坊公鏈上運行了，極大降低了開發難度，很多代幣就是只關注自己的業務邏輯，底層全部依賴以太坊，

轉自：https://xw.qq.com/cmsid/20210512A03DDN00

先添加SafeMath.sol計算方法
在contracts目錄同級創建library目錄，在library目錄中創建檔案SafeMath.sol，內容如下

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;

library SafeMath {
    function mul(uint256 a, uint256 b) internal pure returns (uint256){
        uint256 c = a * b;
        assert(a == 0 || c / a == b);
        return c;
    }
 
    function div(uint256 a, uint256 b) internal pure returns (uint256){
        assert(b > 0);
        uint256 c = a / b;
        return c;
    }
 
    function sub(uint256 a, uint256 b) internal pure returns (uint256){
        assert(b <= a);
        return a - b;
    }
 
    function add(uint256 a, uint256 b) internal pure returns (uint256){
        uint256 c = a + b;
        assert(c >= a);
        return c;
    }
}

添加ERC20.sol代幣標準介面
在contracts目錄同級創建library目錄，在library目錄中創建檔案ERC20.sol，內容如下

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;

interface ERC20 {
    function totalSupply() external view returns (uint256);
    
    function balanceOf(address _owner) external view returns (uint256 balance);

    function transfer(address _to, uint256 _value)  external returns (bool success);

    function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);

    function approve(address _spender  , uint256 _value) external returns (bool success);

    function allowance(address _owner, address _spender) external view returns (uint256 remaining);

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

添加Roles.sol合約權限管理，授權用戶串列添加、移出等
在contracts目錄同級創建library目錄，在library目錄中創建檔案Roles.sol，內容如下

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
  struct Role {
    mapping (address => bool) bearer;
  }

  /**
   * @dev give an account access to this role
   */
  function add(Role storage role, address account) internal {
    require(account != address(0));
    role.bearer[account] = true;
  }

  /**
   * @dev remove an account's access to this role
   */
  function remove(Role storage role, address account) internal {
    require(account != address(0));
    role.bearer[account] = false;
  }

  /**
   * @dev check if an account has this role
   * @return bool
   */
  function has(Role storage role, address account)
    internal
    view
    returns (bool)
  {
    require(account != address(0));
    return role.bearer[account];
  }
}

添加Ownable.sol代幣所有者權限管理合約，針對業務，管理業務的授權用戶串列，判斷是否有權限，業務授權方法等
在contracts目錄同級創建library目錄，在library目錄中創建檔案Ownable.sol，內容如下

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;

import "./Roles.sol";

contract Ownable {
  using Roles for Roles.Role;

  event MinterAdded(address indexed account);
  event MinterRemoved(address indexed account);

  Roles.Role private minters;

  constructor() {
    minters.add(msg.sender);
  }

  modifier onlyMinter() {
    require(isMinter(msg.sender));
    _;
  }

  function isMinter(address account) public view returns (bool) {
    return minters.has(account);
  }

  function addMinter(address account) public onlyMinter {
    minters.add(account);
    emit MinterAdded(account);
  }

  function renounceMinter() public {
    minters.remove(msg.sender);
  }

  function _removeMinter(address account) internal {
    minters.remove(account);
    emit MinterRemoved(account);
  }
}

查看contracts目錄，您應該能夠找到 Greeter.sol，這是hardhat默認的示例，不修改可以直接進行下一步編譯進行測驗；本文需要自己寫一個代幣的合約，依賴于上方創建的內容，如下是我自己根據ERC20規范寫的代幣合約，代幣名稱PET，檔案名TokenPET.sol，實作ERC20，放在contracts目錄下

需要注意的是，發行的數量需要相對token小數點來設定，
例如如果token的小數點是0位，你要發行1000個token，那么發行數量_totalSupply的值是1000，
但是如果token的小數點是18位，你要發行1000個token，那么發行數量_totalSupply的值是1000000000000000000000（1000后面加上18個0），

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import { SafeMath } from "../library/SafeMath.sol";
import { ERC20 } from "../library/ERC20.sol";

/// @title PET 私有區塊鏈代幣合約
/// @author Aubrey
/// @notice Explain to an end user what this does
/// @dev Explain to a developer any extra details
contract TokenPET is ERC20 {

  // 變數
  string private _name = 'PETurrency';
  string private _symbol = 'PET';
  // 8表示將令牌數量除以100000000得到其用戶表示，
  uint8 private _decimals = 8;
  uint256 private _totalSupply;
  uint256 constant private MAX_UINT256 = 2**256 - 1;
  uint256 private maxMintBlock = 0;

  // 使用 SafeMath 函式庫
  using SafeMath for uint256;
  // 類比二維陣列
  mapping (address => mapping (address => uint256)) private allowed;
  // 類比一維陣列
  mapping (address => uint256) private balances;

  // 令牌的名稱
  function name() public view returns (string memory) {
    return _name;
  }
  // 令牌的符號
  function symbol() public view returns (string memory) {
    return _symbol;
  }
  // 令牌使用的小數位數 - 例如8，表示將令牌數量除以100000000得到其用戶表示， 
  function decimals() public view returns (uint8) {
    return _decimals;
  }
  // 回傳總代幣供應量
  function totalSupply() public override view returns (uint256) {
    return _totalSupply;
  }
  // 獲取賬戶余額
  function balanceOf(address _owner) public override view returns (uint256 balance) {
    return balances[_owner];
  }
  // 給賬戶轉賬
  function transfer(address _to, uint256 _value) public override returns (bool success) {
    assert(0 < _value);
    require(balances[msg.sender] >= _value);
    require(_to != address(0));
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    emit Transfer(msg.sender, _to, _value);
    return true;
  }
  // 從賬戶轉賬到賬戶 
  function transferFrom(address _from, address _to, uint256 _value) public override returns (bool success) {
    uint256 _allowance = allowed[_from][msg.sender];
    assert (balances[_from] >= _value);
    assert (_allowance >= _value);
    assert (_value > 0);
    require(_to != address(0));
    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = _allowance.sub(_value);
    emit Transfer(_from, _to, _value);
    return true;
  }
  // 允許 _spender 多次取回您的帳戶，最高達 _value 金額； 如果再次呼叫此函式，它將用 _value 的當前值覆寫的 allowance 值，
  function approve(address _spender, uint256 _value) public override returns (bool success) {
    require(_spender != address(0));
    require((_value == 0) || (allowed[msg.sender][_spender] == 0));
    allowed[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
  }
  //  回傳 _spender 仍然被允許從 _owner 提取的金額，
  function allowance(address _owner, address _spender) public override view returns (uint256 remaining) {
    return allowed[_owner][_spender];
  }

  // 內部方法 給地址 _to 初始化數量 _amount 數量的 tokens，注意 onlyOwner 修飾，只有合約創建者才有權限分配 分配會增加可發行總代幣量，如果代幣總量為0也可以增量發行
  function _mint(address _to, uint256 _amount) internal {
      require(_to != address(0));
      _totalSupply = _totalSupply.add(_amount);
      balances[_to] = balances[_to].add(_amount);
      emit Transfer(address(0), _to, _amount);
  }
  // 內部方法 銷毀一定數量的令牌
  function _burn(address account, uint256 amount) internal {
    require(account != address(0));
    require(amount <= balances[account]);

    _totalSupply = _totalSupply.sub(amount);
    balances[account] = balances[account].sub(amount);
    emit Transfer(account, address(0), amount);
  }
  // 內部方法 從津貼中銷毀一定數量的令牌
  function _burnFrom(address account, uint256 amount) internal {
    require(amount <= allowed[account][msg.sender]);

    // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
    // this function needs to emit an event with the updated approval.
    allowed[account][msg.sender] = allowed[account][msg.sender].sub(amount);
    _burn(account, amount);
  }

}

上方代碼有三個內部方法，因為方法的操作內容比較敏感，所以控制為內部方法，然后使用權限控制呼叫是否允許，下面撰寫內部方法的對外呼叫介面

在contracts目錄創建TokenPETMintable.sol代幣合約檔案，用來向外提供內部方法mint的鑒權呼叫，需要繼承TokenPET、Ownable，根據Ownable的判斷是否有權限呼叫內部方法或其他邏輯，之后的測驗、部署都是基于該檔案

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.4;
import { TokenPET } from "../contracts/TokenPET.sol";
import { Ownable } from "../library/Ownable.sol";

contract TokenPETMintable is TokenPET, Ownable {
event MintingFinished();

  bool private _mintingFinished = false;

  modifier onlyBeforeMintingFinished() {
    require(!_mintingFinished);
    _;
  }

  /**
   * @return true if the minting is finished.
   */
  function mintingFinished() public view returns(bool) {
    return _mintingFinished;
  }

  /**
   * @dev Function to mint tokens
   * @param to The address that will receive the minted tokens.
   * @param amount The amount of tokens to mint.
   * @return A boolean that indicates if the operation was successful.
   */
  function mint(
    address to,
    uint256 amount
  )
    public
    onlyMinter
    onlyBeforeMintingFinished
    returns (bool)
  {
    _mint(to, amount);
    return true;
  }

  /**
   * @dev Function to stop minting new tokens.
   * @return True if the operation was successful.
   */
  function finishMinting()
    public
    onlyMinter
    onlyBeforeMintingFinished
    returns (bool)
  {
    _mintingFinished = true;
    emit MintingFinished();
    return true;
  }

}

三、智能合約編譯

運行npx hardhat compile編譯合同

npx hardhat compile
---------------------
# 編譯成功最后輸出如下
> Compilation finished successfully

四、智能合約測驗

測驗合約，在test目錄下，能夠找到sample-test.js，如下圖所示，這是默認的測驗代碼示例；可以按照該格式寫測驗代碼，呼叫合同中的方法并輸出log進行測驗合同是否正常

在這里插入圖片描述

PET代幣合約測驗代碼如下

const { expect } = require("chai");

// 這里的PET是測驗實體名
describe("PET", function() {
  // 測驗描述
  it("Should return the new PET once it's changed", async function() {
    // 獲取編譯的智能合約TokenPET，這個名是sol合約檔案的類名，就是contracts后面的名字，不是檔案名
    const TokenPET = await ethers.getContractFactory("TokenPET");
    const pet = await TokenPET.deploy();
    await pet.deployed();

    // 斷言判斷
    expect(await pet.name()).to.equal("PETurrency");
    expect(await pet.symbol()).to.equal("PET");
  });
});

撰寫好測驗腳本之后，運行npx hardhat test即可看到輸出

npx hardhat test
-------------------------
# 輸出如下說明成功
  PET
    √ Should return the new PET once it's changed (166ms)


  1 passing (901ms)

五、智能合約部署（本地開發網路）

測驗通過之后，進行合同的部署，在scripts目錄里面你會發現sample-script.js，這是發布合約的示例，如圖所示；可以按照該格式進行部署腳本的撰寫

在這里插入圖片描述

如下是，我針對自己添加的智能合約的部署腳本pet-deploy-script.js，hre.ethers.getContractFactory的引數是合同名，就是智能合約代碼中contracts后的名，不是合約檔案名

const hre = require("hardhat");

async function main() {
  const TokenPET = await hre.ethers.getContractFactory("TokenPETMintable");
  const pet = await TokenPET.deploy();

  await pet.deployed();

  console.log("TokenPET symbol is:", await pet.symbol());
  console.log("TokenPET deployed to:", pet.address);
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });

上文已經啟動hardhat本地網路，現在發布合同到本地網路

# scripts/pet-deploy-script.js 為寫好的部署合同腳本，想運行哪個執行哪個
# --network localhost 指發布到本地網路，之后講發布到測驗鏈或私鏈
npx hardhat run scripts/pet-deploy-script.js --network localhost

運行以上內容，輸出如下，說明發布成功，這是本地發布，說明合約沒有問題，才可以往線上的鏈發布

TokenPET symbol is: PET
TokenPET deployed to: 0x9fE46736679d2D9a65F0992F2……

到MetaMask中使用剛剛發布的代幣，右上角選擇本地網路然后點擊下方“添加代幣”使用合約
填寫代幣資訊，代幣合約地址就是第4步TokenPET deployed to的地址，代幣資訊會自動顯示，如果網路連接錯誤或地址填寫錯誤是找不到合約地址的，也就不會自動顯示下方的代幣資訊
點擊下一步，添加代幣
錢包中就可以使用該代幣了
呼叫合約中的mint方法，傳入目標用戶地址、代幣數量，就可以給指定用戶發幣了（同時代幣總量也會增加，相當于增量發行代幣）pet-using.js

//初始化程序
var Web3 = require('web3');
var Contract = require('web3-eth-contract');

// 編譯后的檔案 自行定位檔案修改路徑
var TokenPETMintable = require("../artifacts/contracts/TokenPETMintable.sol/TokenPETMintable.json");
var abi = TokenPETMintable.abi;
// 發布后合約的地址
var address = '0xa85233C63b9Ee964Add6F2cffe00……';

// 合約發布的鏈網路
web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"));

// 創建合同物件
var contract = new web3.eth.Contract(abi, address);

// 方法呼叫
contract.methods.totalSupply().call().then(function(totalSupply){
  console.log('totalSupply result', totalSupply) 
});

// 查詢發幣之前的賬戶余額 錢包中所選的創世用戶也可以
contract.methods.balanceOf('0xf39Fd6e51aad88F6F4ce6aB88272……').call().then(function(balanceOf){
  console.log('Before balanceOf result', balanceOf) 
});

// 呼叫mint方法向賬戶發行代幣
var mint = contract.methods.mint('0xf39Fd6e51aad88F6F4ce6aB88272……', 999);
// from需要是所有者，因為發布的時候沒有選擇用戶，默認是創世用戶第一個，才可以向想合約申請給用戶發幣
mint.send({from: '0xf39Fd6e51aad88F6F4ce6aB88272……'}).then(function(receipt){
// var result = mint.call().then(function(receipt) {
  console.log('call result', receipt) 
  // 查詢發幣之后的賬戶余額 錢包中所選的創世用戶也可以
  contract.methods.balanceOf('0xf39Fd6e51aad88F6F4ce6aB88272……').call().then(function(balanceOf){
	console.log('After balanceOf result', balanceOf) 
  });
}).catch((error, receipt) => {
  console.error('error === ', error);
  process.exit(1);
});

執行合約呼叫

npx hardhat run .\scripts\pet-using.js
# Before balanceOf result 0
# call result中status: true則為交易成功
# After balanceOf result 999

到錢包中查看對應賬戶就有余額了
在這里插入圖片描述

到此，您已經在本地創建了一個專案，運行了一個HardHat任務，開發、編譯了一個智能合約，撰寫并運行了一個測驗，并部署了一個合同，遠程呼叫了已部署合約的方法，對合約及賬戶進行了操作，

下面說將該代幣發布到私有、公開區塊鏈網路，

六、智能合約部署（私有、公開區塊鏈[主、測驗]網路）

以下發布流程需要是本地測驗、部署沒有問題再進行，本文介紹的只是其中一種方式，并非唯一發布方式，使用其他方式的如果有疑問可以留言

訪問合約發布網站myetherwallet（需要準備好前文說的MetaMask）
點擊“Access my wallet”
選擇瀏覽器插件“Browser Extension”
然后同意MetaMask授權
我這授權過了，看不到效果了，授權后在MetaMask中可以查看已連接的網站
授權成功后，錢包管理網頁應跳轉至如下，這個頁面左側用戶資訊，注意要是私鏈或測驗鏈中的用戶地址資訊，并且有一定的ETH，部署合約需要花費ETH，測驗鏈可以在回應鏈的水龍頭申請，然后之后的操作保證MetaMask選擇用戶是有ETH的這個用戶
選擇發布合約
填寫構建的合約資訊（構建流程見上文），查看artifacts->contracts->TokenPETMintable.sol->TokenPETMintable.json檔案內容，按照下圖對應關系填入
點擊Sign Transaction，點擊confirm
然后MetaMask會提示確認交易（需要由報酬，確認賬戶中有ETH，可以在水龍頭申請一些ETH用來測驗，否則個人的私網也沒法處理本次作業，私鏈就自己發幣就行了），點擊確認，點擊提交，在metamask 插件中或myetherwallet可以看到處理狀態，然后等待交易完成
查看錢包用戶交易，可以看到合約部署的交易，myetherwallet網站中也可以查看該交易資訊
點擊交易查看詳情，可以跳轉到以太坊區塊鏈瀏覽器查看資訊，如果是私鏈則線上的區塊鏈瀏覽器無法查看，因為區塊鏈瀏覽器沒有你私鏈的連接資訊和api（可能需要翻墻）
交易中的To，就是發布到測驗鏈中的合約地址
查看鏈上合約的具體資訊，點擊To中的合約地址，查看合約資訊
在metamask連接私鏈或測驗鏈，是剛剛發布代幣的鏈就可以，選擇添加代幣，和之前說的添加本地網路代幣步驟一樣，就是代幣合約地址使用上一步查看的合約地址，然后這里就多了另一個剛剛發布的幣，可以進行交易

在私鏈或測驗鏈發幣（給用戶發自己發行的幣種）也可以用上面自己寫腳本呼叫，這個網站只可以對測驗鏈或可在公網訪問的區塊鏈操作，內部網路它也訪問不到
選擇選單Interact with Contract，在右側填寫要操作的合約地址，填寫artifacts->contracts->TokenPETMintable.sol->TokenPETMintable.json檔案的ABI內容（直接在第一行選擇剛剛發布的合約，下面的內容一般會帶出來）
選擇Mint方法，填寫收款用戶地址，發行代幣數量，然后點擊Write

在這里插入圖片描述

同意交易

在這里插入圖片描述
18. 交易成功后，到MetaMask查看用戶的PET余額，可以看到已經有余額了，這里因為我設定的合約小數點為8位，所以交易金額都是以小數點后8位開始

GitHub原始碼參考：https://github.com/Aubrey-J/PET-ERC20

轉載請註明出處，本文鏈接：https://www.uj5u.com/qukuanlian/328176.html

標籤：區塊鏈

上一篇：DeFi+NFT革命者——NFTEA全新模式打破傳統市場壁壘！

下一篇：solidity資料型別（三）msg tx hash kill payable new