type types.Transactions has no field or method GetRlp

Question

I am trying to create a raw transaction in go-ethereum and found some tutorial code that I was tinkering with. The error is:

./transaction_raw_create.go:65:18: ts.GetRlp undefined (type types.Transactions has no field or method GetRlp)

The code:

package main

import (
    "context"
    "crypto/ecdsa"
    "encoding/hex"
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethclient"
    "github.com/jimlawless/whereami"
)

func createRawTransaction() {
    client, err := ethclient.Dial(infura.URL + infura.ID)
    if err != nil {
        fmt.Println(err.Error() + "@" + whereami.WhereAmI())
    }

    privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
    if err != nil {
        fmt.Println(err.Error() + "@" + whereami.WhereAmI())
    }

    publicKey := privateKey.Public()
    publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
    if !ok {
        fmt.Println("error casting public key to ECDSA@" + whereami.WhereAmI())
    }

    fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
    nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
    if err != nil {
        fmt.Println(err.Error() + "@" + whereami.WhereAmI())
    }

    value := big.NewInt(1000000000000000000) // in wei (1 eth)
    gasLimit := uint64(21000)                // in units
    gasPrice, err := client.SuggestGasPrice(context.Background())
    if err != nil {
        fmt.Println(err.Error() + "@" + whereami.WhereAmI())
    }

    toAddress := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")
    var data []byte
    tx := types.NewTransaction(nonce, toAddress, value, gasLimit, gasPrice, data)

    chainID, err := client.NetworkID(context.Background())
    if err != nil {
        fmt.Println(err.Error() + "@" + whereami.WhereAmI())
    }

    signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
    if err != nil {
        fmt.Println(err.Error() + "@" + whereami.WhereAmI())
    }
    fmt.Print("signedTx: ")
    fmt.Println(signedTx)

    /*  */
    ts := types.Transactions{signedTx}
    rawTxBytes := ts.GetRlp(0)
    rawTxHex := hex.EncodeToString(rawTxBytes)
    fmt.Printf(rawTxHex) // f86...772
}

I am attempting to extract the transaction Hex value from the signed transaction.

Any suggestions on how to replace the last part?

    ts := types.Transactions{signedTx}
    rawTxBytes := ts.GetRlp(0)  //<-- ts.GetRlp undefined 
    rawTxHex := hex.EncodeToString(rawTxBytes)
    fmt.Printf(rawTxHex) // f86...772

Forgot to mention: $ go version go version go1.17.2 linux/amd64 — pigfox, Jan 18 '22 at 20:46

score 7 · Accepted Answer · answered Jan 18 '22 at 20:56

Not sure when it was removed, but the code previously was

import (
    // ...
    "github.com/ethereum/go-ethereum/rlp"
    // ...
)

// GetRlp implements Rlpable and returns the i'th element of s in rlp.
func (s Transactions) GetRlp(i int) []byte {
    enc, _ := rlp.EncodeToBytes(s[i])
    return enc
}

And rlp.EncodeToBytes still exists, so it stands to reason that you could do

ts := types.Transactions{signedTx}
rawTxBytes, _ := rlp.EncodeToBytes(ts[0])  //<-- ts.GetRlp undefined 
rawTxHex := hex.EncodeToString(rawTxBytes)
fmt.Printf(rawTxHex) // f86...772

That being said, there seems to be a new function

func (s Transactions) EncodeIndex(i int, w *bytes.Buffer) {
    tx := s[i]
    if tx.Type() == LegacyTxType {
        rlp.Encode(w, tx.inner)
    } else {
        tx.encodeTyped(w)
    }
}

so I would probably try doing

b := new(bytes.Buffer)
ts.EncodeIndex(0, b)
rawTxBytes := b.Bytes()

type types.Transactions has no field or method GetRlp

1 Answers1

Linked