Blockchain - Cosmos SDK and Golang

RogerCheng · ‎2023 Aug 29

Overview

Cosmos is a decentralized network of independent blockchains which are powered by the Byzantine Fault Tolerance (BFT) consensus algorithm. The Cosmos SDK enables the creation of these blockchain applications. In this blog post, I would like to share with you some of these Cosmos SDK functions.

The documentation of Cosmos SDK can be found at https://pkg.go.dev/github.com/cosmos/cosmos-sdk.

The following code samples were written in Golang and Cosmos SDK v0.45.4.

Code Samples

Initialize New Keyring

The keyring holds the private/public keypairs used for interactions with a node.

import (

    "strings"

    "github.com/cosmos/cosmos-sdk/crypto/keyring"

    "github.com/cosmos/cosmos-sdk/types"

)



func NewKeyring() (keyring.Keyring, error) {

    var kr keyring.Keyring

    keyringPassword := "password"

    runtimeHomeDir := "~/.cosmosHome"

    reader := strings.NewReader("")

    reader.Reset(keyringPassword + "\n")

    kr, err := keyring.New(

        types.KeyringServiceName(),

        keyring.BackendTest

        runtimeHomeDir,

        reader,

    )

    if err != nil {

        return kr, err

    }

    return kr, nil

}

Create Account

An account designates the private/public keypairs. The public key can be derived to generate various Addresses which are used to identify the users in the blockchain.

import (

    "github.com/cosmos/cosmos-sdk/crypto/keyring"

)



func CreateAccount() (string, error) {

    keyringPassword := "password"

    kr, err = NewKeyring()

    if err != nil {

        return "", err

    }

    algo, _ := kr.SupportedAlgorithms()

    signingAlgo, err := keyring.NewSigningAlgoFromString("secp256k1", algo)

    if err != nil {

        return "", err

    }

    uid := genUID()

    mnemonicInfo, _, err := kr.NewMnemonic(uid, keyring.English, "", keyringPassword, signingAlgo)

    if err != nil {

        return "", err

    }

    return mnemonicInfo.GetAddress().String(), nil

}



func genUID() string {

//  Generate a string composed of 40 randomized alphanumeric characters.

}

Create GRPC Connection

Queries can be performed through a GRPC connection.

import (

    "crypto/tls"

    "google.golang.org/grpc"

    "google.golang.org/grpc/credentials"

)



/* Create a GRPC client connnection with TLS. */

func CreateGrpcConnTls() (*grpc.ClientConn, error) {

    var grpcConn *grpc.ClientConn

    var err error

//  Specify the fully qualified hostname and port of the validator node.

    grpcHost := "…Hostname…"

    tlsCfg := &tls.Config{

        InsecureSkipVerify: true,

    }

    grpcConn, err = grpc.Dial(

        grpcHost,

        grpc.WithTransportCredentials(credentials.NewTLS(tlsCfg)),

    )

    return grpcConn, err

}



/* Create a GRPC client connnection without TLS. */

func CreateGrpcConn() (*grpc.ClientConn, error) {

    var grpcConn *grpc.ClientConn

    var err error

//  Specify the fully qualified hostname and port of the validator node.

    grpcHost := "…Hostname…"

    grpcConn, err = grpc.Dial(

        grpcHost,

        grpc.WithInsecure(),

    )

    return grpcConn, err

}

Get Node Information

Getting the information of a node.

import (

    "github.com/cosmos/cosmos-sdk/client/grpc/tmservice"

    "github.com/tendermint/tendermint/proto/tendermint/p2p"

)



func GetNodeInfo() (*p2p.DefaultNodeInfo, error) {

    var nodeInfo *p2p.DefaultNodeInfo

    grpcConn, err := CreateGrpcConnTls()

    if err != nil {

        return nodeInfo, err

    }

    defer grpcConn.Close()

    serviceClient := tmservice.NewServiceClient(grpcConn)

    nodeInfoRes, err := serviceClient.GetNodeInfo(

        context.Background(),

        &tmservice.GetNodeInfoRequest{},

    )

    if err != nil {

        return nodeInfo, err

    }

    nodeInfo = nodeInfoRes.GetDefaultNodeInfo()

    return nodeInfo, nil

}

Get Latest Block

Getting information of the latest block.

import (

    "context"

    "encoding/base64"

    "github.com/cosmos/cosmos-sdk/client/grpc/tmservice"

)



func GetLatestBlock() (*tmservice.GetLatestBlockResponse, error) {

    var latestBlockRes *tmservice.GetLatestBlockResponse

    grpcConn, err := CreateGrpcConnTls()

    if err != nil {

        return latestBlockRes, err

    }

    defer grpcConn.Close()

    serviceClient := tmservice.NewServiceClient(grpcConn)

    latestBlockRes, err = serviceClient.GetLatestBlock(

        context.Background(),

        &tmservice.GetLatestBlockRequest{},

    )

    if err != nil {

        return latestBlockRes, err

    }

    return latestBlockRes, nil

}



/* Get the attributes */

latestBlockRes, err := GetLatestBlock()

block := latestBlockRes.GetBlock() // Type: Block

header := block.GetHeader() // Type: Header

height := header.GetHeight()

dataHash := header.GetDataHash()

blockId := latestBlockRes.GetBlockId() // Type: BlockID

blockIdHash := base64.StdEncoding.EncodeToString(blockId.GetHash())

Get Block by Height

Getting the block information by the height.

import (

    "context"

    "encoding/base64"

    "github.com/cosmos/cosmos-sdk/client/grpc/tmservice"

)



func GetBlockByHeight(height int64) (*tmservice.GetBlockByHeightResponse, error) {

    var blockRes *tmservice.GetBlockByHeightResponse

    grpcConn, err := CreateGrpcConnTls()

    if err != nil {

        return blockRes, err

    }

    defer grpcConn.Close()

    serviceClient := tmservice.NewServiceClient(grpcConn)

    blockRes, err = serviceClient.GetBlockByHeight(

        context.Background(),

        &tmservice.GetBlockByHeightRequest{Height: height},

    )

    if err != nil {

        return blockRes, err

    }

    return blockRes, nil

}



/* Get the attributes */

height int64 := 12345

blockRes, err := GetBlockByHeight(height)

block := blockRes.GetBlock() // Type: Block

header := block.GetHeader() // Type: Header

blockId := blockRes.GetBlockId() // Type: BlockID

blockIdHash := base64.StdEncoding.EncodeToString(blockId.GetHash())

Get Balance

Getting the balance of an account address.

import (

    sdktypes  "github.com/cosmos/cosmos-sdk/types"

    banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"

)



func GetBalance(accountAddress, denom string) (*sdktypes.Coin, error) {

    var balance *sdktypes.Coin

    addr, err := sdktypes.AccAddressFromBech32(accountAddress)

    if err != nil {

        return balance, err

    }

    grpcConn, err := CreateGrpcConnTls()

    if err != nil {

        return balance, err

    }

    defer grpcConn.Close()

    bankClient := banktypes.NewQueryClient(grpcConn)

    balanceRes, err := bankClient.Balance(

        context.Background(),

        &banktypes.QueryBalanceRequest{Address: addr.String(), Denom: denom},

    )

    if err != nil {

        return balance, err

    }

    balance = balanceRes.GetBalance()

    return balance, nil

}



/* Get the attributes */

accountAddress := "……"

denom := "……"

balance, err := GetBalance(accountAddress, denom) // Type: Coin

amount := balance.Amount

Create Transaction

Creating a transaction is a 2-step process. First, a signed transaction is created. Second, the signed transaction is broadcasted.

func createTxn() (string, error) {

    txBytes, err := CreateSignedTxn()

    if err != nil {

        return "", err

    }

    txHash, _, err := BroadcastSignedTxn(txBytes)

    if err != nil {

        return "", err

    }

    return txHash, nil

}

Create Signed Transaction

The transaction example is to send tokens from account A to account B. For simplicity, some error checking is skipped in the following code snippet.

Import (

                "github.com/cosmos/cosmos-sdk/client/tx"

                "github.com/cosmos/cosmos-sdk/crypto"

    cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"

    sdktypes    "github.com/cosmos/cosmos-sdk/types"

                "github.com/cosmos/cosmos-sdk/types/tx/signing"

    authsigning "github.com/cosmos/cosmos-sdk/x/auth/signing"

    banktypes   "github.com/cosmos/cosmos-sdk/x/bank/types"

)



func CreateSignedTxn() ([]byte, error) {

    encodingConfig := cosmoscmd.MakeEncodingConfig(catxapp.ModuleBasics)

    txConfig := encodingConfig.TxConfig

    txBuilder := txConfig.NewTxBuilder()

    kr, err := NewKeyring()

//  Specify the from account address.

    fromAddr, err := sdktypes.AccAddressFromBech32("…From Address…")

//  Specify the to account address.

    toAddr, err := sdktypes.AccAddressFromBech32("…To Address…")

//  Specify the amount of tokens to be sent.

    amount := ……

//  Specify the denomination.

    coin := sdktypes.NewInt64Coin("…Denomination…", amount)

    coins := sdktypes.NewCoins(coin)

    msg := banktypes.NewMsgSend(fromAddr, toAddr, coins)

    if err := txBuilder.SetMsgs(msg); err != nil { return nil, err }

//  Specify the fee.

    fee := ……

//  Specify the denomination.

    feeAmt := sdktypes.Coin{Denom: "…Denomination…", Amount: sdktypes.NewInt(fee)}

    feeAmount := sdktypes.NewCoins(feeAmt)

    txBuilder.SetFeeAmount(feeAmount)

//  Specify the gas limit.

    gasLimit := ……

    txBuilder.SetGasLimit(gasLimit)

    keyInfo, err := kr.KeyByAddress(fromAddr)

//  Specify the passphrase.

    exportedPrivateKey, err := kr.ExportPrivKeyArmor(keyInfo.GetName(), "…Passphrase…")

//  Specify the passphrase.

    privateKey, _, err := crypto.UnarmorDecryptPrivKey(exportedPrivateKey, "…Passphrase…"])

//  Specify the from account address.

    account, err := GetAccount("…From Address…")

    accNumber := account.AccountNumber

    accSequence := account.Sequence

    privKeyList := []cryptotypes.PrivKey{privateKey}

    accNumberList := []uint64{accNumber}

    accSeqList := []uint64{accSequence}

/*  First round: Gather all signer infos. */

    var signatureList []signing.SignatureV2

    for idx, privKey := range privKeyList {

        sig := signing.SignatureV2{

            PubKey: privKey.PubKey(),

            Data: &signing.SingleSignatureData{

                SignMode:  encodingConfig.TxConfig.SignModeHandler().DefaultMode(),

                Signature: nil,

            },

            Sequence: accSeqList[idx],

        }

        signatureList = append(signatureList, sig)

    }

    if err := txBuilder.SetSignatures(signatureList...); err != nil { return nil, err }

/*  Second round: Signed by each signer. */

    var signingList []signing.SignatureV2

    for idx, privKey := range privKeyList {

        signerData := authsigning.SignerData {

        //  Specify the chain ID.

            ChainID:       "……",

            AccountNumber: accNumberList[idx],

            Sequence:      accSeqList[idx],

        }

        signMode := encodingConfig.TxConfig.SignModeHandler().DefaultMode()

        sig, err := tx.SignWithPrivKey(signMode, signerData, txBuilder, privKey,

        encodingConfig.TxConfig, accSeqList[idx])

        signingList = append(signingList, sig)

    }

    if err := txBuilder.SetSignatures(signingList...); err != nil { return nil, err }

    txBytes, err := encodingConfig.TxConfig.TxEncoder()(txBuilder.GetTx())

    return txBytes, nil

}

Broadcast Signed Transaction

Broadcasting a signed transaction.

import (

    "context"

    "strconv"

    "github.com/cosmos/cosmos-sdk/types/tx"

)



func BroadcastSignedTxn(txBytes []byte) (string, int64, error) {

    grpcConn, err := CreateGrpcConnTls()

    if err != nil {

        return "", int64(0), err

    }

    defer grpcConn.Close()

    serviceClient := tx.NewServiceClient(grpcConn)

    broadcastTxRes, err := serviceClient.BroadcastTx(

        context.Background(),

        &tx.BroadcastTxRequest{

            Mode:    tx.BroadcastMode_BROADCAST_MODE_BLOCK,

            TxBytes: txBytes,

        },

    )

    if err != nil {

        return "", int64(0), err

    }

    txResponse := broadcastTxRes.GetTxResponse()

    if txResponse.Code != 0 {

        return "", int64(0),

        errors.New("TxResponse.Code: " + strconv.FormatUint(uint64(txResponse.Code), 10))

    }

    return txResponse.TxHash, txResponse.Height, nil

}

Get Transaction by Hash

Getting transaction information by the transaction hash.

import (

             "context"

    sdktypes "github.com/cosmos/cosmos-sdk/types"

    txtypes  "github.com/cosmos/cosmos-sdk/types/tx"

)



func GetTxnByHash(txHash string) (*sdktypes.TxResponse, error) {

    var txResponse *sdktypes.TxResponse

    grpcConn, err := CreateGrpcConnTls()

    if err != nil {

        return txResponse, err

    }

    defer grpcConn.Close()

    serviceClient := txtypes.NewServiceClient(grpcConn)

    txRes, err := serviceClient.GetTx(

        context.Background(),

        &txtypes.GetTxRequest{Hash: txHash},

    )

    if err != nil {

        return txResponse, err

    }

    txResponse = txRes.GetTxResponse()

    return txResponse, nil

}



/* Get the attributes */

txHash := "……"

txRes, err := GetTxnByHash(txHash)

height := txRes.Height

Get Account

Getting the information of an account.

import (

    "github.com/cosmos/cosmos-sdk/x/auth/types"

)



func GetAccount(accountAddress string) (types.BaseAccount, error) {

    var baseAccount types.BaseAccount

    addr, err := sdktypes.AccAddressFromBech32(accountAddress)

    if err != nil {

        return baseAccount, err

    }

    grpcConn, err := CreateGrpcConnTls()

    if err != nil {

        return baseAccount, err

    }

    defer grpcConn.Close()

    accountClient := types.NewQueryClient(grpcConn)

    accountRes, err := accountClient.Account(

        context.Background(),

        &types.QueryAccountRequest{Address: addr.String()},

    )

    if err != nil {

        return baseAccount, err

    }

    accountData := accountRes.GetAccount().Value

    if err := baseAccount.XX_Unmarshal(accountData); err != nil {

        return baseAccount, err

    }

    return baseAccount, nil

}

Get Validator Set

Getting the information of the validator set.

import (

    "github.com/cosmos/cosmos-sdk/x/staking/types"

)



func GetValidatorSet() ([]types.Validator, error) {

    var validatorList []types.Validator

    grpcConn, err := CreateGrpcConnTls()

    if err != nil {

        return validatorList, err

    }

    defer grpcConn.Close()

    queryClient := types.NewQueryClient(grpcConn)

    validatorsRes, err := queryClient.Validators(

        context.Background(),

        &types.QueryValidatorsRequest{},

    if err != nil {

        return validatorList, err

    }

    validatorList = validatorsRes.GetValidators()

    return validatorList, nil

}

Type Structs

Type: Block

Block defines the atomic unit of a Tendermint blockchain.

The structure of type Block is defined as:

type Block struct {

    Header `json:"header"`

    ……

}

For details, see:

https://pkg.go.dev/github.com/tendermint/tendermint@v0.34.19/types#Block

https://github.com/tendermint/tendermint/blob/v0.34.19/proto/tendermint/types/block.pb.go

Type: BlockID

The structure of type BlockID is defined as:

type BlockID struct {

    Hash tmbytes.HexBytes `json:"hash"`

    ……

}

For details, see:

https://pkg.go.dev/github.com/tendermint/tendermint@v0.34.19/types#BlockID

https://github.com/tendermint/tendermint/blob/v0.34.19/proto/tendermint/types/types.pb.go

Type: Coin

Coin defines a token with a denomination and an amount.

The structure of type Coin is defined as:

type Coin struct {

    Denom  string `json:"denom,omitempty"`

    Amount Int    `json:"amount"`

}

For details, see:

https://pkg.go.dev/github.com/cosmos/cosmos-sdk@v0.45.4/types#Coin

https://github.com/cosmos/cosmos-sdk/blob/v0.45.4/types/coin.pb.go

Type: Header

Header defines the structure of a Tendermint block header.

The structure of type Header is defined as:

type Header struct {

    Height   int64            `json:"height"`

    DataHash tmbytes.HexBytes `json:"data_hash"`

    ……

}

For details, see:

https://pkg.go.dev/github.com/tendermint/tendermint@v0.34.19/types#Header

https://github.com/tendermint/tendermint/blob/v0.34.19/proto/tendermint/types/types.pb.go

Type: QueryBalanceRequest

The structure of type QueryBalanceRequest is defined as:

type QueryBalanceRequest struct {

    Address string `json:"address,omitempty"`

    Denom   string `json:"denom,omitempty"`

}

For details, see:

https://pkg.go.dev/github.com/cosmos/cosmos-sdk@v0.45.4/x/bank/types#QueryBalanceRequest

https://github.com/cosmos/cosmos-sdk/blob/v0.45.4/x/bank/types/query.pb.go

Type: QueryBalanceResponse

The structure of type QueryBalanceResponse is defined as:

type QueryBalanceResponse struct {

    Balance *types.Coin `json:"balance,omitempty"`

}

For details, see:

https://pkg.go.dev/github.com/cosmos/cosmos-sdk@v0.45.4/x/bank/types#QueryBalanceResponse

https://github.com/cosmos/cosmos-sdk/blob/v0.45.4/x/bank/types/query.pb.go

Summary

I hope the above samples will help kick start your coding in Golang and Cosmos SDK.