go-ethereum 使用指南

go-ethereum (简称 Geth) 是以太坊协议的官方 Go 语言实现，它提供了与以太坊区块链交互的全套功能。下面我将介绍如何使用 go-ethereum 进行常见的区块链操作。

1. 安装 go-ethereum

首先需要安装 go-ethereum 库：

go get -u github.com/ethereum/go-ethereum

2. 连接以太坊节点

连接到本地节点

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/ethereum/go-ethereum/ethclient"
)

func main() {
	// 连接到本地节点 (默认IPC路径)
	client, err := ethclient.Dial("/home/user/.ethereum/geth.ipc")
	if err != nil {
		log.Fatal(err)
	}

	// 或者连接到远程节点
	// client, err := ethclient.Dial("https://mainnet.infura.io/v3/YOUR_PROJECT_ID")
	
	// 获取最新区块号
	header, err := client.HeaderByNumber(context.Background(), nil)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Latest block number:", header.Number.String())
}

3. 查询账户余额

func checkBalance() {
	client, err := ethclient.Dial("https://mainnet.infura.io/v3/YOUR_PROJECT_ID")
	if err != nil {
		log.Fatal(err)
	}

	// 替换为你要查询的地址
	account := common.HexToAddress("0x71c7656ec7ab88b098defb751b7401b5f6d8976f")
	
	balance, err := client.BalanceAt(context.Background(), account, nil)
	if err != nil {
		log.Fatal(err)
	}

	// 将wei转换为ether
	ethBalance := new(big.Float).Quo(new(big.Float).SetInt(balance), big.NewFloat(math.Pow10(18)))
	fmt.Printf("Balance: %f ETH\n", ethBalance)
}

4. 发送交易

func sendTransaction() {
	// 连接到节点
	client, err := ethclient.Dial("https://ropsten.infura.io/v3/YOUR_PROJECT_ID")
	if err != nil {
		log.Fatal(err)
	}

	// 加载私钥 (实际应用中应从安全的地方获取)
	privateKey, err := crypto.HexToECDSA("YOUR_PRIVATE_KEY")
	if err != nil {
		log.Fatal(err)
	}

	// 获取账户地址
	publicKey := privateKey.Public()
	publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
	if !ok {
		log.Fatal("cannot assert type: publicKey is not of type *ecdsa.PublicKey")
	}
	fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)

	// 获取nonce
	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
	if err != nil {
		log.Fatal(err)
	}

	// 设置转账金额 (1 ETH)
	value := big.NewInt(1000000000000000000) // in wei (1 eth)
	gasLimit := uint64(21000)                // in units
	gasPrice, err := client.SuggestGasPrice(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	// 目标地址
	toAddress := common.HexToAddress("0xRecipientAddress")

	// 创建交易
	tx := types.NewTransaction(nonce, toAddress, value, gasLimit, gasPrice, nil)

	// 获取链ID
	chainID, err := client.NetworkID(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	// 签名交易
	signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
	if err != nil {
		log.Fatal(err)
	}

	// 发送交易
	err = client.SendTransaction(context.Background(), signedTx)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("tx sent: %s", signedTx.Hash().Hex())
}

5. 与智能合约交互

读取合约数据

func readContract() {
	// 连接到节点
	client, err := ethclient.Dial("https://mainnet.infura.io/v3/YOUR_PROJECT_ID")
	if err != nil {
		log.Fatal(err)
	}

	// 合约地址 (这里使用USDT合约作为示例)
	contractAddress := common.HexToAddress("0xdac17f958d2ee523a2206206994597c13d831ec7")
	
	// 合约ABI (简化版)
	contractABI := `[{"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]`
	
	// 创建合约实例
	contract, err := abi.JSON(strings.NewReader(contractABI))
	if err != nil {
		log.Fatal(err)
	}

	// 要查询的地址
	account := common.HexToAddress("0xAddressToQuery")

	// 调用balanceOf方法
	data, err := contract.Pack("balanceOf", account)
	if err != nil {
		log.Fatal(err)
	}

	// 执行call
	msg := ethereum.CallMsg{
		To:   &contractAddress,
		Data: data,
	}
	result, err := client.CallContract(context.Background(), msg, nil)
	if err != nil {
		log.Fatal(err)
	}

	// 解析结果
	var balance *big.Int
	err = contract.UnpackIntoInterface(&balance, "balanceOf", result)
	if err != nil {
		log.Fatal(err)
	}

	// USDT有6位小数
	usdtBalance := new(big.Float).Quo(new(big.Float).SetInt(balance), big.NewFloat(math.Pow10(6)))
	fmt.Printf("USDT Balance: %f\n", usdtBalance)
}

6. 监听新区块和事件

func watchBlocks() {
	client, err := ethclient.Dial("wss://mainnet.infura.io/ws/v3/YOUR_PROJECT_ID")
	if err != nil {
		log.Fatal(err)
	}

	headers := make(chan *types.Header)
	sub, err := client.SubscribeNewHead(context.Background(), headers)
	if err != nil {
		log.Fatal(err)
	}

	for {
		select {
		case err := <-sub.Err():
			log.Fatal(err)
		case header := <-headers:
			fmt.Println("New block:", header.Number.String())
			
			// 获取完整区块信息
			block, err := client.BlockByHash(context.Background(), header.Hash())
			if err != nil {
				log.Fatal(err)
			}
			
			fmt.Println("Block hash:", block.Hash().Hex())
			fmt.Println("Block transactions:", len(block.Transactions()))
		}
	}
}

7. 部署智能合约

func deployContract() {
	// 连接到测试网络
	client, err := ethclient.Dial("https://ropsten.infura.io/v3/YOUR_PROJECT_ID")
	if err != nil {
		log.Fatal(err)
	}

	// 加载私钥
	privateKey, err := crypto.HexToECDSA("YOUR_PRIVATE_KEY")
	if err != nil {
		log.Fatal(err)
	}

	// 获取账户地址和nonce
	publicKey := privateKey.Public()
	publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
	if !ok {
		log.Fatal("cannot assert type: publicKey is not of type *ecdsa.PublicKey")
	}
	fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
	if err != nil {
		log.Fatal(err)
	}

	// 设置gas价格和限制
	gasPrice, err := client.SuggestGasPrice(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	auth := bind.NewKeyedTransactor(privateKey)
	auth.Nonce = big.NewInt(int64(nonce))
	auth.Value = big.NewInt(0)     // in wei
	auth.GasLimit = uint64(300000) // in units
	auth.GasPrice = gasPrice

	// 编译合约 (这里使用简单示例)
	// 实际项目中应该使用solc编译合约获取bytecode和abi
	contractBytecode := "0x606060...合约字节码..."
	contractABI := `[{"constant":false,"inputs":[{"name":"x","type":"uint256"}],"name":"set","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"get","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_x","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"}]`

	// 解析ABI
	parsedABI, err := abi.JSON(strings.NewReader(contractABI))
	if err != nil {
		log.Fatal(err)
	}

	// 部署合约
	address, tx, _, err := bind.DeployContract(auth, parsedABI, common.FromHex(contractBytecode), client, big.NewInt(123)) // 123是构造函数参数
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Contract deployed at:", address.Hex())
	fmt.Println("Transaction hash:", tx.Hash().Hex())
}

注意事项

1. 私钥管理：实际应用中不应将私钥硬编码在代码中，应使用安全的存储方式
2. 错误处理：生产代码中需要更完善的错误处理
3. 网络选择：开发时建议使用测试网络(Ropsten, Rinkeby等)而非主网
4. 资源管理：记得关闭连接和释放资源
5. 异步处理：大量数据查询时考虑使用goroutine提高效率

go-ethereum 提供了丰富的功能，以上只是基础用法。根据你的具体需求，可以进一步探索其文档和源码实现更复杂的功能。