ABI Encoding

Encode function data, event topics, errors, and return values for contract calls in viem-go

Encode function calldata (with selector), event topics, custom errors, and function return values using a parsed ABI. For standalone parameter encoding without a contract ABI, see Encode Parameters and Encode Packed.

Import

import (
  "math/big"
  "github.com/ethereum/go-ethereum/common"
  "github.com/ChefBingbong/viem-go/abi"
)

EncodeFunctionData

Encode a function call including the 4-byte selector. Use a parsed ABI and the function name plus arguments.

import (
  "math/big"
  "github.com/ethereum/go-ethereum/common"
  "github.com/ChefBingbong/viem-go/abi"
)

// parsed is *abi.ABI from abi.Parse(...)
data, err := parsed.EncodeFunctionData("transfer",
  common.HexToAddress("0xRecipient..."),
  big.NewInt(1000000),
)
if err != nil {
  log.Fatal(err)
}
// data is []byte (selector + ABI-encoded args); use as tx data

Signature: (a *ABI) EncodeFunctionData(functionName string, args ...any) ([]byte, error)
Returns selector (4 bytes) + ABI-encoded arguments. Use for transaction data.

EncodeFunctionArgs

Encode only the arguments (no selector). Useful for constructor args or when you prepend a custom selector.

argsOnly, err := parsed.EncodeFunctionArgs("transfer", to, amount)

EncodeFunctionDataWithSelector

Encode arguments and prepend a custom 4-byte selector:

var customSelector [4]byte
copy(customSelector[:], ...)
data, err := parsed.EncodeFunctionDataWithSelector(customSelector, "transfer", to, amount)

EncodeConstructor

Encode constructor arguments (no selector):

ctorData, err := parsed.EncodeConstructor(arg1, arg2)

EncodeEventTopics

Encode indexed event parameters as topic hashes. First topic is the event signature (unless anonymous); then one topic per indexed argument.

import (
  "github.com/ethereum/go-ethereum/common"
  "github.com/ChefBingbong/viem-go/abi"
)

// Event Transfer(address indexed from, address indexed to, uint256 value)
topics, err := parsed.EncodeEventTopics("Transfer",
  common.HexToAddress("0xFrom..."),
  common.HexToAddress("0xTo..."),
)
if err != nil {
  log.Fatal(err)
}
// topics[0] = event sig, topics[1]=from, topics[2]=to
// Use topics for eth_getLogs filter

Signature: (a *ABI) EncodeEventTopics(eventName string, indexedArgs ...any) ([][]byte, error)
Pass nil for an indexed argument to mean “match any” (wildcard).

EncodeErrorResult

Encode a custom error (selector + arguments). Used when building revert data.

import "github.com/ChefBingbong/viem-go/abi"

// Error InsufficientBalance(uint256 balance, uint256 required)
encoded, err := parsed.EncodeErrorResult("InsufficientBalance", balance, required)
if err != nil {
  log.Fatal(err)
}
// encoded = selector + ABI-encoded args

Signature: (a *ABI) EncodeErrorResult(errorName string, args ...any) ([]byte, error)
Errors with no inputs return only the 4-byte selector.

EncodeFunctionResult

Encode return values for a function (e.g. for testing or off-chain simulation). Inverse of DecodeFunctionResult.

encoded, err := parsed.EncodeFunctionResult("balanceOf", big.NewInt(1000))

Signature: (a *ABI) EncodeFunctionResult(functionName string, values ...any) ([]byte, error)

PrepareEncodeFunctionData

Resolve an overloaded function by name and arguments, and get the selector and resolved name. Useful before encoding the same function many times.

prepared, err := parsed.PrepareEncodeFunctionData("transfer", to, amount)
if err != nil {
    log.Fatal(err)
}
// prepared.FunctionName, prepared.FunctionSelector
data, err := parsed.EncodeWithPrepared(prepared, to, amount)

*PrepareEncodeFunctionData(functionName string, args ...any) (PreparedFunctionData, error)
*PrepareEncodeFunctionDataBySelector(selector [4]byte) (PreparedFunctionData, error)
*EncodeWithPrepared(prepared PreparedFunctionData, args ...any) ([]byte, error)

Go notes

All encode functions return []byte; prefix with 0x when you need a hex string.
EncodeFunctionData and Pack are equivalent; EncodeFunctionData is the preferred name.
Addresses: use common.Address or a hex string; the package converts as needed for encoding.