本节将向你介绍如何转移ERC-20代币。了解如何转移非ERC-20兼容的其他类型的代币请查阅智能合约的章节 来了解如何与智能合约交互。
假设您已连接客户端，加载私钥并配置燃气价格，下一步是设置具体的交易数据字段。 如果你完全不明白我刚讲的这些，请先复习 以太币转账的章节。
代币传输不需要传输ETH，因此将交易“值”设置为“0”。

  1. value := big.NewInt(0)

先将您要发送代币的地址存储在变量中。

  1. toAddress := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")

现在轮到有趣的部分。 我们需要弄清楚交易的 data 部分。 这意味着我们需要找出我们将要调用的智能合约函数名，以及函数将接收的输入。 然后我们使用函数名的keccak-256哈希来检索 方法ID，它是前8个字符（4个字节）。 然后，我们附加我们发送的地址，并附加我们打算转账的代币数量。 这些输入需要256位长（32字节）并填充左侧。 方法ID不需填充。
为了演示，我创造了一个新的代币(HelloToken HTN)，这个可以用代币工厂服务来完成https://tokenfactory.surge.sh, 代币我部署到了Rinkeby测试网。
让我们将代币合约地址分配给变量。

  1. tokenAddress := common.HexToAddress("0x28b149020d2152179873ec60bed6bf7cd705775d")

函数名将是传递函数的名称，即ERC-20规范中的transfer和参数类型。 第一个参数类型是address（令牌的接收者），第二个类型是uint256（要发送的代币数量）。 不需要没有空格和参数名称。 我们还需要用字节切片格式。

  1. transferFnSignature := []byte("transfer(address,uint256)")

我们现在将从go-ethereum导入crypto/sha3包以生成函数签名的Keccak256哈希。 然后我们只使用前4个字节来获取方法ID。

  1. hash := sha3.NewKeccak256()
  2. hash.Write(transferFnSignature)
  3. methodID := hash.Sum(nil)[:4]
  4. fmt.Println(hexutil.Encode(methodID)) // 0xa9059cbb

接下来，我们需要将给我们发送代币的地址左填充到32字节。

  1. paddedAddress := common.LeftPadBytes(toAddress.Bytes(), 32)
  2. fmt.Println(hexutil.Encode(paddedAddress)) // 0x0000000000000000000000004592d8f8d7b001e72cb26a73e4fa1806a51ac79d

接下来我们确定要发送多少个代币，在这个例子里是1,000个，并且我们需要在big.Int中格式化为wei。

  1. amount := new(big.Int)
  2. amount.SetString("1000000000000000000000", 10) // 1000 tokens

代币量也需要左填充到32个字节。

  1. paddedAmount := common.LeftPadBytes(amount.Bytes(), 32)
  2. fmt.Println(hexutil.Encode(paddedAmount))  // 0x00000000000000000000000000000000000000000000003635c9adc5dea00000

接下来我们只需将方法ID，填充后的地址和填后的转账量，接到将成为我们数据字段的字节片。

  1. var data []byte
  2. data = append(data, methodID...)
  3. data = append(data, paddedAddress...)
  4. data = append(data, paddedAmount...)

燃气上限制将取决于交易数据的大小和智能合约必须执行的计算步骤。 幸运的是，客户端提供了EstimateGas方法，它可以为我们估算所需的燃气量。 这个函数从ethereum包中获取CallMsg结构，我们在其中指定数据和地址。 它将返回我们估算的完成交易所需的估计燃气上限。

  1. gasLimit, err := client.EstimateGas(context.Background(), ethereum.CallMsg{
  2.   To:   &toAddress,
  3.   Data: data,
  4. })
  5. if err != nil {
  6.   log.Fatal(err)
  7. }
  9. fmt.Println(gasLimit) // 23256

接下来我们需要做的是构建交易事务类型，这类似于您在ETH转账部分中看到的，除了to字段将是代币智能合约地址。 这个常让人困惑。我们还必须在调用中包含0 ETH的值字段和刚刚生成的数据字节。

  1. tx := types.NewTransaction(nonce, tokenAddress, value, gasLimit, gasPrice, data)

下一步是使用发件人的私钥对事务进行签名。 SignTx方法需要EIP155签名器(EIP155 signer)，这需要我们从客户端拿到链ID。

  1. chainID, err := client.NetworkID(context.Background())
  2. if err != nil {
  3.   log.Fatal(err)
  4. }
  6. signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
  7. if err != nil {
  8.   log.Fatal(err)
  9. }

最后广播交易。

  1. err = client.SendTransaction(context.Background(), signedTx)
  2. if err != nil {
  3.   log.Fatal(err)
  4. }
  6. fmt.Printf("tx sent: %s", signedTx.Hash().Hex()) // tx sent: 0xa56316b637a94c4cc0331c73ef26389d6c097506d581073f927275e7a6ece0bc

你可以去Etherscan看交易的确认过程: https://rinkeby.etherscan.io/tx/0xa56316b637a94c4cc0331c73ef26389d6c097506d581073f927275e7a6ece0bc
要了解更多如何加载ERC20智能合约并与之互动的内容，可以查看ERC20代币的智能合约章节.

完整代码

transfer_tokens.go

  1. package main
  3. import (
  4.     "context"
  5.     "crypto/ecdsa"
  6.     "fmt"
  7.     "log"
  8.     "math/big"
  10.     "github.com/ethereum/go-ethereum"
  11.     "github.com/ethereum/go-ethereum/common"
  12.     "github.com/ethereum/go-ethereum/common/hexutil"
  13.     "github.com/ethereum/go-ethereum/core/types"
  14.     "github.com/ethereum/go-ethereum/crypto"
  15.     "github.com/ethereum/go-ethereum/crypto/sha3"
  16.     "github.com/ethereum/go-ethereum/ethclient"
  17. )
  19. func main() {
  20.     client, err := ethclient.Dial("https://rinkeby.infura.io")
  21.     if err != nil {
  22.         log.Fatal(err)
  23.     }
  25.     privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
  26.     if err != nil {
  27.         log.Fatal(err)
  28.     }
  30.     publicKey := privateKey.Public()
  31.     publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
  32.     if !ok {
  33.         log.Fatal("cannot assert type: publicKey is not of type *ecdsa.PublicKey")
  34.     }
  36.     fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
  37.     nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
  38.     if err != nil {
  39.         log.Fatal(err)
  40.     }
  42.     value := big.NewInt(0) // in wei (0 eth)
  43.     gasPrice, err := client.SuggestGasPrice(context.Background())
  44.     if err != nil {
  45.         log.Fatal(err)
  46.     }
  48.     toAddress := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")
  49.     tokenAddress := common.HexToAddress("0x28b149020d2152179873ec60bed6bf7cd705775d")
  51.     transferFnSignature := []byte("transfer(address,uint256)")
  52.     hash := sha3.NewKeccak256()
  53.     hash.Write(transferFnSignature)
  54.     methodID := hash.Sum(nil)[:4]
  55.     fmt.Println(hexutil.Encode(methodID)) // 0xa9059cbb
  57.     paddedAddress := common.LeftPadBytes(toAddress.Bytes(), 32)
  58.     fmt.Println(hexutil.Encode(paddedAddress)) // 0x0000000000000000000000004592d8f8d7b001e72cb26a73e4fa1806a51ac79d
  60.     amount := new(big.Int)
  61.     amount.SetString("1000000000000000000000", 10) // 1000 tokens
  62.     paddedAmount := common.LeftPadBytes(amount.Bytes(), 32)
  63.     fmt.Println(hexutil.Encode(paddedAmount)) // 0x00000000000000000000000000000000000000000000003635c9adc5dea00000
  65.     var data []byte
  66.     data = append(data, methodID...)
  67.     data = append(data, paddedAddress...)
  68.     data = append(data, paddedAmount...)
  70.     gasLimit, err := client.EstimateGas(context.Background(), ethereum.CallMsg{
  71.         To:   &toAddress,
  72.         Data: data,
  73.     })
  74.     if err != nil {
  75.         log.Fatal(err)
  76.     }
  77.     fmt.Println(gasLimit) // 23256
  79.     tx := types.NewTransaction(nonce, tokenAddress, value, gasLimit, gasPrice, data)
  81.     chainID, err := client.NetworkID(context.Background())
  82.     if err != nil {
  83.         log.Fatal(err)
  84.     }
  86.     signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
  87.     if err != nil {
  88.         log.Fatal(err)
  89.     }
  91.     err = client.SendTransaction(context.Background(), signedTx)
  92.     if err != nil {
  93.         log.Fatal(err)
  94.     }
  96.     fmt.Printf("tx sent: %s", signedTx.Hash().Hex()) // tx sent: 0xa56316b637a94c4cc0331c73ef26389d6c097506d581073f927275e7a6ece0bc
  97. }