Building a Transaction

These are the steps to build, sign and broadcast a transaction using v2 semantics.

These are the steps to build, sign and broadcast a transaction using v2 semantics.

1. Correctly set up imports

import (
    
	"context"
    "fmt"
    "log"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"

	apisigning "cosmossdk.io/api/cosmos/tx/signing/v1beta1"
    "cosmossdk.io/client/v2/broadcast/comet"
    "cosmossdk.io/client/v2/tx"
    "cosmossdk.io/core/transaction"
    "cosmossdk.io/math"
	banktypes "cosmossdk.io/x/bank/types"
	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
    "github.com/cosmos/cosmos-sdk/crypto/keyring"
	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
    "github.com/cosmos/cosmos-sdk/codec"
	addrcodec "github.com/cosmos/cosmos-sdk/codec/address"
	sdk "github.com/cosmos/cosmos-sdk/types"
)

2. Create a gRPC connection

clientConn, err := grpc.NewClient("127.0.0.1:9090", grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
    log.Fatal(err)
}

3. Setup codec and interface registry

// Setup interface registry and register necessary interfaces
    interfaceRegistry := codectypes.NewInterfaceRegistry()

banktypes.RegisterInterfaces(interfaceRegistry)

authtypes.RegisterInterfaces(interfaceRegistry)

cryptocodec.RegisterInterfaces(interfaceRegistry)

	// Create a ProtoCodec for encoding/decoding
    protoCodec := codec.NewProtoCodec(interfaceRegistry)

4. Initialize keyring

ckr, err := keyring.New("autoclikeyring", "test", home, nil, protoCodec)
    if err != nil {
    log.Fatal("error creating keyring", err)
}

kr, err := keyring.NewAutoCLIKeyring(ckr, addrcodec.NewBech32Codec("cosmos"))
    if err != nil {
    log.Fatal("error creating auto cli keyring", err)
}

5. Setup transaction parameters

// Setup transaction parameters
    txParams := tx.TxParameters{
    ChainID:  "simapp-v2-chain",
    SignMode: apisigning.SignMode_SIGN_MODE_DIRECT,
    AccountConfig: tx.AccountConfig{
    FromAddress: "cosmos1t0fmn0lyp2v99ga55mm37mpnqrlnc4xcs2hhhy",
    FromName:    "alice",
},
}

	// Configure gas settings
	gasConfig, err := tx.NewGasConfig(100, 100, "0stake")
    if err != nil {
    log.Fatal("error creating gas config: ", err)
}

txParams.GasConfig = gasConfig

	// Create auth query client
    authClient := authtypes.NewQueryClient(clientConn)

	// Retrieve account information for the sender
	fromAccount, err := getAccount("cosmos1t0fmn0lyp2v99ga55mm37mpnqrlnc4xcs2hhhy", authClient, protoCodec)
    if err != nil {
    log.Fatal("error getting from account: ", err)
}

	// Update txParams with the correct account number and sequence
	txParams.AccountConfig.AccountNumber = fromAccount.GetAccountNumber()

txParams.AccountConfig.Sequence = fromAccount.GetSequence()

	// Retrieve account information for the recipient
	toAccount, err := getAccount("cosmos1e2wanzh89mlwct7cs7eumxf7mrh5m3ykpsh66m", authClient, protoCodec)
    if err != nil {
    log.Fatal("error getting to account: ", err)
}

	// Configure transaction settings
	txConf, _ := tx.NewTxConfig(tx.ConfigOptions{
    AddressCodec:          addrcodec.NewBech32Codec("cosmos"),
    Cdc:                   protoCodec,
    ValidatorAddressCodec: addrcodec.NewBech32Codec("cosmosval"),
    EnabledSignModes:      []apisigning.SignMode{
    apisigning.SignMode_SIGN_MODE_DIRECT
},
})

6. Build the transaction

// Create a transaction factory
	f, err := tx.NewFactory(kr, codec.NewProtoCodec(codectypes.NewInterfaceRegistry()), nil, txConf, addrcodec.NewBech32Codec("cosmos"), clientConn, txParams)
    if err != nil {
    log.Fatal("error creating factory", err)
}

	// Define the transaction message
    msgs := []transaction.Msg{
		&banktypes.MsgSend{
    FromAddress: fromAccount.GetAddress().String(),
    ToAddress:   toAccount.GetAddress().String(),
    Amount: sdk.Coins{
    sdk.NewCoin("stake", math.NewInt(1000000)),
},
},
}

	// Build and sign the transaction
	tx, err := f.BuildsSignedTx(context.Background(), msgs...)
    if err != nil {
    log.Fatal("error building signed tx", err)
}

7. Broadcast the transaction

// Create a broadcaster for the transaction
	c, err := comet.NewCometBFTBroadcaster("http://127.0.0.1:26657", comet.BroadcastSync, protoCodec)
    if err != nil {
    log.Fatal("error creating comet broadcaster", err)
}

	// Broadcast the transaction
	res, err := c.Broadcast(context.Background(), tx.Bytes())
    if err != nil {
    log.Fatal("error broadcasting tx", err)
}

8. Helpers

// getAccount retrieves account information using the provided address
func getAccount(address string, authClient authtypes.QueryClient, codec codec.Codec) (sdk.AccountI, error) {
	// Query account info
	accountQuery, err := authClient.Account(context.Background(), &authtypes.QueryAccountRequest{
    Address: string(address),
})
    if err != nil {
    return nil, fmt.Errorf("error getting account: %w", err)
}

	// Unpack the account information
	var account sdk.AccountI
	err = codec.InterfaceRegistry().UnpackAny(accountQuery.Account, &account)
    if err != nil {
    return nil, fmt.Errorf("error unpacking account: %w", err)
}

return account, nil
}