IRITA Go SDK
IRITA GO SDK makes a simple package of API provided by IRITA Chain, which provides great convenience for users to quickly develop applications based on IRITA.
install
Requirement
- Go version above 1.14.0
Use Go Mod
require (
github.com/bianjieai/irita-sdk-go latest
)
replace github.com/tendermint/tendermint => github.com/bianjieai/tendermint version
NOTE: Please make sure you use bianjieai/tendermint instead of tendermint/tendermint.
Usage
Init Client
The initialization SDK code is as follows:
options := []types.Option{
types.KeyDAOOption(store.NewMemory(nil)),
types.TimeoutOption(10),
}
cfg, err := types.NewClientConfig(nodeURI, gRPCAddr, chainID, options...)
if err != nil {
panic(err)
}
client := sdk.NewIRITAClient(cfg)The ClientConfig component mainly contains the parameters used in the SDK, the specific meaning is shown in the table below
| Iterm | Type | Description |
|---|---|---|
| NodeURI | string | The RPC address of the irita node connected to the SDK, for example( tcp://localhost:26657 ) |
| GRPCAddr | string | The GRPC address of the irita node connected to the SDK, for example( localhost:9090 ) |
| ChainID | string | ChainID of irita, for example: irita |
| Gas | uint64 | The maximum gas to be paid for the transaction, for example: 20000 |
| Fee | DecCoins | Transaction fees to be paid for transactions |
| KeyDAO | KeyDAO | Private key management interface, If the user does not provide it, the default LevelDB will be used |
| Mode | enum | Transaction broadcast mode, value: Sync,Async, Commit |
| Algo | enum | Private key generation algorithm(sm2,secp256k1) |
| Timeout | time.Duration | Transaction timeout, for example: 5s |
| Level | string | Log output level, for example: info |
| MaxTxBytes | uint64 | The maximum number of transaction bytes supported by the connected node, default: 1073741824(5M) |
If you want to use SDK to send a transfer transaction, the example is as follows:
coins, err := types.ParseDecCoins("100point")
to := "caa1rgnu8grzt6mwnjg7jss7w0sfyjn67g4em9njf5"
baseTx := types.BaseTx{
From: "username",
Gas: 20000,
Memo: "test",
Mode: types.Commit,
Password: "password",
}
result, err := client.Bank.Send(to, coins, baseTx)Note: If you use the relevant API for sending transactions, you should implement the KeyDAO interface.
KeyDAO
The interface definition is as follows:
// KeyInfo saves the basic information of the key
type KeyInfo struct {
Name string `json:"name"`
PubKey []byte `json:"pubkey"`
PrivKeyArmor string `json:"priv_key_armor"`
Algo string `json:"algo"`
}
type KeyDAO interface {
// Write will use user password to encrypt data and save to file, the file name is user name
Write(name, password string, store KeyInfo) error
// Read will read encrypted data from file and decrypt with user password
Read(name, password string) (KeyInfo, error)
// Delete will delete user data and use user password to verify permissions
Delete(name, password string) error
// Has returns whether the specified user name exists
Has(name string) bool
}There are three different ways to implement the keyDAO interface in the SDK:
- Based on levelDB(
LevelDBDAO) - Based on local file system(
FileDAO) - Based on memory(
MemoryDAO)
Located under package types/store
Import Account By Mnemonic
//private key generation algorithm(`sm2`,`secp256k1`)
algo := "sm2"
// init cschain sdk client
keyDao := store.NewMemory(nil)
km, err := crypto.NewMnemonicKeyManager(mnemonic, algo)
_, priv := km.Generate()
ki := store.KeyInfo{
Name: name,
PubKey: codec.MarshalPubkey(km.ExportPubKey()),
PrivKeyArmor: string(codec.MarshalPrivKey(priv)),
Algo: algo,
}
err := keyDao.Write(name, password, ki)
options := []types.Option{
types.KeyDAOOption(keyDao),
types.TimeoutOption(10),
}
cfg, err := types.NewClientConfig(nodeURI, gRPCAddr, chainID, options...)
client := sdk.NewIRITAClient(cfg)Bench32PubKey Convert to Sm2Pubkey
var sm2pubKey sm2.PubKey
// support bench32 pubkey type (accpub,valpub,conspub)
pubKey, err := types.GetPubKeyFromBech32(types.Bech32PubKeyTypeAccPub, AccPubKey)
pubkeyBytes, err := json.Marshal(pubKey)
err := json.Unmarshal(pubkeyBytes, &sm2pubKey)
sm2PubKey := sm2.Decompress(sm2pubKey.Key)