I need to add a field when I sign it.

wallet.sign({ to: address, value: ethers.utils.parseEther('1'), type: 0, })

How to put type together with serialize

[axu6705]

Thanks! I have solved.

[axu6705]

If you are creating a new blockchain, you should look at the transactions package and define how your field is encoded for the underlying RLP.

Ethereum

const transactionFields = [
  {name: 'nonce', maxLength: 32},
  {name: 'gasPrice', maxLength: 32},
  {name: 'gasLimit', maxLength: 32},
  {name: 'to', length: 20},
  {name: 'value', maxLength: 32},
  {name: 'data'},
  {name: 'type', maxLength: 8},
];


const utils = ethers.utils;
function serialize(transaction, signature) {
  // utils.checkProperties(transaction, allowedTransactionKeys);
  let raw = [];
  transactionFields.forEach(function(fieldInfo, i) {
    let value = transaction[fieldInfo.name] || [];
    value = utils.arrayify(utils.hexlify(value));
    // Fixed-width field
    if (
      fieldInfo.length &&
      value.length !== fieldInfo.length &&
      value.length > 0
    ) {
      utils.errors.throwError(
        'invalid length for ' + fieldInfo.name,
        utils.errors.INVALID_ARGUMENT,
        {arg: 'transaction' + fieldInfo.name, value: value},
      );
    }
    // Variable-width (with a maximum)
    if (fieldInfo.maxLength) {
      value = utils.stripZeros(value);
      if (value.length > fieldInfo.maxLength) {
        utils.errors.throwError(
          'invalid length for ' + fieldInfo.name,
          utils.errors.INVALID_ARGUMENT,
          {arg: 'transaction' + fieldInfo.name, value: value},
        );
      }
    }
    raw.push(utils.hexlify(value));
  });

  if (transaction.chainId != null && transaction.chainId !== 0) {
    raw.push(utils.hexlify(transaction.chainId));
    raw.push('0x');
    raw.push('0x');
  }

  const unsignedTransaction = utils.RLP.encode(raw);
  // Requesting an unsigned transation
  if (!signature) {
    return unsignedTransaction;
  }
  // The splitSignature will ensure the transaction has a recoveryParam in the
  // case that the signTransaction function only adds a v.
  const sig = utils.splitSignature(signature);
  // We pushed a chainId and null r, s on for hashing only; remove those
  let v = 27 + sig.recoveryParam;
  if (raw.length === 10) {
    raw.pop();
    raw.pop();
    raw.pop();
    v += transaction.chainId * 2 + 8;
  }
  raw.push(utils.hexlify(v));
  raw.push(utils.stripZeros(utils.arrayify(sig.r)));
  raw.push(utils.stripZeros(utils.arrayify(sig.s)));

  return utils.RLP.encode(raw);
}

export class Wallet extends ethers.Wallet {
  constructor(privateKey, provider) {
    super(privateKey, provider);
  }

  async sign(transaction) {
    const tx = await utils.resolveProperties(transaction);
    const rawTx = serialize(tx);
    const signature = this.signingKey.signDigest(utils.keccak256(rawTx));
    return serialize(tx, signature);
  }
}

const signedTransaction = await Wallet.sign({ to: address, value: ethers.utils.parseEther('1'), type: 0});
provider.sendTransaction(signedTransaction);
// Error: invalid raw transaction

Without Type

Error: rlp: too few elements for types.txdata