Go

go-ethereum — geth — is the reference Ethereum node, and the same module ships an ethclient package you import as a library. That gives Go the most complete and current EVM tooling around: the team maintaining the dominant execution client also maintains the API you call, so a new fork like Dencun lands in the bindings without a third-party catching up. Pull it in with go get github.com/ethereum/go-ethereum. It's stewarded by the Ethereum Foundation, which is why the types track the live protocol on chain 1.

go-ethereum is the official Go client, maintained by the Ethereum Foundation. For Go developers that means the most complete and up-to-date EVM implementation available — the library and the node move together, so what you build against matches what mainnet runs.

Go-Ethereum (geth)

ethclient.Dial(url) opens the connection to the Ethereum endpoint and returns a *ethclient.Client that speaks every JSON-RPC method as a typed Go call — BalanceAt returns a *big.Int of wei, SuggestGasPrice an eth_gasPrice reading. Wrapping that client in your own struct, as below, keeps the endpoint URL in one place and lets you swap in a mock client in tests instead of hitting mainnet from a unit test.

1package ethereum
2 
3import (
4    "context"
5    "math/big"
6    "github.com/ethereum/go-ethereum/ethclient"
7    "github.com/ethereum/go-ethereum/common"
8    "github.com/ethereum/go-ethereum/core/types"
9)
10 
11type EthereumClient struct {
12    client *ethclient.Client
13}
14 
15func NewEthereumClient(url string) (*EthereumClient, error) {
16    client, err := ethclient.Dial(url)
17    if err != nil {
18        return nil, err
19    }
20    return &EthereumClient{client: client}, nil
21}
22 
23func (ec *EthereumClient) GetBalance(address string) (*big.Float, error) {
24    account := common.HexToAddress(address)
25    balance, err := ec.client.BalanceAt(context.Background(), account, nil)
26    if err != nil {
27        return nil, err
28    }
29 
30    fbalance := new(big.Float)
31    fbalance.SetString(balance.String())
32    ethValue := new(big.Float).Quo(fbalance, big.NewFloat(1e18))
33 
34    return ethValue, nil
35}
36 
37func (ec *EthereumClient) SendTransaction(from, to common.Address, value *big.Int) (*types.Transaction, error) {
38    nonce, err := ec.client.PendingNonceAt(context.Background(), from)
39    if err != nil {
40        return nil, err
41    }
42 
43    gasPrice, err := ec.client.SuggestGasPrice(context.Background())
44    if err != nil {
45        return nil, err
46    }
47 
48    tx := types.NewTransaction(nonce, to, value, 21000, gasPrice, nil)
49    return tx, nil
50}

GitHub: https://github.com/ethereum/go-ethereum
Docs: https://geth.ethereum.org/
A full Ethereum node implementation you can also import as a library
Complete coverage of the Ethereum protocol, kept current with each upgrade
High-performance client tuned for production load
CLI tools (geth, abigen, clef) and mobile (Android/iOS) build targets
Typed contract bindings generated from Solidity ABIs via abigen

Smart Contract Integration

The idiomatic path for contracts is abigen: feed it a Solidity ABI and it emits a typed Go package where each contract method becomes a Go method, with the parameter and return types already decoded. Under that generated code sits bind.BoundContract, which you can also use directly — it pairs the parsed ABI with the client and exposes Call for gas-free reads against an Ethereum contract and Transact for signed state changes. Generating bindings is what turns an ERC-20's transfer into a compile-checked call rather than a hand-built calldata blob.

1package contracts
2 
3import (
4    "github.com/ethereum/go-ethereum/accounts/abi/bind"
5    "github.com/ethereum/go-ethereum/common"
6)
7 
8type SmartContractClient struct {
9    contract *bind.BoundContract
10    address  common.Address
11}
12 
13func NewContract(address common.Address, client *ethclient.Client) (*SmartContractClient, error) {
14    parsed, err := abi.JSON(strings.NewReader(ContractABI))
15    if err != nil {
16        return nil, err
17    }
18 
19    contract := bind.NewBoundContract(address, parsed, client, client, client)
20    return &SmartContractClient{
21        contract: contract,
22        address:  address,
23    }, nil
24}
25 
26func (sc *SmartContractClient) CallMethod(method string, args ...interface{}) error {
27    opts := &bind.CallOpts{
28        Pending: false,
29        Context: context.Background(),
30    }
31 
32    return sc.contract.Call(opts, method, args...)
33}

Event Monitoring

SubscribeNewHead opens a live feed of block headers, but it only works over WebSocket — eth_subscribe can't ride a plain HTTP connection, so dial wss://ethereum.therpc.io/YOUR_API_KEY for this, not the HTTPS URL you use for one-off reads. Since a new Ethereum block arrives roughly every 12 seconds, you want the push rather than a polling loop. Run the receive logic in a goroutine and select over two channels: one for incoming headers, one for sub.Err(), so a dropped connection surfaces as an error you can reconnect on instead of a silent stall.

1func (ec *EthereumClient) MonitorBlocks() (<-chan *types.Header, error) {
2    headers := make(chan *types.Header)
3    sub, err := ec.client.SubscribeNewHead(context.Background(), headers)
4    if err != nil {
5        return nil, err
6    }
7 
8    go func() {
9        for {
10            select {
11            case err := <-sub.Err():
12                log.Fatal(err)
13            case header := <-headers:
14                block, err := ec.client.BlockByHash(context.Background(), header.Hash())
15                if err != nil {
16                    log.Fatal(err)
17                }
18                fmt.Println("New block:", block.Number().Uint64())
19            }
20        }
21    }()
22 
23    return headers, nil
24}

Utils and Helpers

Wei values on Ethereum routinely exceed what a float64 or even a uint64 can hold — a single ETH is 10^18 wei, and balances stack well beyond that. Do every wei calculation in big.Int, and only drop to big.Float at the last step when you divide by 10^18 for display. Reach for float64 anywhere in the middle and you'll silently lose precision, which is how an off-by-a-few-wei rounding bug ends up in a payout.

1package utils
2 
3import (
4    "math/big"
5    "github.com/ethereum/go-ethereum/common"
6    "github.com/ethereum/go-ethereum/common/hexutil"
7)
8 
9// WeiToEther converts wei to ether
10func WeiToEther(wei *big.Int) *big.Float {
11    return new(big.Float).Quo(
12        new(big.Float).SetInt(wei),
13        new(big.Float).SetInt(big.NewInt(1e18)),
14    )
15}
16 
17// EtherToWei converts ether to wei
18func EtherToWei(ether *big.Float) *big.Int {
19    truncInt, _ := new(big.Float).Mul(ether, big.NewFloat(1e18)).Int(nil)
20    return truncInt
21}
22 
23// IsValidAddress checks if the address is valid
24func IsValidAddress(address string) bool {
25    return common.IsHexAddress(address)
26}

Go

Go-Ethereum (geth)

Smart Contract Integration

Event Monitoring

Utils and Helpers

هل أنت مستعد لاستدعاء هذا في الإنتاج؟

Go

Go-Ethereum (geth)

Smart Contract Integration

Event Monitoring

Utils and Helpers