Unable to serialize a transaction parsed with parse

[Mrtenz]

Describe the bug
When using the parse function of @ethersproject/transactions to parse a (legacy) transaction, trying to serialize that transaction (using the same package) results in an error:

Error: invalid object key - v (argument="transaction:v", value={"nonce":1,"gasPrice":{"type":"BigNumber","hex":"0x3b9aca00"},"gasLimit":{"type":"BigNumber","hex":"0x5208"},"to":"0x94Aa6B7E47CD75e14E73eE2e3951516C019Cf3DA","value":{"type":"BigNumber","hex":"0x0de0b6b3a7640000"},"data":"0x","chainId":1,"v":0,"r":"0x0000000000000000000000000000000000000000000000000000000000000000","s":"0x0000000000000000000000000000000000000000000000000000000000000000","type":null}, code=INVALID_ARGUMENT, version=properties/5.1.0)

    at Logger.makeError (./node_modules/@ethersproject/logger/src.ts/index.ts:205:28)
    at Logger.throwError (./node_modules/@ethersproject/logger/src.ts/index.ts:217:20)
    at Logger.throwArgumentError (./node_modules/@ethersproject/logger/src.ts/index.ts:221:21)
    at ./node_modules/@ethersproject/properties/src.ts/index.ts:53:20
    at Array.forEach (<anonymous>)
    at Object.checkProperties (./node_modules/@ethersproject/properties/src.ts/index.ts:51:25)
    at _serialize (./node_modules/@ethersproject/transactions/src.ts/index.ts:174:5)
    at serialize (./node_modules/@ethersproject/transactions/src.ts/index.ts:255:44)

This happens for both signed and unsigned transactions. I'm not sure if this is a bug, but it's definitely unexpected behaviour.

Reproduction steps
The following code will throw an error at serialize.

const rawTransaction = '0xeb01843b9aca008252089494aa6b7e47cd75e14e73ee2e3951516c019cf3da880de0b6b3a764000080018080';
const parsedTransaction = parse(rawTransaction);
serialize(parsedTransaction);

Removing the signature and type before serializing works:

const rawTransaction = '0xeb01843b9aca008252089494aa6b7e47cd75e14e73ee2e3951516c019cf3da880de0b6b3a764000080018080';
const { r, s, v, type, ...transaction } = parse(rawTransaction);
serialize(transaction);

Environment:
It happens both in Node.js (v14) and in a browser (tested in Chrome 90), using @ethersproject/transactions 5.2.0.

[ricmoo]

The serializing in v5 is very strict, which was to prevent simple typos from generating wrong output, but it does mean some methods are not reflexive.

This likely won’t be changed in v5, but in v6 things are much more relaxed, but easier to enforce as many things, like Transaction, are proper classes.

If there is a strong need for this, I can internally validate the properties are consistent and drop them before serializing.

There are a few other high-priority features though, such as eip-1559 support which is next on deck.

[Mrtenz]

There's no strong need since it's easy to work around the issue, but it would be nice to have (in v6) for sure.

[0xfoobar]

I'm noticing that it's also necessary to remove the from and hash fields. Is there anything else?

[ricmoo]

I'm going to move this to discussions for those who may also find it useful.

The issues described here affect only v5 and below; v6 will have a more robust solution. :)

[christroutner]

One big piece of information that seems to be missing from this conversation:

It's possible to circumvent this issue by creating a new object from the old, leaving out the problematic properties. Here is how I was able to circumvent this issue:

const deserializedTx = ethers.utils.parseTransaction(serializedTx);
console.log("deserializedTx: ", deserializedTx);

const testTx = {
  data: deserializedTx.data,
  to: deserializedTx.to,
  chainId: deserializedTx.chainId
};

const txInfo = await wallet.sendTransaction(testTx);

By creating a new object, and simply omitting the problematic properties, the transaction can be signed and broadcast.

I'm a newbie to ETH stuff, so this was not obvious to me.

[ricmoo]

Yes, in v5, that's the easiest thing to do.

[vjuge]

Is this new serialization method actually implemented in v6.3.x ? I have the same issue here, and I wonder if it's worth to migrate now...

[ricmoo]

In v6, the Transaction object is "alive". So, it has setters and getters, so it updates properties like hash and unsignedSeriailized as you update the value, data, etc.

When you pass in a Transaction object, it will populate all the available fields from that object.

I highly recommend v6, as it is much easier to do simple things without shooting yourself in the foot. :)

[Fabrice-Fabio]

@ricmoo please i've `const customSignTransaction = async (dataToSign) => {

const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();

const nonce = await signer.getNonce();
let gasPrice;
try{
    const feeData = await provider.getFeeData();
    gasPrice = feeData.gasPrice;
}catch(e){
    gasPrice = ethers.parseUnits('20', 'gwei');
}

const domain = {
    name: 'Test App',
    version: '1',
    chainId: (await provider.getNetwork()).chainId,
};

// MetaTransaction
const types = {
    Transaction: [
        { name: 'to', type: 'address' },
        { name: 'data', type: 'bytes' },
        { name: 'gasLimit', type: 'uint256' },
        { name: 'gasPrice', type: 'uint256' },
        { name: 'nonce', type: 'uint256' }
    ]
};

console.log("account : "+ethers.getAddress(account));
console.log("tokenAddress : "+tokenAddress);

const value = {
    to: tokenAddress,
    data: dataToSign,
    gasLimit: ethers.toBeHex(100000), // TODO : add gasLimit
    gasPrice: ethers.toBeHex(gasPrice),
    nonce: ethers.toBeHex(nonce)
};

try {
    const signature = await signer.signTypedData(domain, types, value);
    console.log('Signature:', signature);

    // Verify the signature
    const recoveredAddress = ethers.verifyTypedData(domain, types, value, signature);

    if(recoveredAddress.toLowerCase() != account.toLowerCase()){
      throw new Error('Signature verification failed');
    }

    // Extract r, s, and v from the signature
    const sig = ethers.Signature.from(signature);
    console.log(sig);
    const v = sig.v;
    const r = sig.r;
    const s = sig.s;

    console.log("r-s-v : "+r+"-"+s+"-"+v);

    const rawTx = {
        to: value.to,
        data: value.data,
        gasLimit: value.gasLimit,
        gasPrice: value.gasPrice,
        nonce: value.nonce,
        v: ethers.toBeHex(v),
        r,
        s
    };

  //// I WANT serialize transaction here so i can have the hash, is it possible ? ////
    
    console.log(rawTx);
    return rawTx;

} catch (error) {
    console.error('Error custom sign transaction :', error);
    return;
}

};` but unfortunatly i cant found how to do it even if with v6

[Fabrice-Fabio]

and when i apply : const serializedTx = ethers.Transaction.from(rawTx); console.log(serializedTx); console.log('UnsignedSerialized Transaction:', serializedTx.unsignedSerialized); console.log('Serialized Transaction:', serializedTx.serialized); i got as response UnsignedSerialized Transaction: 0x01f86b808202028512e89203d6830186a094d6df932a45c0f255f85145f286ea0b292b21c90b80b844095ea7b30000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae00000000000000000000000000000000000000000000000000041f038bf08000c0 and error that show : GasWidget.js:112 Error sending transaction: Error: cannot serialize unsigned transaction; maybe you meant .unsignedSerialized (operation=".serialized", code=UNSUPPORTED_OPERATION, version=6.13.1)