Ethereum Token Transfer, Block Listening, and Raw Transaction in Golang – Chapter 2 (Part 2)

·

Developing on the Ethereum blockchain using Golang opens up powerful opportunities for building decentralized applications, automating transactions, and interacting directly with smart contracts. In this continuation of our Ethereum development series, we'll explore three essential operations: token transfers, listening to new blocks, and sending raw transactions. These techniques are foundational for any developer aiming to build robust, real-time blockchain tools.

Whether you're working on DeFi integrations, wallet services, or blockchain monitoring systems, mastering these skills is crucial. We'll walk through each process with clear code examples while maintaining compatibility with modern Ethereum node providers like Infura and Alchemy.

Ethereum Token Transfer Using Golang

Transferring ERC-20 tokens programmatically is a common requirement in blockchain development. Unlike native ETH transfers, token transfers involve interacting with a smart contract that implements the ERC-20 standard.

Here’s how to send tokens using Golang:

client, _ := ethclient.Dial("https://rinkeby.infura.io")

// Since we're transferring tokens, the ETH value is zero
EthValue := big.NewInt(0)

// Recipient address
toAddress := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")

// Token contract address (example)
tokenAddress := common.HexToAddress("0x28b149020d2152179873ec60bed6bf7cd705775d")

// Function signature for `transfer(address,uint256)`
transferFnSignature := []byte("transfer(address,uint256)")

// Generate function selector via Keccak-256 hash (using SHA3)
hash := sha3.New256()
hash.Write(transferFnSignature)
methodID := hash.Sum(nil)[:4]

// Pad recipient address to 32 bytes
paddedAddress := common.LeftPadBytes(toAddress.Bytes(), 32)

// Amount of tokens to send (e.g., 1000 tokens with 18 decimals)
amount := new(big.Int)
amount.SetString("1000000000000000000000", 10) // 1000 * 10^18

// Construct data payload
var data []byte
data = append(data, methodID...)
data = append(data, paddedAddress...)
data = append(data, common.LeftPadBytes(amount.Bytes(), 32)...)

// Estimate gas required for the transaction
gasLimit, err := client.EstimateGas(context.Background(), ethereum.CallMsg{
    To:   &tokenAddress,
    Data: data,
})
if err != nil {
    logrus.Error("Failed to estimate gas: ", err)
}

// Create the transaction
tx := types.NewTx(&types.LegacyTx{
    Nonce:    246,
    GasPrice: EthValue,
    Gas:      gasLimit,
    To:       &tokenAddress,
    Value:    EthValue,
    Data:     data,
})

logrus.Info("Transaction created: ", tx.Hash().Hex())
Note: The main difference from ETH transfers is that you interact with the token contract rather than sending ETH directly. The transfer function is encoded into the transaction data.

👉 Learn how to securely manage private keys and sign transactions off-chain

Listening to New Blocks in Real Time

Real-time monitoring of the Ethereum blockchain enables applications like payment processors, analytics dashboards, and automated trading bots. WebSockets allow us to subscribe to new block headers as they are mined.

Here’s how to set up a block listener:

client, _ := ethclient.Dial("wss://eth-mainnet.ws.alchemyapi.io/ws/")

// Channel to receive block headers
headers := make(chan *types.Header)

// Subscribe to new block headers
sub, err := client.SubscribeNewHead(context.Background(), headers)
if err != nil {
    logrus.Fatal("Failed to subscribe: ", err)
}

// Listen continuously
for {
    select {
    case err := <-sub.Err():
        logrus.Error("Subscription error: ", err)
    case header := <-headers:
        logrus.Info("New block hash: ", header.Hash().Hex())

        // Optionally fetch full block details
        block, err := client.BlockByHash(context.Background(), header.Hash())
        if err != nil {
            logrus.Warn("Could not fetch block: ", err)
            continue
        }
        logrus.Info("Block number: ", block.Number().Uint64())
    }
}

Key Considerations:

Real-time data streaming is critical for high-frequency blockchain interactions.

👉 Discover how real-time blockchain data powers advanced trading strategies

Sending Raw Transactions

A "raw transaction" refers to a signed transaction that is broadcast directly to the network without going through a wallet interface. This method gives developers full control over transaction parameters.

Here’s how to send a pre-signed raw transaction:

client, _ := ethclient.Dial("https://rinkeby.infura.io")

// Example raw transaction in hex format
rawTx := "f86d8202b28477359400825208944592d8f8d7b001e72cb26a73e4fa1806a51ac79d880de0b6b3a7640000802ca05924bde7ef10aa88db9c66dd4f5fb16b46dff2319b9968be983118b57bb50562a001b24b31010004f13d9a26b320845257a6cfc2bf819a3d55e3fc86263c5f0772"
rawBytes, _ := hex.DecodeString(rawTx)

// Parse the RLP-encoded transaction
tx := new(types.Transaction)
rlp.DecodeBytes(rawBytes, &tx)

// Broadcast the transaction
err := client.SendTransaction(context.Background(), tx)
if err != nil {
    logrus.Error("Failed to send transaction: ", err)
    return
}

logrus.Info("Transaction sent: ", tx.Hash().Hex())

This technique is useful for:

Ensure your raw transaction includes valid signatures and correct network parameters.

Frequently Asked Questions

What is the difference between ETH and ERC-20 token transfers?

ETH transfers go directly to an address, while ERC-20 token transfers call a smart contract’s transfer function. The logic resides in the token contract, not the core protocol.

How do I get a WebSocket endpoint for Ethereum?

You can obtain one from services like Alchemy, Infura, or Ankr. Most require free account registration and provide API keys for authentication.

Why do I need to manually encode function calls when transferring tokens?

Because Ethereum doesn’t natively understand token logic. You must encode the function name and parameters into the transaction data field so the smart contract can interpret it.

Can I listen to specific events instead of all blocks?

Yes. Use FilterQuery with SubscribeFilterLogs to monitor specific contract events like Transfer, Approval, or custom events.

Is it safe to use raw transactions in production?

Only if proper security measures are in place. Never expose private keys. Prefer signing offline and broadcasting only the raw signed transaction.

How can I reduce gas costs when transferring tokens?

Optimize contract interaction timing, use EIP-1559-compatible fee strategies, or consider Layer 2 solutions like Arbitrum or Optimism.

Core Keywords

These keywords naturally support search queries related to Ethereum development in Go and help users find practical implementation guides.

👉 Explore developer tools that simplify Ethereum integration and testing

By mastering token transfers, real-time block listening, and raw transaction handling in Golang, you gain the ability to create highly responsive and secure blockchain applications. These skills form the backbone of modern Web3 infrastructure — from wallets to exchanges.

As Ethereum continues evolving with upgrades like Dencun and Proto-Danksharding, having a solid foundation in low-level interactions ensures you stay ahead in the fast-moving crypto landscape.