概述
初步了解
进阶了解
PlatON 节点
- 验证节点介绍
- 成为主网验证节点
- 节点工具
开发者
- 开发指南
- 设置开发环境
  - 开发网络
  - 私有网络
- 智能合约
  - 系统合约
    - 系统合约接口说明
  - Solidity 合约
  - Wasm 合约
- API 参考
- PRC Token
  - PRC-20
  - PRC-721
数据分析
- PlatScan
- PlatEye
示例教程
钱包
社区项目

文江博客开发文档 PlatON 中文文档文章详情

文章来源于网络收集而来，版权归原创者所有，如有侵权请及时联系！

Go SDK

发布于 2023-07-01 15:28:54 字数 76943 浏览 0 评论 0 收藏 0

注：本Go-SDK仅面向Alaya网络，与PlatON网络存在一定的差异，文档内容待更新。

开发库导入

可以先安装到GO_PATH路径下:
go get https://github.com/oldmanfan/platon-go-sdk

或直接使用go.mod方式, 在文件中使用:
import github.com/oldmanfan/platon-go-sdk

要求go版本: ^1.15.6

基础api使用

Bech32地址

0x地址转bech32地址


func main() {
  bytes, _ := hexutil.Decode("0x1963dd5b88accDA8F86C0D9A487c36cCDC0Aba0F")
  b32Addr, _ := bech32util.ConvertAndEncode(network.MainNetHrp, bytes)
  fmt.Println("bech32 addr: ", b32Addr)
  // Expect Output: atp1r93a6kug4nx637rvpkdyslpkenwq4ws0t0g884
}

bech32地址转0x地址


func main() {
  b32Addr := "atp1r93a6kug4nx637rvpkdyslpkenwq4ws0t0g884"


  hrp, ethAddr, _ := bech32util.DecodeAndConvert(b32Addr)
  fmt.Printf("eth hrp: %s, hex: %s\n", hrp, hexutil.Encode(ethAddr))
  // Expect Output: 0x1963dd5b88accDA8F86C0D9A487c36cCDC0Aba0F
}

网络参数

初始化网络

在platon-go-sdk/network中已经预置了Alaya的网络配置, 如果需要自定义网络, 可以自定义网络配置:


 config := network.Config{"http://localhost:6789", big.newInt(1)}

预置的网络配置 在sdk中已经预置了Alaya网络的一些默认设置:


  network.MainNetHrp
  network.TestNetHrp
  network.MainNetConfig
  network.TestNetConfig
  network.PposMainNetParams
  network.PposTestNetParams

钱包相关

本钱包同时支持HDWallet和KeyStore Wallet. 默认情况下使用HDWallet管理账号, 如果仅通过导入私钥或导入KeyStore文件的方式导入账户, 则使用KeyStore存储账户信息.

创建钱包

创建钱包接口, 默认创建HDWallet钱包. 可以通过以下方式创建:

NewWallet方法:
调用该方法将创建一个HDWallet钱包, 同时会生成新的一组助记词和DerivationPath的index为0的账号.


w, err := web3go.NewWallet()
if err != nil {
    fmt.Println("new wall error: ", err)
    return
}
account0, _ := w.Accounts()[0]  // go the default 0 account

NewWalletByMnemonic方法:
调用该方法用来通过助记词导入钱包.


mnemonic := "always brick access science decade nasty marriage attack fame topple pen add"
w, err := NewWalletByMnemonic(mnemonic)

NewWalletBySeed方法:
调用该方法用来通过钱包的seed导入钱包.


seed := "0x9dfc7e3f52c4438d04db5488e13672faa37920ec62bacdc333a83974cb07bfdd893bfd46940dedfeb7ef30a142c4d07d552dd6589b40d3a58b941b7e9d6dae7e"
seedBytes, _ := hexutil.Decode(seed)
w, _ := NewWalletBySeed(seedBytes)

下面的接口中, 我们默认已经通过上面的方法, 成功创建了一个钱包w.

创建新的账号

在钱包创建成功之后, 通过方法NewAccount(index uint64)方法, 创建一个序号为index的账号.


account, err := w.NewAccount(1)

上面的示例代码将生成序号为1的账户.

列出账号信息

使用Accounts() ([]accounts.Account, error)方法, 将列出钱包中所有的账号信息.

查询账号余额

使用BalanceOf(owner common.Address) (*big.Int, error)方法, 查询指定地址的余额.

转账

使用Transfer(from common.Address, to common.Address, value *big.Int) (string, error)方法用来转账. 下面的代码示例, 演示了如何在ALAYA开发测试网上列出账户余额和转账的操作.


const mnemonic = "always brick access science decade nasty marriage attack fame topple pen add"
  w, err := web3go.NewWalletByMnemonics(mnemonic)
  if err != nil {
    fmt.Println("import wall error: ", err)
    return
  }


  w.SetNetworkCfg(&web3go.DefaultTestNetCfg)


  accounts := w.Accounts()
  for _, account := range accounts {
    b, _ := w.BalanceOf(account.Address)
    addr, _ := account.ToMainNetAddress()
    fmt.Printf("balance of %s is %s\n", addr, b.String())
  }


  digest, err := w.Transfer(accounts[0].Address, common.MustBech32ToAddress("atp1ydaqepg8s48gqhz29kk0wrf3lqdtj38d8mkcz3"), big.NewInt(1000000000000000000))
  if err != nil {
    fmt.Println("transfer failed: ", err)
    return
  }


  fmt.Println("tx send: ", digest)

导出HDWallet的助记词

使用ExportMnemonic() (string, error)方法导出钱包的助记词.

导出HDWallet的账户详情

使用ToString(account accounts.Account) string方法导出一个HDWallet账号的详情, 包括Alaya主网地址, 开发测试网, 私钥.

导出KeyStore中账户的私钥

使用ExportPrivateKey(account accounts.Account, passphrass string) (*ecdsa.PrivateKey, error)方法导出KeyStore中账户的私钥. passphrase是KeyStore文件的密码.

导出KeyStore文件

使用ExportToKeyStore(account accounts.Account, path string, passphrase string) error将账号account导出到path指定的路径下, 并设置KeyStore文件的密码为passphrase.

导入私钥

仅仅只有私钥的情况下, 只能将账号的私钥导入到KeyStore文件中. 通过ImportPrivateKey(key *ecdsa.PrivateKey, ksPath string, passphrase string) (accounts.Account, error) 方法, 将私钥key导入到ksPath指定的KeyStore文件中, 并设置密码为passphrase.

导入KeyStore文件

通过ImportFromKeyStore(path string, passphrase string, newpassphrase string) (accounts.Account, error)方法导入账号. 其中path是KeyStore文件的路径, passphrase是KeyStore文件的当前密码, newpassphrase是更新之后的KeyStore文件的密码.

签名交易但是不广播

在Transfer方法的说明中, 当我们进行转账操作的时候, 默认会通过rpc.SendRawTransaction方法, 将交易广播到网络中. 如果我们只需要签名但是无需广播到网络中, 则可以使用SignTx(tx *types.Transaction, fromAccount accounts.Account) (*types.Transaction, error) 方法对交易进行签名, 但是不广播到网络中, 同时获取签名之后的V, R, S数据.


w, _ := NewWalletByMnemonics(mnemonic)
  w.NewAccount(1)
  fromAccount := w.Accounts()[0]
  toAccount := w.Accounts()[1]


  nonce := uint64(1)
  gasLimit := uint64(21000)
  gasPrice := big.NewInt(5000000000)
  tx := types.NewTransaction(nonce, toAccount.Address, big.NewInt(100000), gasLimit, gasPrice, nil)


  signedTx, _ := w.SignTx(tx, fromAccount)


  s, _ := json.Marshal(signedTx)


  fmt.Println("signed Tx: ", string(s))

上面的代码将产生类似的输出:


{
    "nonce":"0x1",
    "gasPrice":"0x12a05f200",
    "gas":"0x5208",
    "to":"atx1u6vtwsz2fqw5ufnm3tm070k43scxhhc8r3nnts",
    "value":"0x186a0",
    "input":"0x",
    "v":"0x62297",
    "r":"0xd6904b0251615d525f6b3c699047977676baf2ba385f3ec8737e1a530c88796d",
    "s":"0x796efcf6b6bede3a49ec6c7969136d50a8fcbb5f43a8d8595e77c6b2b813732b",
    "hash":"0x3b8c1ef129e4b1e65ed527cbae7718c32a0a80c8a432d3c8b5c083e613485139"
}

基础RPC接口

基础API包括网络，交易，查询，节点信息，经济模型参数配置等相关的接口，具体参考如下API使用说明。

调用RPC接口, 需要使用Geb3对象:


  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)

下面的示例中, 我们都将使用web3g这个对象来举例.

ClientVersion

返回当前客户端版本

参数
无
返回值

(string, error)

示例


func main() {
  // const alayaEndpoint = "https://openapi.alaya.network/rpc"
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  rsp, err := web3g.ClientVersion()
  fmt.Println("Version Info: ", rsp, err)
}

输出: Version Info: AlayaNetwork/alaya/v0.16.0-unstable-56b3a6aa/linux-amd64/go1.16.2 <nil>

Sha3

返回给定数据的keccak-256（不是标准sha3-256）

参数
String ：加密前的数据
返回值


(common.hash, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  sha3, err := web3g.Sha3("hello world")
  fmt.Println("sha3: ", sha3.Hex(), err)
  // Expect Output: 0x47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad
}

NetworkID

返回当前网络ID

参数
无
返回值


(*big.Int, error)

返回的整数即为网络ID

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  netver, err := web3g.NetworkID()
  fmt.Println(netver, err)
  // Expect Output: 1
}

NetListening

如果客户端正在积极侦听网络连接，则返回true

参数
无
返回值


(bool, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  netlistening, err := web3g.NetListening()
  fmt.Println(netlistening, err)
  // Expect Output: true
}

NetPeerCount

返回当前连接到客户端的对等体的数量

参数
无
返回值


(uint64, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  netPeerCount, err := web3g.NetPeerCount()
  fmt.Println(netPeerCount, err)
  // Expect Output: 0
}

ProtocolVersion

返回当前platon协议版本

参数
无
返回值


(uint64, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  protocolVer, err := web3g.ProtocolVersion()
  fmt.Println(protocolVer, err)
  // Expect Output: 65
}

Syncing

返回一个对象，其中包含有关同步状态的数据

参数
无
返回值


(*platon.SyncProgress, error)

如果返回值为(nil, nil), 表示没有在同步, 否则platon.SyncProgress中含有同步状态的数据.

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  syncing, err := web3g.Syncing()
  fmt.Println(syncing, err)
}

GasPrice

返回gas当前价格

参数
无
返回值


(*big.Int, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  gasPrice, err := web3g.GasPrice()
  fmt.Println(gasPrice, err)
  // Expect Output: 1000000000
}

Accounts

返回客户端拥有的地址列表

参数
无
返回值


([]string, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  accounts, err := web3g.Accounts()
  fmt.Println(accounts, err)
  // Expect Output: [atp1fgdm0vsevzc8wy2094vmw4dtpdnph25j6l9e8a atp1rat5qr98desmch5jk4shhwpxspqw24ekgkhjdv atp1ulc54kqt9w6jla8pq264dfgqgcgcxnrlayve05]
}

BlockNumber

返回当前最高块高

参数
无
返回值


(uint64, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  blockNum, err := web3g.BlockNumber()
  fmt.Println(blockNum, err)
  // Expect Output: 31329
}

BalanceAt

返回查询地址余额

参数
- String ： address 需要查询的bech32格式地址
- Pos:
  - "latest" 最新块高(默认)
  - "earliest" 最低块高
  - "pending" 未打包交易
  - *big.Int 指定块高
返回值


(*big.Int, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  balance, err := web3g.BalanceAt("atp1fgdm0vsevzc8wy2094vmw4dtpdnph25j6l9e8a", "latest")
  fmt.Println(balance, err)
  // Expect Output: 999000000000000000000
}

StorageAt

从给定地址的存储位置返回指定key的值

参数
- String : address 存储地址
- key: 存储数据的hash
- option:
  - "latest" 最新块高(默认)
  - "earliest" 最低块高
  - "pending" 未打包交易
  - *big.Int 指定块高
返回值


([]byte, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  storage, err := web3g.StorageAt(
    "atp1fgdm0vsevzc8wy2094vmw4dtpdnph25j6l9e8a", 
    common.HexToHash("0x4b3b9abff5c129788aa18916328eadc8c02465a31237df27756c7e5c6dd72ce8"), 
    "latest")
  fmt.Println(storage, err)
  // Expect Output: 0x0
}

TransactionCountByHash

根据区块hash查询区块中交易个数

参数
- common.Hash : blockHash 区块hash
返回值


(uint, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  count, err := web3g.TransactionCountByHash(common.HexToHash("0x4b3b9abff5c129788aa18916328eadc8c02465a31237df27756c7e5c6dd72ce8"))
  fmt.Println(count, err)
  // Expect Output: 0
}

TransactionCountByNumber

根据区块块高，返回块高中的交易总数

参数
- "latest" 最新块高(默认)
- "earliest" 最低块高
- "pending" 未打包交易
- *big.Int 指定块高
返回值


(uint, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  count, err := web3g.TransactionCountByNumber("latest")
  fmt.Println(count, err)
  // Expect Output: 0
}

CodeAt

返回给定地址的代码

参数
- account ： address 地址/合约
- pos:
  - "latest" 最新块高(默认)
  - "earliest" 最低块高
  - "pending" 未打包交易
  - *big.Int 指定块高
返回值


([]byte, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  code, err := web3g.CodeAt("atp1fgdm0vsevzc8wy2094vmw4dtpdnph25j6l9e8a", "latest")
  fmt.Println(code, err)
  // Expect Output: []
}

SendRawTransaction

发送交易

参数
- tx *types.Transaction: 钱包签名后数据
返回值


(json.RawMessage, error)

示例


func main() {
    const alayaEndpoint = "http://172.16.64.132:6789"
    web3g, err := web3go.New(alayaEndpoint)


    const PrivateKey = "ed72066fa30607420635be56785595ccf935675a890bef7c808afc1537f52281"
    var credentials, _ = typedefs.NewCredential(PrivateKey, network.MainNetHrp)
    tx := types.NewTransaction(0, common.MustBech32ToAddress("atp1qv5ffg7z3h42zt4e035vja65d86al7q0nr9s0g"), nil, 0, nil, nil)
    signedTx, _ := credentials.SignTx(tx, network.MainNetChainId)
    rsp, err := web3g.SendRawTransaction(signedTx)
    fmt.Println(rsp, err)
}

CallContract

执行一个消息调用交易，消息调用交易直接在节点旳VM中执行而不需要通过区块链的挖矿来执行

参数
- platongosdk.CallMsg: 交易结构
  - common.Address : From : 交易发送地址
  - common.Address : To : 交易接收方地址
  - *big.Int ： Gas ：本次交易gas用量上限
  - *big.Int ： GasPrice ： gas价格
  - *big.Int ：Value ：转账金额
  - String ：Data ：上链数据
返回值


([]byte, error)

示例


func main() {
    const alayaEndpoint = "http://172.16.64.132:6789"
    web3g, err := web3go.New(alayaEndpoint)


    from := common.MustBech32ToAddress("atp1r93a6kug4nx637rvpkdyslpkenwq4ws0t0g884")
    to := common.MustBech32ToAddress("atp1qv5ffg7z3h42zt4e035vja65d86al7q0nr9s0g")


    msg := platongosdk.CallMsg {
        From:     from,
        To:       &to,
        Gas:      0,
        GasPrice: nil,
        Value:    nil,
        Data:     nil,
    }


    rsp, err := web3g.CallContract(msg, "latest")
    fmt.Println(rsp, err)
}

EstimateGas

估算合约方法gas用量

参数
- msg: platon_go_sdk.CallMsg交易结构
  - string : From : 交易发送地址
  - string : To : 交易接收方地址
  - *big.Int ： Gas ：本次交易gas用量上限
  - *big.Int ： GasPrice ： gas价格
  - *big.Int ：Value ：转账金额
  - []byte ：Data ：上链数据
返回值


(uint, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  req := platongosdk.CallMsg{
    From:     "atp1fgdm0vsevzc8wy2094vmw4dtpdnph25j6l9e8a",
    To:       "atp1fgdm0vsevzc8wy2094vmw4dtpdnph25j6l9e8a",
    Gas:      0,
    GasPrice: nil,
    Value:    nil,
    Data:     nil,
  }
  gaslimit, err := web3g.EstimateGasLimit(req)
  fmt.Println(gaslimit, err)
  // Expect Output: 21000
}

BlockByHash

根据区块hash查询区块信息

参数
- string ： blockHash 区块hash
返回值


(string, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  block, err := web3g.BlockByHash("0x733a072fd7d074f4116585c7be7c036c86ead3f453265b8c34ba56a99b9f6bcc")
  fmt.Println(block, err)
  // Expect Output: {"extraData":"0xd8820d0085616c61796188676f312e31362e32856c696e757800000000000000c971b26df4489326a740841721ca639fba8ac24ca69db7cc1602d1aed4ab36ff31860425e9467201afc68be2757cca7c52e4d1832b39100b0c66a1f4671eab1400","gasLimit":"0x8fcf88","gasUsed":"0x0","hash":"0x733a072fd7d074f4116585c7be7c036c86ead3f453265b8c34ba56a99b9f6bcc","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","miner":"atp1zqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr5jy24r","nonce":"0x03187105be36f06f4fe451e6da7a8d46fec0158bc5c84af2f2ca10c1894b8be5616084f2d4143faab828a3fa4a03b018d38b9ba0b16bfdba2c2edbfcc9f47cd7753297b0d5d8c418a36bd35c1bba2596be","number":"0x8c6b","parentHash":"0x71d6573142d14423f357a6c7c222ff00eb894541f1cf351099c36de6c4e9d319","receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","size":"0x2db","stateRoot":"0x2fb0f3f9567606946fd990f2e640215955d84c452de29768d60d2655fce8f145","timestamp":"0x17aa9f6b4e5","transactions":[],"transactionsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"}
}

BlockByNumber

根据区块高度查询区块信息

参数
- pos:
  - "latest" 最新块高(默认)
  - "earliest" 最低块高
  - "pending" 未打包交易
  - *big.Int 指定块高
返回值


(string, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  block, err := web3g.BlockByNumber("latest")
  fmt.Println(block, err)
  // Expect Output: {"extraData":"0xd8820d0085616c61796188676f312e31362e32856c696e7578000000000000007b16a535ffdd3d17fca3a6bc48af875566cadff4ba056799403edc400b1381ee79c100bd9659b21fce74c855e304e511d0675ffd987c2a736dbc60f794aba7e801","gasLimit":"0x8fcf88","gasUsed":"0x0","hash":"0x38831d18d2339dc6b253235c4b15e1e0e41b3051d704e9569cf617440e17ee5a","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","miner":"atp1zqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqr5jy24r","nonce":"0x02b6d7efb3c656fe57ac0bbd237121bcc45e5a8c29837d2a4d52e942c1533fa2823b6a483227e6ca8d77c140c3522d21eeeb39ea18e779ec7771744fb8f5122ecb1a730e5203d83fa25e7fdb18ebff6bde","number":"0x9228","parentHash":"0xb77808424333dfdc1e94a8bcfcc9fc2aeabc5152b244282d1e559c3f42f2679f","receiptsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421","size":"0x2db","stateRoot":"0x90bb5621483f7b2da204739b63c50f5428316b715cef685aa33fe9c2d86a99d5","timestamp":"0x17aaa0f7f15","transactions":[],"transactionsRoot":"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"}
}

TransactionByBlockHashAndIndex

根据区块hash查询区块中指定序号的交易

参数
- string : blockHash 区块hash
- *big.Int ： transactionIndex 交易在区块中的序号
返回值


(*types.Transaction, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  tx, err := web3g.TransactionByBlockHashAndIndex(common.HexToHash("0x733a072fd7d074f4116585c7be7c036c86ead3f453265b8c34ba56a99b9f6bcc"), 0)
  fmt.Println(tx, err)
}

TransactionByBlockNumberAndIndex

根据区块高度查询区块中指定序号的交易

参数
- pos:
  - "latest" 最新块高(默认)
  - "earliest" 最低块高
  - "pending" 未打包交易
  - *big.Int 指定块高
- index: uint
返回值


(*types.Transaction, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  tx, err := web3g.TransactionByBlockNumberAndIndex("pending", 1)
  fmt.Println(tx, err)
}

TransactionReceipt

根据交易hash查询交易回执

参数
- common.Hash : transactionHash 交易hash
返回值


(*types.Receipt, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  tx, err := web3g.TransactionReceipt(common.HexToHash("0x733a072fd7d074f4116585c7be7c036c86ead3f453265b8c34ba56a99b9f6bcc"))
  fmt.Println(tx, err)
}

AdminGetProgramVersion

获取代码版本

参数
无
返回值


(*params.ProgramVersion, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  pv, err := web3g.AdminGetProgramVersion()
  fmt.Println(pv, err)
  // Expect Output: {4096 0x0dca7024507a5d94c84b9c9deb417d56bf58f6fe5e37ecee86e64a62d1f518b67ddeeed7ba59a619b7f30ecd881164e96f9781b30309c07ea8985929401692de00}
}

ProgramVersion 对象解析
- *big.Int ： version ：代码版本
- string ： sign ：代码版本签名

GetSchnorrNIZKProve

获取bls的证明

参数
无
返回值


(string, error)

示例


func main() {
  const alayaEndpoint = "http://172.16.64.132:6789"
  web3g, err := web3go.New(alayaEndpoint)


  p, err := web3g.GetSchnorrNIZKProve()
  fmt.Println(p, err)
  // Expect Output: b9f8498559d91d4823c2bea19a2ee315cc4418a3bfe06d328c99e7567d725939e7df9ec1902ca910cf789471342b971ed0810d7d61cda5dfb54b9270c9557256
}

系统合约调用

系统接口主要包含经济模型和治理相关的合约接口：

质押相关接口
委托相关接口
奖励相关接口
节点相关接口
治理相关接口
举报相关接口
锁仓相关接口

如上接口的介绍和使用，请参考如下接口说明。

使用合约时, 需要提供Credentials, 本文档中的示例, 统一使用以下的credential:


const PrivateKey = "ed72066fa30607420635be56785595ccf935675a890bef7c808afc1537f52281"
var credentials, _ = typedefs.NewCredential(PrivateKey, network.MainNetHrp)

质押相关接口

质押相关的接口：主要包括节点质押、修改质押信息、解除质押、查询质押信息等接口

接口说明

Staking

节点质押：适用于矿工，节点质押后才有机会参与共识，获得收益。质押前需要自己的节点接入网络，质押时rpc链接地址必须是当前需要质押的节点。如果质押成功，节点会出现在候选人列表中。

入参
- NodeId 节点id，16进制格式，即节点公钥，可以通过管理台查询。
- Amount 质押的金额
- StakingAmountType 表示使用账户自由金额还是账户的锁仓金额做质押，StakingAmountType.FREE_AMOUNT_TYPE：自由金额，StakingAmountType.RESTRICTING_AMOUNT_TYPE：锁仓金额
- BenefitAddress 收益账户，用于接收出块奖励和质押奖励的收益账户。
- NodeName 节点的名称
- ExternalId 外部Id(有长度限制，给第三方拉取节点描述的Id)，目前为keybase账户公钥，节点图标是通过该公钥获取。
- WebSite 节点的第三方主页(有长度限制，表示该节点的主页)
- Details 节点的描述(有长度限制，表示该节点的描述)
- ProgramVersion 程序的真实版本，通过治理rpc获取
- BlsPubKey bls的公钥
- BlsProof bls的证明，通过治理rpc获取
- RewardPer 委托所得到的奖励分成比例，1=0.01% 10000=100%
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash 交易的hash
合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewStakingContract(config, credentials)


  sp := req.StakingParam{
    NodeId:            "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050",
    Amount:            big.NewInt(10),
    StakingAmountType: typedefs.FREE_AMOUNT_TYPE,
    BenefitAddress:    MainFanAccount,
    ExternalId:        "",
    NodeName:          "chendai-node3",
    WebSite:           "www.baidu.com",
    Details:           "chendai-node3-details",
    ProcessVersion: typedefs.ProgramVersion{
      Version: big.NewInt(4096),
      Sign:    "0x0dca7024507a5d94c84b9c9deb417d56bf58f6fe5e37ecee86e64a62d1f518b67ddeeed7ba59a619b7f30ecd881164e96f9781b30309c07ea8985929401692de00",
    },
    BlsPubKey: "0x5ccd6b8c32f2713faa6c9a46e5fb61ad7b7400e53fabcbc56bdc0c16fbfffe09ad6256982c7059e7383a9187ad93a002a7cda7a75d569f591730481a8b91b5fad52ac26ac495522a069686df1061fc184c31771008c1fedfafd50ae794778811",
    BlsProof:  "0xa8fadadfc215f4f73fcdd539f5c2c8228a948f9d9f1f840329965a4abaec284be94d76f02839a0dd73d5a446dd5cd415c10b6ce621f0b1226924b8f3633f055a94b86446bb57dba0c9e85fb2e4b065773be39d8435352b6542a43c953afa0981",
    RewardPer: big.NewInt(1000),
  }


  tx, err := sc.Staking(sp)
  fmt.Println(tx, err)
}

UnStaking

节点撤销质押(一次性发起全部撤销，多次到账)，成功后节点会从候选人列表移除。只能由该节点的质押钱包地址发起交易。

入参
- string: nodeId 节点id，16进制格式，即节点公钥
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash 交易的回执

合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewStakingContract(config, credentials)


  nodeId := "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050"


  list, err := sc.UnStaking(nodeId)
  if err != nil {
    t.Errorf("StakingContract.UnStaking failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }
  fmt.Println(string(result))
}

UpdateStakingInfo

修改质押信息，只能由该节点的质押钱包地址发起交易。

入参
- string: nodeId 节点id，16进制格式，即节点公钥，可以通过管理台查询（platon attach http://127.0.0.1:6789 --exec "admin.nodeInfo.id"）。
- string: benifitAddress 收益账户，用于接收出块奖励和质押奖励的收益账户。
- string: nodeName 节点的名称
- string: externalId 外部Id(有长度限制，给第三方拉取节点描述的Id)，目前为keybase账户公钥，节点图标是通过该公钥获取。
- string: webSite 节点的第三方主页(有长度限制，表示该节点的主页)
- string: details 节点的描述(有长度限制，表示该节点的描述)
- *big.Int: rewardPer 委托所得到的奖励分成比例，1=0.01% 10000=100%
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash 交易的回执

合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewStakingContract(config, credentials)


  req := req.UpdateStakingParam{
    NodeId:         "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050",
    BenifitAddress: MainFanAccount,
    ExternalId:     "",
    NodeName:       "chendai-node3",
    WebSite:        "www.baidu.com",
    Details:        "chendai-node3-details",
    RewardPer:      big.NewInt(1000),
  }
  list, err := sc.UpdateStakingInfo(req)
  if err != nil {
    t.Errorf("StakingContract.UpdateStakingInfo failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

AddStaking

增持质押，增加已质押节点质押金，只能由该节点的质押钱包地址发起交易。

入参
- string: nodeId 节点id，16进制格式，即节点公钥
- StakingAmountType：stakingAmountType 表示使用账户自由金额还是账户的锁仓金额做质押，StakingAmountType.FREE_AMOUNT_TYPE：自由金额，StakingAmountType.RESTRICTING_AMOUNT_TYPE：锁仓金额
- *big.Int: addStakingAmount 增持的金额
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash 交易的回执

合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewStakingContract(config, credentials)


  nodeId := "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050"


  list, err := sc.AddStaking(nodeId, typedefs.FREE_AMOUNT_TYPE, big.NewInt(10))
  if err != nil {
    t.Errorf("StakingContract.AddStaking failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

GetStakingInfo

查询当前节点的质押信息

入参
- string: nodeId 节点id，16进制格式，即节点公钥
返回值


resp.Node, error

Node：保存单个候选节点信息对象
- string: NodeId 被质押的节点Id(也叫候选人的节点Id)
- string: StakingAddress 发起质押时使用的账户
- string: BenifitAddress 用于接受出块奖励和质押奖励的收益账户
- *big.Int: RewardPer 当前结算周期奖励分成比例
- *big.Int: NextRewardPer 下一个结算周期奖励分成比例
- *big.Int: StakingTxIndex 发起质押时的交易索引
- *big.Int: ProgramVersion 被质押节点的PlatON进程的真实版本号(获取版本号的接口由治理提供)
- *big.Int: Status 候选人的状态，0: 节点可用，1: 节点不可用，2:节点出块率低但没有达到移除条件的，4:节点的最低质押门槛，8:节点被举报双签，16:节点出块率低且达到移除条件, 32: 节点主动发起撤销
- *big.Int: StakingEpoch 当前变更质押金额时的结算周期
- *big.Int: StakingBlockNum 发起质押时的区块高度
- *big.Int: Shares 当前候选人总共质押加被委托的数目
- *big.Int: Released 发起质押账户的自由金额的锁定期质押的数量
- *big.Int: ReleasedHes 发起质押账户的自由金额的犹豫期质押的数量
- *big.Int: RestrictingPlan 发起质押账户的锁仓金额的锁定期质押的数量
- *big.Int: RestrictingPlanHes 发起质押账户的锁仓金额的犹豫期质押的数量
- string: ExternalId 外部Id(有长度限制，给第三方拉取节点描述的Id)，目前为keybase账户公钥，节点图标是通过该公钥获取。
- string: NodeName 被质押节点的名称(有长度限制，表示该节点的名称)
- string: Website 节点的第三方主页(有长度限制，表示该节点的主页)
- string: Details 节点的描述(有长度限制，表示该节点的描述)
- *big.Int: DelegateEpoch 节点最后一次被委托的结算周期
- *big.Int: DelegateTotal 节点被委托的生效总数量
- *big.Int: DelegateTotalHes 节点被委托的未生效总数量
- *big.Int: DelegateRewardTotal 候选人当前发放的总委托奖励
合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewStakingContract(config, credentials)


  list, err := sc.GetStakingInfo(SNZPoolId)
  if err != nil {
    t.Errorf("StakingContract.GetStakingInfo failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

GetPackageReward

查询当前结算周期的区块奖励

入参
无
返回值


(*big.Int, error)

合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewStakingContract(config, credentials)


  list, err := sc.GetPackageReward()
  if err != nil {
    t.Errorf("StakingContract.GetPackageReward failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

GetStakingReward

查询当前结算周期的质押奖励

入参
无
返回值


(*big.Int, error)

合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewStakingContract(config, credentials)


  list, err := sc.GetStakingReward()
  if err != nil {
    t.Errorf("StakingContract.GetStakingReward failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }
  fmt.Println(string(result))
}

GetAvgPackTime

查询打包区块的平均时间

入参
无
返回值


(*big.Int, error)

合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewStakingContract(config, credentials)


  list, err := sc.GetAvgPackTime()
  if err != nil {
    t.Errorf("StakingContract.GetAvgPackTime failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
  // 1073
}

委托相关接口

PlatON经济模型中委托人相关的合约接口

接口说明

Delegate

发起委托，委托已质押节点，委托给某个节点增加节点权重来获取收入

入参
- string: nodeId 节点id，16进制格式，即节点公钥.
- StakingAmountType：stakingAmountType 表示使用账户自由金额还是账户的锁仓金额做质押，StakingAmountType.FREE_AMOUNT_TYPE：自由金额，StakingAmountType.RESTRICTING_AMOUNT_TYPE：锁仓金额
- *big.Int: amount 委托的金额，单位Token，默认委托金额必须大于等于10LAT，该大小限制可以通过治理参数动态调整，可通过治理接口获得当前值（proposalContract.getGovernParamValue("staking", "operatingThreshold")）。
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash 交易的回执

合约使用


func main() {
  config := network.PposMainNetParams
  dc := NewDelegateContract(config, credentials)


  nodeId := "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050"


  amount := new(big.Int)
  amount.SetString("200000000000000000000", 10)
  list, err := dc.Delegate(nodeId, typedefs.FREE_AMOUNT_TYPE, amount)
  if err != nil {
    t.Errorf("DelegateContract.Delegate failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

UnDelegate

减持/撤销委托(全部减持就是撤销)

入参
- string: nodeId 节点id，16进制格式，0x开头
- *big.Int: stakingBlockNum 委托节点的质押块高，代表着某个node的某次质押的唯一标示
- *big.Int: stakingAmount 减持的委托金额(按照最小单位算，1LAT = 10**18 Token)
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash 交易的回执

解交易回执
- *big.Int: Reward 获得解除委托时所提取的委托收益
合约使用


func main() {
  config := network.PposMainNetParams
  dc := NewDelegateContract(config, credentials)


  nodeId := "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050"
  stakingBlockNumber := big.NewInt(129518)
  amount := new(big.Int)
  amount.SetString("100000000000000000000", 10)
  list, err := dc.UnDelegate(nodeId, stakingBlockNumber, amount)
  if err != nil {
    t.Errorf("DelegateContract.UnDelegate failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

奖励相关接口

PlatON经济模型中奖励相关的合约接口

接口说明

WithdrawDelegateReward

提取账户当前所有的可提取的委托奖励

入参
无
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash：交易的回执

解交易回执
- string：NodeId 节点ID
- *big.Int：StakingNum 节点的质押块高
- *big.Int：Reward 领取到的收益
合约使用


const (
  MainFanAccount = "atp1qv5ffg7z3h42zt4e035vja65d86al7q0nr9s0g"
  SNZPoolId      = "0xc0dc97ee57ba202faf012ecb72bf30aebcd2cf7c161d7012017e0320e0db15925c107998bd833d61ec4c2689172d7e34a0371f4511773641e00814c2632b0e66"
  XiaoYiId       = "0x0423022e05633d8d2a80cb66d65d7b8bb267ef3c5deeb6cc124726219ddcd05194f6e958207443c3d39fb81b1072025b24525c7f2a14a2a2076b59a9af7bb70e"
)


func main() {
  config := network.PposMainNetParams
  rc := NewRewardContract(config, credentials)


  receipt, err := rc.WithdrawDelegateReward()
  if err != nil {
    t.Errorf("Get Delegate Reward info failed: %s", err)
  }


  fmt.Println(receipt)
}

GetDelegateReward

查询当前账号可提取奖励明细

入参
- string：Address 委托人的账户地址
- []string： NodeList 节点列表，如果为空查全部
返回值


([]resp.Reward, error)

Reward：奖励明细
- string：nodeId 节点ID
- *big.Int：stakingNum 节点的质押块高
- *big.Int：reward 领取到的收益
合约使用


const (
  MainFanAccount = "atp1qv5ffg7z3h42zt4e035vja65d86al7q0nr9s0g"
  SNZPoolId      = "0xc0dc97ee57ba202faf012ecb72bf30aebcd2cf7c161d7012017e0320e0db15925c107998bd833d61ec4c2689172d7e34a0371f4511773641e00814c2632b0e66"
  XiaoYiId       = "0x0423022e05633d8d2a80cb66d65d7b8bb267ef3c5deeb6cc124726219ddcd05194f6e958207443c3d39fb81b1072025b24525c7f2a14a2a2076b59a9af7bb70e"
)


func main() {
  config := network.PposMainNetParams
  rc := NewRewardContract(config, credentials)


  addr := common.MustBech32ToAddress(MainFanAccount)
  nodeId := []string{SNZPoolId, XiaoYiId}


  list, err := rc.GetDelegateReward(addr, nodeId)
  if err != nil {
    t.Errorf("Get Delegate Reward info failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
  // Expect Output: [{"nodeId":"0423022e05633d8d2a80cb66d65d7b8bb267ef3c5deeb6cc124726219ddcd05194f6e958207443c3d39fb81b1072025b24525c7f2a14a2a2076b59a9af7bb70e","stakingNum":10464209,"reward":"0x9715aca6c9eadbf2"},{"nodeId":"c0dc97ee57ba202faf012ecb72bf30aebcd2cf7c161d7012017e0320e0db15925c107998bd833d61ec4c2689172d7e34a0371f4511773641e00814c2632b0e66","stakingNum":500930,"reward":"0x16455593f23fd3c07"}]
}

节点相关合约

PlatON经济模型中委托人相关的合约接口

接口说明

GetVerifierList

查询当前结算周期的验证人队列

入参
无
返回值


[]resp.Node, error

Node：保存单个候选节点信息对象
- string: NodeId 被质押的节点Id(也叫候选人的节点Id)
- string: StakingAddress 发起质押时使用的账户(撤销质押时，Token会被退回该账户或者该账户的锁仓信息中)
- string: BenifitAddress 用于接受出块奖励和质押奖励的收益账户
- *big.Int: RewardPer 当前结算周期奖励分成比例
- *big.Int: NextRewardPer 下一个结算周期奖励分成比例
- *big.Int: StakingTxIndex 发起质押时的交易索引
- *big.Int: ProgramVersion 被质押节点的PlatON进程的真实版本号(获取版本号的接口由治理提供)
- *big.Int: Status 候选人的状态，0: 节点可用，1: 节点不可用，2:节点出块率低但没有达到移除条件的，4:节点的Token不足最低质押门槛，8:节点被举报双签，16:节点出块率低且达到移除条件, 32: 节点主动发起撤销
- *big.Int: StakingEpoch 当前变更质押金额时的结算周期
- *big.Int: StakingBlockNum 发起质押时的区块高度
- *big.Int: Shares 当前候选人总共质押加被委托的Token数目
- *big.Int: Released 发起质押账户的自由金额的锁定期质押的Token
- *big.Int: ReleasedHes 发起质押账户的自由金额的犹豫期质押的Token
- *big.Int: RestrictingPlan 发起质押账户的锁仓金额的锁定期质押的Token
- *big.Int: RestrictingPlanHes 发起质押账户的锁仓金额的犹豫期质押的Token
- string: ExternalId 外部Id(有长度限制，给第三方拉取节点描述的Id)，目前为keybase账户公钥，节点图标是通过该公钥获取。
- string: NodeName 被质押节点的名称(有长度限制，表示该节点的名称)
- string: Website 节点的第三方主页(有长度限制，表示该节点的主页)
- string: Details 节点的描述(有长度限制，表示该节点的描述)
- *big.Int: DelegateEpoch 节点最后一次被委托的结算周期
- *big.Int: DelegateTotal 节点被委托的生效总数量
- *big.Int: DelegateTotalHes 节点被委托的未生效总数量
- *big.Int: DelegateRewardTotal 候选人当前发放的总委托奖励

合约使用


func main() {
  config := network.PposMainNetParams
  nc := NewNodeContract(config, credentials)


  list, err := nc.GetVerifierList()
  if err != nil {
    t.Errorf("Get Verifier list failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

GetValidatorList

查询当前共识周期的验证人列表

入参
无
返回值


[]resp.Node, error

Node：保存单个候选节点信息对象
- string: NodeId 被质押的节点Id(也叫候选人的节点Id)
- string: StakingAddress 发起质押时使用的账户(撤销质押时，Token会被退回该账户或者该账户的锁仓信息中)
- string: BenifitAddress 用于接受出块奖励和质押奖励的收益账户
- *big.Int: RewardPer 当前结算周期奖励分成比例
- *big.Int: NextRewardPer 下一个结算周期奖励分成比例
- *big.Int: StakingTxIndex 发起质押时的交易索引
- *big.Int: ProgramVersion 被质押节点的PlatON进程的真实版本号(获取版本号的接口由治理提供)
- *big.Int: Status 候选人的状态，0: 节点可用，1: 节点不可用，2:节点出块率低但没有达到移除条件的，4:节点的Token不足最低质押门槛，8:节点被举报双签，16:节点出块率低且达到移除条件, 32: 节点主动发起撤销
- *big.Int: StakingEpoch 当前变更质押金额时的结算周期
- *big.Int: StakingBlockNum 发起质押时的区块高度
- *big.Int: Shares 当前候选人总共质押加被委托的Token数目
- *big.Int: Released 发起质押账户的自由金额的锁定期质押的Token
- *big.Int: ReleasedHes 发起质押账户的自由金额的犹豫期质押的Token
- *big.Int: RestrictingPlan 发起质押账户的锁仓金额的锁定期质押的Token
- *big.Int: RestrictingPlanHes 发起质押账户的锁仓金额的犹豫期质押的Token
- string: ExternalId 外部Id(有长度限制，给第三方拉取节点描述的Id)，目前为keybase账户公钥，节点图标是通过该公钥获取。
- string: NodeName 被质押节点的名称(有长度限制，表示该节点的名称)
- string: Website 节点的第三方主页(有长度限制，表示该节点的主页)
- string: Details 节点的描述(有长度限制，表示该节点的描述)
- *big.Int: DelegateEpoch 节点最后一次被委托的结算周期
- *big.Int: DelegateTotal 节点被委托的生效总数量
- *big.Int: DelegateTotalHes 节点被委托的未生效总数量
- *big.Int: DelegateRewardTotal 候选人当前发放的总委托奖励

合约使用


func main() {
  config := network.PposMainNetParams
  nc := NewNodeContract(config, credentials)


  list, err := nc.GetValidatorList()
  if err != nil {
    t.Errorf("Get Validator list failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

GetCandidateList

查询所有实时的候选人列表

入参
无
返回值


[]resp.Node, error

Node：保存单个候选节点信息对象
- string: NodeId 被质押的节点Id(也叫候选人的节点Id)
- string: StakingAddress 发起质押时使用的账户(撤销质押时，Token会被退回该账户或者该账户的锁仓信息中)
- string: BenifitAddress 用于接受出块奖励和质押奖励的收益账户
- *big.Int: RewardPer 当前结算周期奖励分成比例
- *big.Int: NextRewardPer 下一个结算周期奖励分成比例
- *big.Int: StakingTxIndex 发起质押时的交易索引
- *big.Int: ProgramVersion 被质押节点的PlatON进程的真实版本号(获取版本号的接口由治理提供)
- *big.Int: Status 候选人的状态，0: 节点可用，1: 节点不可用，2:节点出块率低但没有达到移除条件的，4:节点的Token不足最低质押门槛，8:节点被举报双签，16:节点出块率低且达到移除条件, 32: 节点主动发起撤销
- *big.Int: StakingEpoch 当前变更质押金额时的结算周期
- *big.Int: StakingBlockNum 发起质押时的区块高度
- *big.Int: Shares 当前候选人总共质押加被委托的Token数目
- *big.Int: Released 发起质押账户的自由金额的锁定期质押的Token
- *big.Int: ReleasedHes 发起质押账户的自由金额的犹豫期质押的Token
- *big.Int: RestrictingPlan 发起质押账户的锁仓金额的锁定期质押的Token
- *big.Int: RestrictingPlanHes 发起质押账户的锁仓金额的犹豫期质押的Token
- string: ExternalId 外部Id(有长度限制，给第三方拉取节点描述的Id)，目前为keybase账户公钥，节点图标是通过该公钥获取。
- string: NodeName 被质押节点的名称(有长度限制，表示该节点的名称)
- string: Website 节点的第三方主页(有长度限制，表示该节点的主页)
- string: Details 节点的描述(有长度限制，表示该节点的描述)
- *big.Int: DelegateEpoch 节点最后一次被委托的结算周期
- *big.Int: DelegateTotal 节点被委托的生效总数量
- *big.Int: DelegateTotalHes 节点被委托的未生效总数量
- *big.Int: DelegateRewardTotal 候选人当前发放的总委托奖励
合约使用


func main() {
  config := network.PposMainNetParams
  nc := NewNodeContract(config, credentials)


  list, err := nc.GetCandidateList()
  if err != nil {
    t.Errorf("Get Candidate list failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
  // {"NodeId":"ab74f5500dd35497ce09b2dc92a3da26ea371dd9f6d438559b6e19c8f1622ee630951b510cb370aca8267f9bb9a9108bc532ec48dd077474cb79a48122f2ab03","BlsPubKey":"a74daa9361921a6d42eb8c150976efea2dab4a56d5177c9e4834985ce6e85270870c158bd47a67381d832ce2fe2b5c035c807d06a9468ed4cd7fef3cce3efbec0a0f40019cbe541266281c4fc86cbde3e7ae52932987328ea1313f754d33d504","StakingAddress":"atp16lcj06w6q2md0cztxru2z3sss4mrjy9vlkaaeu","BenefitAddress":"atp1r6jegq7twgcmnv6w3zhjlnlm9t5lsnsca72a6u","RewardPer":8888,"NextRewardPer":8888,"RewardPerChangeEpoch":48,"StakingTxIndex":0,"ProgramVersion":3840,"Status":0,"StakingEpoch":49,"StakingBlockNum":507203,"Shares":"0x1acf31fa638ce992fe9c","Released":"0x46a10a47349e9769c","ReleasedHes":"0x0","RestrictingPlan":"0x21e19e0c9bab2400000","RestrictingPlanHes":"0x0","DelegateEpoch":2038,"DelegateTotal":"0x1250a7164caaa53d8800","DelegateTotalHes":"0x0","DelegateRewardTotal":"0x3bf2da80056ba48c4dd","ExternalId":"DB667A6F239969F5","NodeName":"IRISnet-Bianjie","Website":"https://irisnet.org/irisnet-bianjie","Details":"Interchain Service Hub for NextGen Distributed Applications."},
}

治理相关合约

PlatON治理相关的合约接口

接口说明

SubmitProposal

提交提案

入参
- resp.Proposal: 提案对象
文本提案 CreateTextProposal
- string：Verifier 提交提案的验证人
- string：PIDID PIPID
升级提案 CreateVersionProposal
- string: verifier 提交提案的验证人
- string: pIDID PIPID
- *big.Int: newVersion 升级版本
- *big.Int: endVotingRounds 投票共识轮数量。说明：假设提交提案的交易，被打包进块时的共识轮序号时round1，则提案投票截止块高，就是round1 + endVotingRounds这个共识轮的第230个块高（假设一个共识轮出块250，ppos揭榜提前20个块高，250，20都是可配置的），其中0 < endVotingRounds <= 4840（约为2周，实际论述根据配置可计算），且为整数）
参数提案 CreateParamProposal
- string: Verifier 提交提案的验证人
- string: PIDID PIPID
- string: Module 参数模块
- string: Name 参数名称
- string: NewValue 参数新值
取消提案 CreateCancelProposal
- string: Verifier 提交提案的验证人
- string: PIDID PIPID
- *big.Int: EndVotingRounds 投票共识轮数量。参考提交升级提案的说明，同时，此接口中此参数的值不能大于对应升级提案中的
- string: TobeCanceledProposalID 待取消的提案ID
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash：交易的回执

合约使用


func main() {
  config := network.PposMainNetParams
  pc := NewProposalContract(config, credentials)


  nodeId := "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050"
  proposal := resp.CreateTextProposal(nodeId, "1000")


  list, err := pc.SubmitProposal(proposal)
  if err != nil {
    t.Errorf("ProposalContract.SubmitTextProposal failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
  // 0x0c780c48043192c722cb152f18281ba0aa54d622d8cf6eb5fc3c7b9f1cc27606
}

Vote

给提案投票

入参
- ProgramVersion:ProgramVersion 程序的真实版本，治理rpc接口admin_getProgramVersion获取
- VoteOption：VoteOption 投票类型，YEAS 赞成票，NAYS 反对票，ABSTENTIONS 弃权票
- string: ProposalID 提案ID
- string: Verifier 声明的节点，只能是验证人/候选人
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash 交易的回执

合约使用：


func main() {
  config := network.PposMainNetParams
  pc := NewProposalContract(config, credentials)


  proposalId := "0x261cf6c0f518aeddffb2aa5536685af6f13f8ba763c77b42f12ce025ef7170ed"
  pv := typedefs.ProgramVersion{
    Version: big.NewInt(4096),
    Sign:    "0x0dca7024507a5d94c84b9c9deb417d56bf58f6fe5e37ecee86e64a62d1f518b67ddeeed7ba59a619b7f30ecd881164e96f9781b30309c07ea8985929401692de00",
  }
  voption := typedefs.YEAS
  nodeId := "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050"


  list, err := pc.Vote(pv, voption, proposalId, nodeId)
  if err != nil {
    t.Errorf("ProposalContract.Vote failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

GetProposal

查询提案

入参
- string: ProposalID 提案id
返回值


(resp.Proposal, error)

Proposal：保存单个提案信息的对象
- string: ProposalId 提案ID
- string: Proposer 提案节点ID
- int: ProposalType 提案类型， 0x01：文本提案； 0x02：升级提案；0x03参数提案 0x04取消提案
- string: PiPid 提案PIPID
- *big.Int: SubmitBlock 提交提案的块高
- *big.Int: EndVotingBlock 提案投票结束的块高
- *big.Int: NewVersion 升级版本
- *big.Int: ToBeCanceled 提案要取消的升级提案ID
- *big.Int: ActiveBlock 提案生效块高，系统根据EndVotingBlock算出
- string: Verifier 提交提案的验证人
合约使用


func main() {
  config := network.PposMainNetParams
  pc := NewProposalContract(config, credentials)


  proposalId := "0x261cf6c0f518aeddffb2aa5536685af6f13f8ba763c77b42f12ce025ef7170ed"
  list, err := pc.GetProposal(proposalId)
  if err != nil {
    t.Errorf("ProposalContract.GetProposal failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
  // {"ProposalID":"0x261cf6c0f518aeddffb2aa5536685af6f13f8ba763c77b42f12ce025ef7170ed","Proposer":"9460fce5beea98e4d56c62a920bb041f45e48a5a7b96d12d02a16cbb20863be9c76491127533d9cefa5b4cec48ae6595b7ba347ef7dc8277cfb343eebde4646b","ProposalType":2,"PIPID":"12","SubmitBlock":5194289,"EndVotingBlock":5619480,"NewVersion":3584,"TobeCanceled":"","ActiveBlock":5619501,"Verifier":"","Module":"","Name":"","NewValue":""}


}

GetTallyResult

查询提案结果

入参
- string: proposalID 提案ID
返回值


(resp.TallyResult, error)

TallyResult：保存单个提案结果的对象
- string: ProposalID 提案ID
- *big.Int: Yeas 赞成票票数
- *big.Int: Nays 反对票票数
- *big.Int: Abstentions 弃权票票数
- *big.Int: AccuVerifiers 在整个投票期内有投票资格的验证人总数
- int: Status 提案状态
status
- 1 投票中
- 2 投票通过
- 3 投票失败
- 4 （升级提案）预生效
- 5 （升级提案）生效
- 6 被取消
合约使用


func main() {
  config := network.PposMainNetParams
  pc := NewProposalContract(config, credentials)


  proposalId := "0x261cf6c0f518aeddffb2aa5536685af6f13f8ba763c77b42f12ce025ef7170ed"
  list, err := pc.GetTallyResult(proposalId)
  if err != nil {
    t.Errorf("ProposalContract.GetTallyResult failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }
  fmt.Println(string(result))
  // {"ProposalID":"0x261cf6c0f518aeddffb2aa5536685af6f13f8ba763c77b42f12ce025ef7170ed","Yeas":102,"Nays":0,"Abstentions":0,"AccuVerifiers":116,"Status":5}
}

GetProposalList

查询提案列表

入参
无
返回值


[]resp.Proposal, error

Proposal：保存单个提案的对象
- string: ProposalId 提案ID
- string: Proposer 提案节点ID
- int: ProposalType 提案类型， 0x01：文本提案； 0x02：升级提案；0x03参数提案
- string: PiPid 提案PIPID
- *big.Int: SubmitBlock 提交提案的块高
- *big.Int: EndVotingBlock 提案投票结束的块高
- *big.Int: NewVersion 升级版本
- string: ToBeCanceled 提案要取消的升级提案ID
- *big.Int: ActiveBlock 提案生效块高，系统根据EndVotingBlock算出
- string: Verifier 提交提案的验证人
合约使用


func main() {
  config := network.PposMainNetParams
  pc := NewProposalContract(config, credentials)


  list, err := pc.GetProposalList()
  if err != nil {
    t.Errorf("ProposalContract.GetProposalList failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
  // [{"ProposalID":"0x261cf6c0f518aeddffb2aa5536685af6f13f8ba763c77b42f12ce025ef7170ed","Proposer":"9460fce5beea98e4d56c62a920bb041f45e48a5a7b96d12d02a16cbb20863be9c76491127533d9cefa5b4cec48ae6595b7ba347ef7dc8277cfb343eebde4646b","ProposalType":2,"PIPID":"12","SubmitBlock":5194289,"EndVotingBlock":5619480,"NewVersion":3584,"TobeCanceled":"","ActiveBlock":5619501,"Verifier":"","Module":"","Name":"","NewValue":""},{"ProposalID":"0xf61e717687fb76ef097b7078f9ea6723dd30926ec754ffc4db266b57461b1011","Proposer":"9460fce5beea98e4d56c62a920bb041f45e48a5a7b96d12d02a16cbb20863be9c76491127533d9cefa5b4cec48ae6595b7ba347ef7dc8277cfb343eebde4646b","ProposalType":2,"PIPID":"14","SubmitBlock":8296399,"EndVotingBlock":8623980,"NewVersion":3840,"TobeCanceled":"","ActiveBlock":8624001,"Verifier":"","Module":"","Name":"","NewValue":""},{"ProposalID":"0x81a704420dfdafb9056ad1b85066d896899186dac4ce5f72753c8e74131841bc","Proposer":"0eb6b43a9945a062e67b45248084ec4b5da5f22d35a58991c8f508666253fbd1b679b633728f4c3384ee878ca5efca7623786fdf623b4e5288ace830dc237614","ProposalType":1,"PIPID":"15","SubmitBlock":10894675,"EndVotingBlock":12104230,"NewVersion":null,"TobeCanceled":"","ActiveBlock":null,"Verifier":"","Module":"","Name":"","NewValue":""}]
}

DeclareVersion

版本声明

入参
- ProgramVersion:ProgramVersion 程序的真实版本，治理rpc接口admin_getProgramVersion获取
- string: Verifier 声明的节点，只能是验证人/候选人
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash 交易的回执

合约使用


func main() {
  config := network.PposMainNetParams
  pc := NewProposalContract(config, credentials)
  version := typedefs.ProgramVersion{
    Version: big.NewInt(4096),
    Sign:    "0x0dca7024507a5d94c84b9c9deb417d56bf58f6fe5e37ecee86e64a62d1f518b67ddeeed7ba59a619b7f30ecd881164e96f9781b30309c07ea8985929401692de00",
  }


  verifier := "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050"
  list, err := pc.DeclareVersion(version, verifier)
  if err != nil {
    t.Errorf("ProposalContract.DeclareVersion failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

GetActiveVersion

查询节点的链生效版本

入参
无
返回值


(uint64, error)

合约使用


func main() {
  config := network.PposMainNetParams
  pc := NewProposalContract(config, credentials)


  list, err := pc.GetActiveVersion()
  if err != nil {
    t.Errorf("ProposalContract.GetActiveVersion failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
  // 3804
}

双签举报相关接口

PlatON举报惩罚相关的合约接口

接口说明

ReportDoubleSign

举报双签

入参
- typedefs.DuplicateSignType: 枚举，代表双签类型：PREPARE_BLOCK，PREPARE_VOTE，VIEW_CHANGE
- string：data 单个证据的json值，格式参照RPC接口Evidences
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash：交易的回执

合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewSlashContract(config, credentials)


  evidence := "{\"prepareA\":{\"epoch\":0,\"viewNumber\":0,\"blockHash\":\"0x47c0b9cc1e544e866ed3afb1a2fec5f8c0c6d97a04680f56f26b238b362482ca\",\"blockNumber\":583848,\"blockIndex\":0,\"blockData\":\"0x005e8ae4a78cd34d2c9fb08abda0e39d781e4abc58ea7f9b03c56f6a8e804027\",\"validateNode\":{\"index\":0,\"address\":\"0x0550184a50db8162c0cfe9296f06b2b1db019331\",\"nodeId\":\"77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050\",\"blsPubKey\":\"5ccd6b8c32f2713faa6c9a46e5fb61ad7b7400e53fabcbc56bdc0c16fbfffe09ad6256982c7059e7383a9187ad93a002a7cda7a75d569f591730481a8b91b5fad52ac26ac495522a069686df1061fc184c31771008c1fedfafd50ae794778811\"},\"signature\":\"0x974d787c28b7fb2ec67decdb750e4e29ace69e07ab3d1864c4fba9b7eb780868fb36966183ac6f156b99b0f1d8034d8500000000000000000000000000000000\"},\"prepareB\":{\"epoch\":0,\"viewNumber\":0,\"blockHash\":\"0x4bf9291e34fb7ae3f93eb4bb77a4b41251dce247e4a9b8e120dbf69a310f87bb\",\"blockNumber\":583848,\"blockIndex\":0,\"blockData\":\"0x4b6fd7afae0fd5ab3b2457720297165539623562eff16827981904357720b995\",\"validateNode\":{\"index\":0,\"address\":\"0x0550184a50db8162c0cfe9296f06b2b1db019331\",\"nodeId\":\"77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050\",\"blsPubKey\":\"5ccd6b8c32f2713faa6c9a46e5fb61ad7b7400e53fabcbc56bdc0c16fbfffe09ad6256982c7059e7383a9187ad93a002a7cda7a75d569f591730481a8b91b5fad52ac26ac495522a069686df1061fc184c31771008c1fedfafd50ae794778811\"},\"signature\":\"0x615967a22bb06245a76c94ce8914c95bdc9eda8fbfaa97b85d8472c7c7bb10bc6aff325798965e583130690ac7ef568c00000000000000000000000000000000\"}}"
  list, err := sc.ReportDoubleSign(typedefs.PREPARE_BLOCK, evidence)
  if err != nil {
    t.Errorf("SlashContract.ReportDoubleSign failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

CheckDoubleSign

查询节点是否已被举报过多签

入参
- typedefs.DuplicateSignType 枚举，代表双签类型：prepareBlock，EprepareVote，viewChange
- string：address 举报的节点地址
- *big.Int: blockNumber 多签的块高
返回值


(string, error)

合约使用


func main() {
  config := network.PposMainNetParams
  sc := NewSlashContract(config, credentials)


  nodeId := "0x77fffc999d9f9403b65009f1eb27bae65774e2d8ea36f7b20a89f82642a5067557430e6edfe5320bb81c3666a19cf4a5172d6533117d7ebcd0f2c82055499050"
  blockNumber := big.NewInt(583848)
  list, err := sc.CheckDoubleSign(typedefs.PREPARE_BLOCK, nodeId, blockNumber)
  if err != nil {
    t.Errorf("SlashContract.CheckDoubleSign failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }
  fmt.Println(string(result))
}

锁仓相关接口

PlatON锁仓相关接口

接口说明

CreateRestrictingPlan

创建锁仓计划

入参
- string：address 锁仓释放到账账户
- []resp.RestrictingPlan 锁仓计划列表（数组）
  - Epoch：锁仓的周期，表示结算周期的倍数
  - Amount：表示目标区块上待释放的金额。
返回值


(typedefs.TransactionHash, error)

typedefs.TransactionHash：交易的回执

合约使用


func main() {
  config := network.PposMainNetParams
  rpc := NewRestrictingPlanContract(config, credentials)


  addr := common2.MustBech32ToAddress(MainFanAccount)


  plan1Amount := new(big.Int)
  plan1Amount.SetString("1000000000000000000", 10)
  plan1 := resp.RestrictingPlan{
    Epoch:  big.NewInt(100),
    Amount: plan1Amount,
  }


  plan2Amount := new(big.Int)
  plan2Amount.SetString("2000000000000000000", 10)
  plan2 := resp.RestrictingPlan{
    Epoch:  big.NewInt(200),
    Amount: plan2Amount,
  }
  plans := []resp.RestrictingPlan{plan1, plan2}


  list, err := rpc.CreateRestrictingPlan(addr, plans)
  if err != nil {
    t.Errorf("RestrictingPlanContract.CreateRestrictingPlan failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }


  fmt.Println(string(result))
}

GetRestrictingInfo

获取锁仓计划

入参
- common.Address address 锁仓释放到账账户
返回值


(resp.RestrictingItem, error)

RestrictingItem：保存锁仓信息对象
- *big.Int: Balance 锁仓余额
- *big.Int: Pledge 质押/抵押金额
- *big.Int: Debt 欠释放金额
- []RestrictingInfo：Info 锁仓分录信息
RestrictingInfo：保存单个锁仓分录信息的对象
- *big.Int: BlockNumber 释放区块高度
- *big.Int: Amount 释放金额
合约使用


func main() {
  config := network.PposMainNetParams
  rpc := NewRestrictingPlanContract(config, credentials)


  addr := common2.MustBech32ToAddress(MainFanAccount)
  list, err := rpc.GetRestrictingInfo(addr)
  if err != nil {
    t.Errorf("RestrictingPlanContract.GetRestrictingInfo failed: %s", err)
  }


  result, err := json.Marshal(list)
  if err != nil {
    t.Errorf("Marshal of list failed: %s", err)
  }
  fmt.Println(string(result))
}

Solidity合约调用

Alaya sdk的contracts模块用于在Alaya网络上部署, 操作智能合约.

准备工作

要通过sdk部署和调用合约, 需要使用到solc, 请按照官方文档安装好solc编译器. 以及按照Alaya-Go 的说明, 项目编译成功之后, 在build/bin目录下, 可以找到abigen工具.

为了演示如何使用, 我们准备了一个测试合约store.sol(关于如何编写合约, 请参考solidity官方教程):


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;


contract Store {
  event ItemSet(bytes32 key, bytes32 value);


  string public version;
  mapping (bytes32 => bytes32) public items;


  constructor(string memory _version) {
    version = _version;
  }


  function setItem(bytes32 key, bytes32 value) external {
    items[key] = value;
    emit ItemSet(key, value);
  }
}

然后, 我们使用以下命令, 编译出我们需要的bin和abi文件:
solc --bin --abi store.sol -o Store
执行成功之后, 会在Store目录下生成Store.abi和Store.bin两个文件.

接着, 我们使用abigen工具, 生成Store.go文件:
abigen --bin=Store.bin --abi=Store.abi --pkg=store --out=Store.go

至此, 我们需要的文件已经准备完毕.

本文以下部分描述的操作, 可以在这里找到完整的使用示例.

部署合约

在操作合约之前, 我们需要先获得一个Contract对象:


contract := contracts.Contract{
    Url:        AlayaEndpoint,
    PrivateKey: privateKey,
}


opts, client, err := contract.Init()
if err != nil {
    log.Fatal(err)
}

在Init操作完成之后, 我们获得了opts和client对象, 它们的类型分别是*bind.TransactOpts和bind.ContractBackend, 有了这两个对象, 我们就可以通过以下代码来部署合约了:


func toDeployContract(opts *bind.TransactOpts, client bind.ContractBackend) string {
  input := "1.0"
  address, tx, _, err := store.DeployStore(opts, client, input)
  if err != nil {
    log.Fatal(err)
  }


  fmt.Println(address.Hex())
  fmt.Println(tx.Hash().Hex())
  // wait until tx confirmed
  time.Sleep(time.Duration(10) * time.Second)
  return address.Hex()
}

部署成功之后, 我们可以获得交易的hash以及合约部署的地址. 通过这引地址, 我们就可以用来调用合约的方法了.

调用合约

合约部署成功之后, 我们可以调用它的方法来完成工作了, 以下的代码示例说明了如果调用Version, SetItems和Items方法:


func toCallContractMethod(hexContractAddr string, opts *bind.TransactOpts, client bind.ContractBackend) {
  addr := common.HexToAddress(hexContractAddr)
  instance, err := store.NewStore(addr, client)
  if err != nil {
    log.Fatal("new instance failed: ", err)
  }
  // to query version
  ver, err := instance.Version(nil)
  if err != nil {
    log.Fatal(err)
  }


  fmt.Println("version of contract is ", ver)


  // to set new items
  key := [32]byte{}
  value := [32]byte{}
  copy(key[:], []byte("hello"))
  copy(value[:], []byte("kitty"))


  tx, err := instance.SetItem(opts, key, value)
  if err != nil {
    log.Fatal(err)
  }


  fmt.Printf("tx sent: %s\n", tx.Hash().Hex())


  time.Sleep(time.Duration(10) * time.Second)


  result, err := instance.Items(nil, key)
  if err != nil {
    log.Fatal(err)
  }


  fmt.Println(string(result[:])) // kitty
}

总结

在本文中, 我们演示了怎样部署合约, 以及调用合约中的view方法和非view方法.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

列表为空，暂无数据