title: ERC-20 Token transfer problem: execution reverted: ERC20: transfer from the zero address
body: <p>i ve been trying to learn stuff about smart contracts lately, but when i tried to understand how a token transfer works i ve encountered this problem. || execution reverted: ERC20: transfer from the zero address || (ropsten network)</p>
  <p>the code:</p>
  <pre><code>
  import (
      &quot;context&quot;
      &quot;crypto/ecdsa&quot;
      &quot;fmt&quot;
      &quot;github.com/ethereum/go-ethereum&quot;
      &quot;github.com/ethereum/go-ethereum/common&quot;
      &quot;github.com/ethereum/go-ethereum/common/hexutil&quot;
      &quot;github.com/ethereum/go-ethereum/core/types&quot;
      &quot;github.com/ethereum/go-ethereum/crypto&quot;
      &quot;github.com/ethereum/go-ethereum/ethclient&quot;
      &quot;golang.org/x/crypto/sha3&quot;
      &quot;log&quot;
      &quot;math/big&quot;
  )
  
  func main() {
  
      client, err := ethclient.Dial(&quot;https://ropsten.infura.io/v3&quot;)
      if err != nil {
          panic(err)
      }
  
      chainID, _ := client.NetworkID(context.Background())
  
      privateKey, err := crypto.HexToECDSA(&quot;280a5fb7d2eef8c7956f4e6754c82a46f30496e43f50be4c8a457ef4e45fb1f4&quot;)
      if err != nil {
          log.Fatal(err)
      }
  
      publicKey := privateKey.Public()
      publicKeyECDSA, ok :=publicKey.(*ecdsa.PublicKey)
      if !ok {
          log.Fatal(&quot;cannot assert type: publicKey is not of type *ecdsa.PublicKey&quot;)
      }
  
      fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
      nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
  
      if err != nil {
          log.Fatal(err)
      }
  
      value := big.NewInt(0)
  
      toAddress := common.HexToAddress(&quot;0x0cFd37C2A1c9d0B8833fFE5a772003a350B5Be3f&quot;)
  
      tokenAddress := common.HexToAddress(&quot;0x4f1c3F4D89826f27204769Af1617540c219E3A62&quot;)
  
      transferFnSignature := []byte(&quot;transfer(address,uint256)&quot;)
      hash := sha3.NewLegacyKeccak256()
      hash.Write(transferFnSignature)
  
      methodID := hash.Sum(nil)[:4]
      fmt.Println(hexutil.Encode(methodID))
  
      paddedAddress := common.LeftPadBytes(toAddress.Bytes(),32)
      fmt.Println(hexutil.Encode(paddedAddress))
  
      amount := new(big.Int)
      amount.SetString(&quot;10000000000000000000&quot;, 10)
      paddedAmount := common.LeftPadBytes(amount.Bytes(), 32)
      fmt.Println(hexutil.Encode(paddedAmount))
  
      var data []byte
      data = append(data, methodID...)
      data = append(data, paddedAddress...)
      data = append(data, paddedAmount...)
  
      gasLimit, err := client.EstimateGas(context.Background(), ethereum.CallMsg{
          To: &amp;tokenAddress,
          Data: data,
      })
      if err != nil {
          log.Fatal(err)
      }
      gasPrice, err := client.SuggestGasPrice(context.Background())
      if err != nil {
          log.Fatal(err)
      }
  
      fmt.Println(gasLimit)
  
      tx := types.NewTx(&amp;types.LegacyTx{
          Nonce:    nonce,
          GasPrice: gasPrice,
          Gas:      gasLimit,
          To:       &amp;tokenAddress,
          Value:    value,
          Data:     data,
          V:        nil,
          R:        nil,
          S:        nil,
      })
  
      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(&quot;TOKEN TX SENT! || %s ||&quot;, signedTx.Hash().Hex())
  
  
  }
  </code></pre>
  <p>the token address is my contract address, the fromAddress is my wallet who is holding 10000 of my tokens, and the toAddress is a normal wallet. what am i missing here?</p>