quantumcoin 6.14.5 → 7.0.2

package/src.ts/transaction/transaction.ts

@@ -1,1349 +0,0 @@
-
-import { getAddress } from "../address/index.js";
-import { ZeroAddress } from "../constants/addresses.js";
-import {
-    keccak256, sha256, Signature, SigningKey
-} from "../crypto/index.js";
-import {
-    concat, decodeRlp, encodeRlp, getBytes, getBigInt, getNumber, hexlify,
-    assert, assertArgument, isBytesLike, isHexString, toBeArray, zeroPadValue
-} from "../utils/index.js";
-
-import { accessListify } from "./accesslist.js";
-import { authorizationify } from "./authorization.js";
-import { recoverAddress } from "./address.js";
-
-import type { BigNumberish, BytesLike } from "../utils/index.js";
-import type { SignatureLike } from "../crypto/index.js";
-
-import type {
-    AccessList, AccessListish, Authorization, AuthorizationLike
-} from "./index.js";
-
-
-const BN_0 = BigInt(0);
-const BN_2 = BigInt(2);
-const BN_27 = BigInt(27)
-const BN_28 = BigInt(28)
-const BN_35 = BigInt(35);
-const BN_MAX_UINT = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-
-const BLOB_SIZE = 4096 * 32;
-
-// The BLS Modulo; each field within a BLOb must be less than this
-//const BLOB_BLS_MODULO = BigInt("0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001");
-
-/**
- *  A **TransactionLike** is an object which is appropriate as a loose
- *  input for many operations which will populate missing properties of
- *  a transaction.
- */
-export interface TransactionLike<A = string> {
-    /**
-     *  The type.
-     */
-    type?: null | number;
-
-    /**
-     *  The recipient address or ``null`` for an ``init`` transaction.
-     */
-    to?: null | A;
-
-    /**
-     *  The sender.
-     */
-    from?: null | A;
-
-    /**
-     *  The nonce.
-     */
-    nonce?: null | number;
-
-    /**
-     *  The maximum amount of gas that can be used.
-     */
-    gasLimit?: null | BigNumberish;
-
-    /**
-     *  The gas price for legacy and berlin transactions.
-     */
-    gasPrice?: null | BigNumberish;
-
-    /**
-     *  The maximum priority fee per gas for london transactions.
-     */
-    maxPriorityFeePerGas?: null | BigNumberish;
-
-    /**
-     *  The maximum total fee per gas for london transactions.
-     */
-    maxFeePerGas?: null | BigNumberish;
-
-    /**
-     *  The data.
-     */
-    data?: null | string;
-
-    /**
-     *  The value (in wei) to send.
-     */
-    value?: null | BigNumberish;
-
-    /**
-     *  The chain ID the transaction is valid on.
-     */
-    chainId?: null | BigNumberish;
-
-    /**
-     *  The transaction hash.
-     */
-    hash?: null | string;
-
-    /**
-     *  The signature provided by the sender.
-     */
-    signature?: null | SignatureLike;
-
-    /**
-     *  The access list for berlin and london transactions.
-     */
-    accessList?: null | AccessListish;
-
-    /**
-     *  The maximum fee per blob gas (see [[link-eip-4844]]).
-     */
-    maxFeePerBlobGas?: null | BigNumberish;
-
-    /**
-     *  The versioned hashes (see [[link-eip-4844]]).
-     */
-    blobVersionedHashes?: null | Array<string>;
-
-    /**
-     *  The blobs (if any) attached to this transaction (see [[link-eip-4844]]).
-     */
-    blobs?: null | Array<BlobLike>
-
-    /**
-     *  An external library for computing the KZG commitments and
-     *  proofs necessary for EIP-4844 transactions (see [[link-eip-4844]]).
-     *
-     *  This is generally ``null``, unless you are creating BLOb
-     *  transactions.
-     */
-    kzg?: null | KzgLibraryLike;
-
-    /**
-     *  The [[link-eip-7702]] authorizations (if any).
-     */
-    authorizationList?: null | Array<Authorization>;
-}
-
-/**
- *  A full-valid BLOb object for [[link-eip-4844]] transactions.
- *
- *  The commitment and proof should have been computed using a
- *  KZG library.
- */
-export interface Blob {
-    data: string;
-    proof: string;
-    commitment: string;
-}
-
-/**
- *  A BLOb object that can be passed for [[link-eip-4844]]
- *  transactions.
- *
- *  It may have had its commitment and proof already provided
- *  or rely on an attached [[KzgLibrary]] to compute them.
- */
-export type BlobLike = BytesLike | {
-    data: BytesLike;
-    proof: BytesLike;
-    commitment: BytesLike;
-};
-
-/**
- *  A KZG Library with the necessary functions to compute
- *  BLOb commitments and proofs.
- */
-export interface KzgLibrary {
-    blobToKzgCommitment: (blob: Uint8Array) => Uint8Array;
-    computeBlobKzgProof: (blob: Uint8Array, commitment: Uint8Array) => Uint8Array;
-}
-
-/**
- *  A KZG Library with any of the various API configurations.
- *  As the library is still experimental and the API is not
- *  stable, depending on the version used the method names and
- *  signatures are still in flux.
- *
- *  This allows any of the versions to be passed into Transaction
- *  while providing a stable external API.
- */
-export type KzgLibraryLike  = KzgLibrary | {
-    // kzg-wasm >= 0.5.0
-    blobToKZGCommitment: (blob: string) => string;
-    computeBlobKZGProof: (blob: string, commitment: string) => string;
-} | {
-    // micro-ecc-signer
-    blobToKzgCommitment: (blob: string) => string | Uint8Array;
-    computeBlobProof: (blob: string, commitment: string) => string | Uint8Array;
-};
-
-function getKzgLibrary(kzg: KzgLibraryLike): KzgLibrary {
-
-    const blobToKzgCommitment = (blob: Uint8Array) => {
-
-        if ("computeBlobProof" in kzg) {
-            // micro-ecc-signer; check for computeBlobProof since this API
-            // expects a string while the kzg-wasm below expects a Unit8Array
-
-            if ("blobToKzgCommitment" in kzg && typeof(kzg.blobToKzgCommitment) === "function") {
-                return getBytes(kzg.blobToKzgCommitment(hexlify(blob)))
-            }
-
-        } else if ("blobToKzgCommitment" in kzg && typeof(kzg.blobToKzgCommitment) === "function") {
-            // kzg-wasm <0.5.0; blobToKzgCommitment(Uint8Array) => Uint8Array
-
-            return getBytes(kzg.blobToKzgCommitment(blob));
-        }
-
-        // kzg-wasm >= 0.5.0; blobToKZGCommitment(string) => string
-        if ("blobToKZGCommitment" in kzg && typeof(kzg.blobToKZGCommitment) === "function") {
-            return getBytes(kzg.blobToKZGCommitment(hexlify(blob)));
-        }
-
-        assertArgument(false, "unsupported KZG library", "kzg", kzg);
-    };
-
-    const computeBlobKzgProof = (blob: Uint8Array, commitment: Uint8Array) => {
-
-        // micro-ecc-signer
-        if ("computeBlobProof" in kzg && typeof(kzg.computeBlobProof) === "function") {
-            return getBytes(kzg.computeBlobProof(hexlify(blob), hexlify(commitment)))
-        }
-
-        // kzg-wasm <0.5.0; computeBlobKzgProof(Uint8Array, Uint8Array) => Uint8Array
-        if ("computeBlobKzgProof" in kzg && typeof(kzg.computeBlobKzgProof) === "function") {
-            return kzg.computeBlobKzgProof(blob, commitment);
-        }
-
-        // kzg-wasm >= 0.5.0; computeBlobKZGProof(string, string) => string
-        if ("computeBlobKZGProof" in kzg && typeof(kzg.computeBlobKZGProof) === "function") {
-            return getBytes(kzg.computeBlobKZGProof(hexlify(blob), hexlify(commitment)));
-        }
-
-        assertArgument(false, "unsupported KZG library", "kzg", kzg);
-    };
-
-    return { blobToKzgCommitment, computeBlobKzgProof };
-}
-
-function getVersionedHash(version: number, hash: BytesLike): string {
-    let versioned = version.toString(16);
-    while (versioned.length < 2) { versioned = "0" + versioned; }
-    versioned += sha256(hash).substring(4);
-    return "0x" + versioned;
-}
-
-function handleAddress(value: string): null | string {
-    if (value === "0x") { return null; }
-    return getAddress(value);
-}
-
-function handleAccessList(value: any, param: string): AccessList {
-    try {
-        return accessListify(value);
-    } catch (error: any) {
-        assertArgument(false, error.message, param, value);
-    }
-}
-
-function handleAuthorizationList(value: any, param: string): Array<Authorization> {
-    try {
-        if (!Array.isArray(value)) { throw new Error("authorizationList: invalid array"); }
-        const result: Array<Authorization> = [ ];
-        for (let i = 0; i < value.length; i++) {
-            const auth: Array<string> = value[i];
-            if (!Array.isArray(auth)) { throw new Error(`authorization[${ i }]: invalid array`); }
-            if (auth.length !== 6) { throw new Error(`authorization[${ i }]: wrong length`); }
-            if (!auth[1]) { throw new Error(`authorization[${ i }]: null address`); }
-            result.push({
-                address: <string>handleAddress(auth[1]),
-                nonce: handleUint(auth[2], "nonce"),
-                chainId: handleUint(auth[0], "chainId"),
-                signature: Signature.from({
-                    r: auth[4],
-                    s: auth[5],
-                    v: 1
-                })
-            });
-        }
-        return result;
-    } catch (error: any) {
-        assertArgument(false, error.message, param, value);
-    }
-}
-
-function handleNumber(_value: string, param: string): number {
-    if (_value === "0x") { return 0; }
-    return getNumber(_value, param);
-}
-
-function handleUint(_value: string, param: string): bigint {
-    if (_value === "0x") { return BN_0; }
-    const value = getBigInt(_value, param);
-    assertArgument(value <= BN_MAX_UINT, "value exceeds uint size", param, value);
-    return value;
-}
-
-function formatNumber(_value: BigNumberish, name: string): Uint8Array {
-    const value = getBigInt(_value, "value");
-    const result = toBeArray(value);
-    assertArgument(result.length <= 32, `value too large`, `tx.${ name }`, value);
-    return result;
-}
-
-function formatAccessList(value: AccessListish): Array<[ string, Array<string> ]> {
-    return accessListify(value).map((set) => [ set.address, set.storageKeys ]);
-}
-
-function formatAuthorizationList(value: Array<Authorization>): Array<Array<string | Uint8Array>> {
-    return value.map((a) => {
-        return [
-            formatNumber(a.chainId, "chainId"),
-            a.address,
-            formatNumber(a.nonce, "nonce"),
-            a.signature.r,
-            a.signature.s
-        ];
-    });
-}
-
-function formatHashes(value: Array<string>, param: string): Array<string> {
-    assertArgument(Array.isArray(value), `invalid ${ param }`, "value", value);
-    for (let i = 0; i < value.length; i++) {
-        assertArgument(isHexString(value[i], 32), "invalid ${ param } hash", `value[${ i }]`, value[i]);
-    }
-    return value;
-}
-
-function _parseLegacy(data: Uint8Array): TransactionLike {
-    const fields: any = decodeRlp(data);
-
-    assertArgument(Array.isArray(fields) && (fields.length === 9 || fields.length === 6),
-        "invalid field count for legacy transaction", "data", data);
-
-    const tx: TransactionLike = {
-        type:     0,
-        nonce:    handleNumber(fields[0], "nonce"),
-        gasPrice: handleUint(fields[1], "gasPrice"),
-        gasLimit: handleUint(fields[2], "gasLimit"),
-        to:       handleAddress(fields[3]),
-        value:    handleUint(fields[4], "value"),
-        data:     hexlify(fields[5]),
-        chainId:  BN_0
-    };
-
-    // Legacy unsigned transaction
-    if (fields.length === 6) { return tx; }
-
-    const v = handleUint(fields[6], "v");
-    const r = handleUint(fields[7], "r");
-    const s = handleUint(fields[8], "s");
-
-    if (r === BN_0 && s === BN_0) {
-        // EIP-155 unsigned transaction
-        tx.chainId = v;
-
-    } else {
-
-        // Compute the EIP-155 chain ID (or 0 for legacy)
-        let chainId = (v - BN_35) / BN_2;
-        if (chainId < BN_0) { chainId = BN_0; }
-        tx.chainId = chainId
-
-        // Signed Legacy Transaction
-        assertArgument(chainId !== BN_0 || (v === BN_27 || v === BN_28), "non-canonical legacy v", "v", fields[6]);
-
-        tx.signature = Signature.from({
-            r: zeroPadValue(fields[7], 32),
-            s: zeroPadValue(fields[8], 32),
-            v
-        });
-
-        //tx.hash = keccak256(data);
-    }
-
-    return tx;
-}
-
-function _serializeLegacy(tx: Transaction, sig: null | Signature): string {
-    const fields: Array<any> = [
-        formatNumber(tx.nonce, "nonce"),
-        formatNumber(tx.gasPrice || 0, "gasPrice"),
-        formatNumber(tx.gasLimit, "gasLimit"),
-        (tx.to || "0x"),
-        formatNumber(tx.value, "value"),
-        tx.data,
-    ];
-
-    let chainId = BN_0;
-    if (tx.chainId != BN_0) {
-        // A chainId was provided; if non-zero we'll use EIP-155
-        chainId = getBigInt(tx.chainId, "tx.chainId");
-
-    } else if (tx.signature) {
-
-    }
-
-    // Requesting an unsigned transaction
-    if (!sig) {
-        // We have an EIP-155 transaction (chainId was specified and non-zero)
-        if (chainId !== BN_0) {
-            fields.push(toBeArray(chainId));
-            fields.push("0x");
-            fields.push("0x");
-        }
-
-        return encodeRlp(fields);
-    }
-
-    let v = sig.v;
-
-    // Add the signature
-    fields.push(toBeArray(v));
-    fields.push(toBeArray(sig.r));
-    fields.push(toBeArray(sig.s));
-
-    return encodeRlp(fields);
-}
-
-function _parseEipSignature(tx: TransactionLike, fields: Array<string>): void {
-    const r = fields[1];
-    const s = fields[2]
-
-    const signature = Signature.from({ r, s });
-    tx.signature = signature;
-}
-
-function _parseEip1559(data: Uint8Array): TransactionLike {
-    const fields: any = decodeRlp(getBytes(data).slice(1));
-
-    assertArgument(Array.isArray(fields) && (fields.length === 9 || fields.length === 12),
-        "invalid field count for transaction type: 2", "data", hexlify(data));
-
-    const tx: TransactionLike = {
-        type:                  2,
-        chainId:               handleUint(fields[0], "chainId"),
-        nonce:                 handleNumber(fields[1], "nonce"),
-        maxPriorityFeePerGas:  handleUint(fields[2], "maxPriorityFeePerGas"),
-        maxFeePerGas:          handleUint(fields[3], "maxFeePerGas"),
-        gasPrice:              null,
-        gasLimit:              handleUint(fields[4], "gasLimit"),
-        to:                    handleAddress(fields[5]),
-        value:                 handleUint(fields[6], "value"),
-        data:                  hexlify(fields[7]),
-        accessList:            handleAccessList(fields[8], "accessList"),
-    };
-
-    // Unsigned EIP-1559 Transaction
-    if (fields.length === 9) { return tx; }
-
-    //tx.hash = keccak256(data);
-
-    _parseEipSignature(tx, fields.slice(9));
-
-    return tx;
-}
-
-function _serializeEip1559(tx: Transaction, sig: null | Signature): string {
-    const fields: Array<any> = [
-        formatNumber(tx.chainId, "chainId"),
-        formatNumber(tx.nonce, "nonce"),
-        formatNumber(tx.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"),
-        formatNumber(tx.maxFeePerGas || 0, "maxFeePerGas"),
-        formatNumber(tx.gasLimit, "gasLimit"),
-        (tx.to || "0x"),
-        formatNumber(tx.value, "value"),
-        tx.data,
-        formatAccessList(tx.accessList || [ ])
-    ];
-
-    if (sig) {
-        fields.push(toBeArray(sig.r));
-        fields.push(toBeArray(sig.s));
-    }
-
-    return concat([ "0x02", encodeRlp(fields)]);
-}
-
-function _parseEip2930(data: Uint8Array): TransactionLike {
-    const fields: any = decodeRlp(getBytes(data).slice(1));
-
-    assertArgument(Array.isArray(fields) && (fields.length === 8 || fields.length === 11),
-        "invalid field count for transaction type: 1", "data", hexlify(data));
-
-    const tx: TransactionLike = {
-        type:       1,
-        chainId:    handleUint(fields[0], "chainId"),
-        nonce:      handleNumber(fields[1], "nonce"),
-        gasPrice:   handleUint(fields[2], "gasPrice"),
-        gasLimit:   handleUint(fields[3], "gasLimit"),
-        to:         handleAddress(fields[4]),
-        value:      handleUint(fields[5], "value"),
-        data:       hexlify(fields[6]),
-        accessList: handleAccessList(fields[7], "accessList")
-    };
-
-    // Unsigned EIP-2930 Transaction
-    if (fields.length === 8) { return tx; }
-
-    //tx.hash = keccak256(data);
-
-    _parseEipSignature(tx, fields.slice(8));
-
-    return tx;
-}
-
-function _serializeEip2930(tx: Transaction, sig: null | Signature): string {
-    const fields: any = [
-        formatNumber(tx.chainId, "chainId"),
-        formatNumber(tx.nonce, "nonce"),
-        formatNumber(tx.gasPrice || 0, "gasPrice"),
-        formatNumber(tx.gasLimit, "gasLimit"),
-        (tx.to || "0x"),
-        formatNumber(tx.value, "value"),
-        tx.data,
-        formatAccessList(tx.accessList || [ ])
-    ];
-
-    if (sig) {
-        fields.push(toBeArray(sig.r));
-        fields.push(toBeArray(sig.s));
-    }
-
-    return concat([ "0x01", encodeRlp(fields)]);
-}
-
-function _parseEip4844(data: Uint8Array): TransactionLike {
-    let fields: any = decodeRlp(getBytes(data).slice(1));
-
-    let typeName = "3";
-
-    let blobs: null | Array<Blob> = null;
-
-    // Parse the network format
-    if (fields.length === 4 && Array.isArray(fields[0])) {
-        typeName = "3 (network format)";
-        const fBlobs = fields[1], fCommits = fields[2], fProofs = fields[3];
-        assertArgument(Array.isArray(fBlobs), "invalid network format: blobs not an array", "fields[1]", fBlobs);
-        assertArgument(Array.isArray(fCommits), "invalid network format: commitments not an array", "fields[2]", fCommits);
-        assertArgument(Array.isArray(fProofs), "invalid network format: proofs not an array", "fields[3]", fProofs);
-        assertArgument(fBlobs.length === fCommits.length, "invalid network format: blobs/commitments length mismatch", "fields", fields);
-        assertArgument(fBlobs.length === fProofs.length, "invalid network format: blobs/proofs length mismatch", "fields", fields);
-
-        blobs = [ ];
-        for (let i = 0; i < fields[1].length; i++) {
-            blobs.push({
-                data: fBlobs[i],
-                commitment: fCommits[i],
-                proof: fProofs[i],
-            });
-        }
-
-        fields = fields[0];
-    }
-
-    assertArgument(Array.isArray(fields) && (fields.length === 11 || fields.length === 14),
-        `invalid field count for transaction type: ${ typeName }`, "data", hexlify(data));
-
-    const tx: TransactionLike = {
-        type:                  3,
-        chainId:               handleUint(fields[0], "chainId"),
-        nonce:                 handleNumber(fields[1], "nonce"),
-        maxPriorityFeePerGas:  handleUint(fields[2], "maxPriorityFeePerGas"),
-        maxFeePerGas:          handleUint(fields[3], "maxFeePerGas"),
-        gasPrice:              null,
-        gasLimit:              handleUint(fields[4], "gasLimit"),
-        to:                    handleAddress(fields[5]),
-        value:                 handleUint(fields[6], "value"),
-        data:                  hexlify(fields[7]),
-        accessList:            handleAccessList(fields[8], "accessList"),
-        maxFeePerBlobGas:      handleUint(fields[9], "maxFeePerBlobGas"),
-        blobVersionedHashes:   fields[10]
-    };
-
-    if (blobs) { tx.blobs = blobs; }
-
-    assertArgument(tx.to != null, `invalid address for transaction type: ${ typeName }`, "data", data);
-
-    assertArgument(Array.isArray(tx.blobVersionedHashes), "invalid blobVersionedHashes: must be an array", "data", data);
-    for (let i = 0; i < tx.blobVersionedHashes.length; i++) {
-        assertArgument(isHexString(tx.blobVersionedHashes[i], 32), `invalid blobVersionedHash at index ${ i }: must be length 32`, "data", data);
-    }
-
-    // Unsigned EIP-4844 Transaction
-    if (fields.length === 11) { return tx; }
-
-    // @TODO: Do we need to do this? This is only called internally
-    // and used to verify hashes; it might save time to not do this
-    //tx.hash = keccak256(concat([ "0x03", encodeRlp(fields) ]));
-
-    _parseEipSignature(tx, fields.slice(11));
-
-    return tx;
-}
-
-function _serializeEip4844(tx: Transaction, sig: null | Signature, blobs: null | Array<Blob>): string {
-    const fields: Array<any> = [
-        formatNumber(tx.chainId, "chainId"),
-        formatNumber(tx.nonce, "nonce"),
-        formatNumber(tx.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"),
-        formatNumber(tx.maxFeePerGas || 0, "maxFeePerGas"),
-        formatNumber(tx.gasLimit, "gasLimit"),
-        (tx.to || ZeroAddress),
-        formatNumber(tx.value, "value"),
-        tx.data,
-        formatAccessList(tx.accessList || [ ]),
-        formatNumber(tx.maxFeePerBlobGas || 0, "maxFeePerBlobGas"),
-        formatHashes(tx.blobVersionedHashes || [ ], "blobVersionedHashes")
-    ];
-
-    if (sig) {
-        fields.push(toBeArray(sig.r));
-        fields.push(toBeArray(sig.s));
-
-        // We have blobs; return the network wrapped format
-        if (blobs) {
-            return concat([
-                "0x03",
-                encodeRlp([
-                    fields,
-                    blobs.map((b) => b.data),
-                    blobs.map((b) => b.commitment),
-                    blobs.map((b) => b.proof),
-                ])
-            ]);
-        }
-
-    }
-
-    return concat([ "0x03", encodeRlp(fields)]);
-}
-
-function _parseEip7702(data: Uint8Array): TransactionLike {
-    const fields: any = decodeRlp(getBytes(data).slice(1));
-
-    assertArgument(Array.isArray(fields) && (fields.length === 10 || fields.length === 13),
-        "invalid field count for transaction type: 4", "data", hexlify(data));
-
-    const tx: TransactionLike = {
-        type:                  4,
-        chainId:               handleUint(fields[0], "chainId"),
-        nonce:                 handleNumber(fields[1], "nonce"),
-        maxPriorityFeePerGas:  handleUint(fields[2], "maxPriorityFeePerGas"),
-        maxFeePerGas:          handleUint(fields[3], "maxFeePerGas"),
-        gasPrice:              null,
-        gasLimit:              handleUint(fields[4], "gasLimit"),
-        to:                    handleAddress(fields[5]),
-        value:                 handleUint(fields[6], "value"),
-        data:                  hexlify(fields[7]),
-        accessList:            handleAccessList(fields[8], "accessList"),
-        authorizationList:     handleAuthorizationList(fields[9], "authorizationList"),
-    };
-
-    // Unsigned EIP-7702 Transaction
-    if (fields.length === 10) { return tx; }
-
-    _parseEipSignature(tx, fields.slice(10));
-
-    return tx;
-}
-
-function _serializeEip7702(tx: Transaction, sig: null | Signature): string {
-    const fields: Array<any> = [
-        formatNumber(tx.chainId, "chainId"),
-        formatNumber(tx.nonce, "nonce"),
-        formatNumber(tx.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"),
-        formatNumber(tx.maxFeePerGas || 0, "maxFeePerGas"),
-        formatNumber(tx.gasLimit, "gasLimit"),
-        (tx.to || "0x"),
-        formatNumber(tx.value, "value"),
-        tx.data,
-        formatAccessList(tx.accessList || [ ]),
-        formatAuthorizationList(tx.authorizationList || [ ])
-    ];
-
-    if (sig) {
-        fields.push(toBeArray(sig.r));
-        fields.push(toBeArray(sig.s));
-    }
-
-    return concat([ "0x04", encodeRlp(fields)]);
-}
-
-/**
- *  A **Transaction** describes an operation to be executed on
- *  Ethereum by an Externally Owned Account (EOA). It includes
- *  who (the [[to]] address), what (the [[data]]) and how much (the
- *  [[value]] in ether) the operation should entail.
- *
- *  @example:
- *    tx = new Transaction()
- *    //_result:
- *
- *    tx.data = "0x1234";
- *    //_result:
- */
-export class Transaction implements TransactionLike<string> {
-    #type: null | number;
-    #to: null | string;
-    #data: string;
-    #nonce: number;
-    #gasLimit: bigint;
-    #gasPrice: null | bigint;
-    #maxPriorityFeePerGas: null | bigint;
-    #maxFeePerGas: null | bigint;
-    #value: bigint;
-    #chainId: bigint;
-    #sig: null | Signature;
-    #accessList: null | AccessList;
-    #maxFeePerBlobGas: null | bigint;
-    #blobVersionedHashes: null | Array<string>;
-    #kzg: null | KzgLibrary;
-    #blobs: null | Array<Blob>;
-    #auths: null | Array<Authorization>;
-
-    /**
-     *  The transaction type.
-     *
-     *  If null, the type will be automatically inferred based on
-     *  explicit properties.
-     */
-    get type(): null | number { return this.#type; }
-    set type(value: null | number | string) {
-        switch (value) {
-            case null:
-                this.#type = null;
-                break;
-            case 0: case "legacy":
-                this.#type = 0;
-                break;
-            case 1: case "berlin": case "eip-2930":
-                this.#type = 1;
-                break;
-            case 2: case "london": case "eip-1559":
-                this.#type = 2;
-                break;
-            case 3: case "cancun": case "eip-4844":
-                this.#type = 3;
-                break;
-            case 4: case "pectra": case "eip-7702":
-                this.#type = 4;
-                break;
-            default:
-                assertArgument(false, "unsupported transaction type", "type", value);
-        }
-    }
-
-    /**
-     *  The name of the transaction type.
-     */
-    get typeName(): null | string {
-        switch (this.type) {
-            case 0: return "legacy";
-            case 1: return "eip-2930";
-            case 2: return "eip-1559";
-            case 3: return "eip-4844";
-            case 4: return "eip-7702";
-        }
-
-        return null;
-    }
-
-    /**
-     *  The ``to`` address for the transaction or ``null`` if the
-     *  transaction is an ``init`` transaction.
-     */
-    get to(): null | string {
-        const value = this.#to;
-        if (value == null && this.type === 3) { return ZeroAddress; }
-        return value;
-    }
-    set to(value: null | string) {
-        this.#to = (value == null) ? null: getAddress(value);
-    }
-
-    /**
-     *  The transaction nonce.
-     */
-    get nonce(): number { return this.#nonce; }
-    set nonce(value: BigNumberish) { this.#nonce = getNumber(value, "value"); }
-
-    /**
-     *  The gas limit.
-     */
-    get gasLimit(): bigint { return this.#gasLimit; }
-    set gasLimit(value: BigNumberish) { this.#gasLimit = getBigInt(value); }
-
-    /**
-     *  The gas price.
-     *
-     *  On legacy networks this defines the fee that will be paid. On
-     *  EIP-1559 networks, this should be ``null``.
-     */
-    get gasPrice(): null | bigint {
-        const value = this.#gasPrice;
-        if (value == null && (this.type === 0 || this.type === 1)) { return BN_0; }
-        return value;
-    }
-    set gasPrice(value: null | BigNumberish) {
-        this.#gasPrice = (value == null) ? null: getBigInt(value, "gasPrice");
-    }
-
-    /**
-     *  The maximum priority fee per unit of gas to pay. On legacy
-     *  networks this should be ``null``.
-     */
-    get maxPriorityFeePerGas(): null | bigint {
-        const value = this.#maxPriorityFeePerGas;
-        if (value == null) {
-            if (this.type === 2 || this.type === 3) { return BN_0; }
-            return null;
-        }
-        return value;
-    }
-    set maxPriorityFeePerGas(value: null | BigNumberish) {
-        this.#maxPriorityFeePerGas = (value == null) ? null: getBigInt(value, "maxPriorityFeePerGas");
-    }
-
-    /**
-     *  The maximum total fee per unit of gas to pay. On legacy
-     *  networks this should be ``null``.
-     */
-    get maxFeePerGas(): null | bigint {
-        const value = this.#maxFeePerGas;
-        if (value == null) {
-            if (this.type === 2 || this.type === 3) { return BN_0; }
-            return null;
-        }
-        return value;
-    }
-    set maxFeePerGas(value: null | BigNumberish) {
-        this.#maxFeePerGas = (value == null) ? null: getBigInt(value, "maxFeePerGas");
-    }
-
-    /**
-     *  The transaction data. For ``init`` transactions this is the
-     *  deployment code.
-     */
-    get data(): string { return this.#data; }
-    set data(value: BytesLike) { this.#data = hexlify(value); }
-
-    /**
-     *  The amount of ether (in wei) to send in this transactions.
-     */
-    get value(): bigint { return this.#value; }
-    set value(value: BigNumberish) {
-        this.#value = getBigInt(value, "value");
-    }
-
-    /**
-     *  The chain ID this transaction is valid on.
-     */
-    get chainId(): bigint { return this.#chainId; }
-    set chainId(value: BigNumberish) { this.#chainId = getBigInt(value); }
-
-    /**
-     *  If signed, the signature for this transaction.
-     */
-    get signature(): null | Signature { return this.#sig || null; }
-    set signature(value: null | SignatureLike) {
-        this.#sig = (value == null) ? null: Signature.from(value);
-    }
-
-    /**
-     *  The access list.
-     *
-     *  An access list permits discounted (but pre-paid) access to
-     *  bytecode and state variable access within contract execution.
-     */
-    get accessList(): null | AccessList {
-        const value = this.#accessList || null;
-        if (value == null) {
-            if (this.type === 1 || this.type === 2 || this.type === 3) {
-                // @TODO: in v7, this should assign the value or become
-                // a live object itself, otherwise mutation is inconsistent
-                return [ ];
-            }
-            return null;
-        }
-        return value;
-    }
-    set accessList(value: null | AccessListish) {
-        this.#accessList = (value == null) ? null: accessListify(value);
-    }
-
-    get authorizationList(): null | Array<Authorization> {
-        const value = this.#auths || null;
-        if (value == null) {
-            if (this.type === 4) {
-                // @TODO: in v7, this should become a live object itself,
-                // otherwise mutation is inconsistent
-                return [ ];
-            }
-        }
-        return value;
-    }
-    set authorizationList(auths: null | Array<AuthorizationLike>) {
-        this.#auths = (auths == null) ? null: auths.map((a) =>
-          authorizationify(a));
-    }
-
-    /**
-     *  The max fee per blob gas for Cancun transactions.
-     */
-    get maxFeePerBlobGas(): null | bigint {
-        const value = this.#maxFeePerBlobGas;
-        if (value == null && this.type === 3) { return BN_0; }
-        return value;
-    }
-    set maxFeePerBlobGas(value: null | BigNumberish) {
-        this.#maxFeePerBlobGas = (value == null) ? null: getBigInt(value, "maxFeePerBlobGas");
-    }
-
-    /**
-     *  The BLOb versioned hashes for Cancun transactions.
-     */
-    get blobVersionedHashes(): null | Array<string> {
-        // @TODO: Mutation is inconsistent; if unset, the returned value
-        // cannot mutate the object, if set it can
-        let value = this.#blobVersionedHashes;
-        if (value == null && this.type === 3) { return [ ]; }
-        return value;
-    }
-    set blobVersionedHashes(value: null | Array<string>) {
-        if (value != null) {
-            assertArgument(Array.isArray(value), "blobVersionedHashes must be an Array", "value", value);
-            value = value.slice();
-            for (let i = 0; i < value.length; i++) {
-                assertArgument(isHexString(value[i], 32), "invalid blobVersionedHash", `value[${ i }]`, value[i]);
-            }
-        }
-        this.#blobVersionedHashes = value;
-    }
-
-    /**
-     *  The BLObs for the Transaction, if any.
-     *
-     *  If ``blobs`` is non-``null``, then the [[seriailized]]
-     *  will return the network formatted sidecar, otherwise it
-     *  will return the standard [[link-eip-2718]] payload. The
-     *  [[unsignedSerialized]] is unaffected regardless.
-     *
-     *  When setting ``blobs``, either fully valid [[Blob]] objects
-     *  may be specified (i.e. correctly padded, with correct
-     *  committments and proofs) or a raw [[BytesLike]] may
-     *  be provided.
-     *
-     *  If raw [[BytesLike]] are provided, the [[kzg]] property **must**
-     *  be already set. The blob will be correctly padded and the
-     *  [[KzgLibrary]] will be used to compute the committment and
-     *  proof for the blob.
-     *
-     *  A BLOb is a sequence of field elements, each of which must
-     *  be within the BLS field modulo, so some additional processing
-     *  may be required to encode arbitrary data to ensure each 32 byte
-     *  field is within the valid range.
-     *
-     *  Setting this automatically populates [[blobVersionedHashes]],
-     *  overwriting any existing values. Setting this to ``null``
-     *  does **not** remove the [[blobVersionedHashes]], leaving them
-     *  present.
-     */
-    get blobs(): null | Array<Blob> {
-        if (this.#blobs == null) { return null; }
-        return this.#blobs.map((b) => Object.assign({ }, b));
-    }
-    set blobs(_blobs: null | Array<BlobLike>) {
-        if (_blobs == null) {
-            this.#blobs = null;
-            return;
-        }
-
-        const blobs: Array<Blob> = [ ];
-        const versionedHashes: Array<string> = [ ];
-        for (let i = 0; i < _blobs.length; i++) {
-            const blob = _blobs[i];
-
-            if (isBytesLike(blob)) {
-                assert(this.#kzg, "adding a raw blob requires a KZG library", "UNSUPPORTED_OPERATION", {
-                    operation: "set blobs()"
-                });
-
-                let data = getBytes(blob);
-                assertArgument(data.length <= BLOB_SIZE, "blob is too large", `blobs[${ i }]`, blob);
-
-                // Pad blob if necessary
-                if (data.length !== BLOB_SIZE) {
-                    const padded = new Uint8Array(BLOB_SIZE);
-                    padded.set(data);
-                    data = padded;
-                }
-
-                const commit = this.#kzg.blobToKzgCommitment(data);
-                const proof = hexlify(this.#kzg.computeBlobKzgProof(data, commit));
-
-                blobs.push({
-                    data: hexlify(data),
-                    commitment: hexlify(commit),
-                    proof
-                });
-                versionedHashes.push(getVersionedHash(1, commit));
-
-            } else {
-                const commit = hexlify(blob.commitment);
-                blobs.push({
-                    data: hexlify(blob.data),
-                    commitment: commit,
-                    proof: hexlify(blob.proof)
-                });
-                versionedHashes.push(getVersionedHash(1, commit));
-            }
-        }
-
-        this.#blobs = blobs;
-        this.#blobVersionedHashes = versionedHashes;
-    }
-
-    get kzg(): null | KzgLibrary { return this.#kzg; }
-    set kzg(kzg: null | KzgLibraryLike) {
-        if (kzg == null) {
-            this.#kzg = null;
-        } else {
-            this.#kzg = getKzgLibrary(kzg);
-        }
-    }
-
-    /**
-     *  Creates a new Transaction with default values.
-     */
-    constructor() {
-        this.#type = null;
-        this.#to = null;
-        this.#nonce = 0;
-        this.#gasLimit = BN_0;
-        this.#gasPrice = null;
-        this.#maxPriorityFeePerGas = null;
-        this.#maxFeePerGas = null;
-        this.#data = "0x";
-        this.#value = BN_0;
-        this.#chainId = BN_0;
-        this.#sig = null;
-        this.#accessList = null;
-        this.#maxFeePerBlobGas = null;
-        this.#blobVersionedHashes = null;
-        this.#kzg = null;
-        this.#blobs = null;
-        this.#auths = null;
-    }
-
-    /**
-     *  The transaction hash, if signed. Otherwise, ``null``.
-     */
-    get hash(): null | string {
-        if (this.signature == null) { return null; }
-        return keccak256(this.#getSerialized(true, false));
-    }
-
-    /**
-     *  The pre-image hash of this transaction.
-     *
-     *  This is the digest that a [[Signer]] must sign to authorize
-     *  this transaction.
-     */
-    get unsignedHash(): string {
-        return keccak256(this.unsignedSerialized);
-    }
-
-    /**
-     *  The sending address, if signed. Otherwise, ``null``.
-     */
-    get from(): null | string {
-        if (this.signature == null) { return null; }
-        return recoverAddress(this.unsignedHash, this.signature);
-    }
-
-    /**
-     *  The public key of the sender, if signed. Otherwise, ``null``.
-     */
-    get fromPublicKey(): null | string {
-        if (this.signature == null) { return null; }
-        return SigningKey.recoverPublicKey(this.unsignedHash, this.signature);
-    }
-
-    /**
-     *  Returns true if signed.
-     *
-     *  This provides a Type Guard that properties requiring a signed
-     *  transaction are non-null.
-     */
-    isSigned(): this is (Transaction & { type: number, typeName: string, from: string, signature: Signature }) {
-        return this.signature != null;
-    }
-
-    #getSerialized(signed: boolean, sidecar: boolean): string {
-        assert(!signed || this.signature != null, "cannot serialize unsigned transaction; maybe you meant .unsignedSerialized", "UNSUPPORTED_OPERATION", { operation: ".serialized"});
-
-        const sig = signed ? this.signature: null;
-        switch (this.inferType()) {
-            case 0:
-                return _serializeLegacy(this, sig);
-            case 1:
-                return _serializeEip2930(this, sig);
-            case 2:
-                return _serializeEip1559(this, sig);
-            case 3:
-                return _serializeEip4844(this, sig, sidecar ? this.blobs: null);
-            case 4:
-                return _serializeEip7702(this, sig);
-        }
-
-        assert(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: ".serialized" });
-    }
-
-    /**
-     *  The serialized transaction.
-     *
-     *  This throws if the transaction is unsigned. For the pre-image,
-     *  use [[unsignedSerialized]].
-     */
-    get serialized(): string {
-        return this.#getSerialized(true, true);
-    }
-
-    /**
-     *  The transaction pre-image.
-     *
-     *  The hash of this is the digest which needs to be signed to
-     *  authorize this transaction.
-     */
-    get unsignedSerialized(): string {
-        return this.#getSerialized(false, false);
-    }
-
-    /**
-     *  Return the most "likely" type; currently the highest
-     *  supported transaction type.
-     */
-    inferType(): number {
-        const types = this.inferTypes();
-
-        // Prefer London (EIP-1559) over Cancun (BLOb)
-        if (types.indexOf(2) >= 0) { return 2; }
-
-        // Return the highest inferred type
-        return <number>(types.pop());
-    }
-
-    /**
-     *  Validates the explicit properties and returns a list of compatible
-     *  transaction types.
-     */
-    inferTypes(): Array<number> {
-
-        // Checks that there are no conflicting properties set
-        const hasGasPrice = this.gasPrice != null;
-        const hasFee = (this.maxFeePerGas != null || this.maxPriorityFeePerGas != null);
-        const hasAccessList = (this.accessList != null);
-        const hasBlob = (this.#maxFeePerBlobGas != null || this.#blobVersionedHashes);
-
-        //if (hasGasPrice && hasFee) {
-        //    throw new Error("transaction cannot have gasPrice and maxFeePerGas");
-        //}
-
-        if (this.maxFeePerGas != null && this.maxPriorityFeePerGas != null) {
-            assert(this.maxFeePerGas >= this.maxPriorityFeePerGas, "priorityFee cannot be more than maxFee", "BAD_DATA", { value: this });
-        }
-
-        //if (this.type === 2 && hasGasPrice) {
-        //    throw new Error("eip-1559 transaction cannot have gasPrice");
-        //}
-
-        assert(!hasFee || (this.type !== 0 && this.type !== 1), "transaction type cannot have maxFeePerGas or maxPriorityFeePerGas", "BAD_DATA", { value: this });
-        assert(this.type !== 0 || !hasAccessList, "legacy transaction cannot have accessList", "BAD_DATA", { value: this })
-
-        const types: Array<number> = [ ];
-
-        // Explicit type
-        if (this.type != null) {
-            types.push(this.type);
-
-        } else {
-            if (this.authorizationList && this.authorizationList.length) {
-                types.push(4);
-            } else if (hasFee) {
-                types.push(2);
-            } else if (hasGasPrice) {
-                types.push(1);
-                if (!hasAccessList) { types.push(0); }
-            } else if (hasAccessList) {
-                types.push(1);
-                types.push(2);
-            } else if (hasBlob && this.to) {
-                types.push(3);
-            } else {
-                types.push(0);
-                types.push(1);
-                types.push(2);
-                types.push(3);
-            }
-        }
-
-        types.sort();
-
-        return types;
-    }
-
-    /**
-     *  Returns true if this transaction is a legacy transaction (i.e.
-     *  ``type === 0``).
-     *
-     *  This provides a Type Guard that the related properties are
-     *  non-null.
-     */
-    isLegacy(): this is (Transaction & { type: 0, gasPrice: bigint }) {
-        return (this.type === 0);
-    }
-
-    /**
-     *  Returns true if this transaction is berlin hardform transaction (i.e.
-     *  ``type === 1``).
-     *
-     *  This provides a Type Guard that the related properties are
-     *  non-null.
-     */
-    isBerlin(): this is (Transaction & { type: 1, gasPrice: bigint, accessList: AccessList }) {
-        return (this.type === 1);
-    }
-
-    /**
-     *  Returns true if this transaction is london hardform transaction (i.e.
-     *  ``type === 2``).
-     *
-     *  This provides a Type Guard that the related properties are
-     *  non-null.
-     */
-    isLondon(): this is (Transaction & { type: 2, accessList: AccessList, maxFeePerGas: bigint, maxPriorityFeePerGas: bigint }) {
-        return (this.type === 2);
-    }
-
-    /**
-     *  Returns true if this transaction is an [[link-eip-4844]] BLOB
-     *  transaction.
-     *
-     *  This provides a Type Guard that the related properties are
-     *  non-null.
-     */
-    isCancun(): this is (Transaction & { type: 3, to: string, accessList: AccessList, maxFeePerGas: bigint, maxPriorityFeePerGas: bigint, maxFeePerBlobGas: bigint, blobVersionedHashes: Array<string> }) {
-        return (this.type === 3);
-    }
-
-    /**
-     *  Create a copy of this transaciton.
-     */
-    clone(): Transaction {
-        return Transaction.from(this);
-    }
-
-    /**
-     *  Return a JSON-friendly object.
-     */
-    toJSON(): any {
-        const s = (v: null | bigint) => {
-            if (v == null) { return null; }
-            return v.toString();
-        };
-
-        return {
-            type: this.type,
-            to: this.to,
-//            from: this.from,
-            data: this.data,
-            nonce: this.nonce,
-            gasLimit: s(this.gasLimit),
-            gasPrice: s(this.gasPrice),
-            maxPriorityFeePerGas: s(this.maxPriorityFeePerGas),
-            maxFeePerGas: s(this.maxFeePerGas),
-            value: s(this.value),
-            chainId: s(this.chainId),
-            sig: this.signature ? this.signature.toJSON(): null,
-            accessList: this.accessList
-        };
-    }
-
-    /**
-     *  Create a **Transaction** from a serialized transaction or a
-     *  Transaction-like object.
-     */
-    static from(tx?: string | TransactionLike<string>): Transaction {
-        if (tx == null) { return new Transaction(); }
-
-        if (typeof(tx) === "string") {
-            const payload = getBytes(tx);
-
-            if (payload[0] >= 0x7f) { // @TODO: > vs >= ??
-                return Transaction.from(_parseLegacy(payload));
-            }
-
-            switch(payload[0]) {
-                case 1: return Transaction.from(_parseEip2930(payload));
-                case 2: return Transaction.from(_parseEip1559(payload));
-                case 3: return Transaction.from(_parseEip4844(payload));
-                case 4: return Transaction.from(_parseEip7702(payload));
-            }
-            assert(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: "from" });
-        }
-
-        const result = new Transaction();
-        if (tx.type != null) { result.type = tx.type; }
-        if (tx.to != null) { result.to = tx.to; }
-        if (tx.nonce != null) { result.nonce = tx.nonce; }
-        if (tx.gasLimit != null) { result.gasLimit = tx.gasLimit; }
-        if (tx.gasPrice != null) { result.gasPrice = tx.gasPrice; }
-        if (tx.maxPriorityFeePerGas != null) { result.maxPriorityFeePerGas = tx.maxPriorityFeePerGas; }
-        if (tx.maxFeePerGas != null) { result.maxFeePerGas = tx.maxFeePerGas; }
-        if (tx.maxFeePerBlobGas != null) { result.maxFeePerBlobGas = tx.maxFeePerBlobGas; }
-        if (tx.data != null) { result.data = tx.data; }
-        if (tx.value != null) { result.value = tx.value; }
-        if (tx.chainId != null) { result.chainId = tx.chainId; }
-        if (tx.signature != null) { result.signature = Signature.from(tx.signature); }
-        if (tx.accessList != null) { result.accessList = tx.accessList; }
-        if (tx.authorizationList != null) {
-            result.authorizationList = tx.authorizationList;
-        }
-
-        // This will get overwritten by blobs, if present
-        if (tx.blobVersionedHashes != null) { result.blobVersionedHashes = tx.blobVersionedHashes; }
-
-        // Make sure we assign the kzg before assigning blobs, which
-        // require the library in the event raw blob data is provided.
-        if (tx.kzg != null) { result.kzg = tx.kzg; }
-        if (tx.blobs != null) { result.blobs = tx.blobs; }
-
-        if (tx.hash != null) {
-            assertArgument(result.isSigned(), "unsigned transaction cannot define '.hash'", "tx", tx);
-            assertArgument(result.hash === tx.hash, "hash mismatch", "tx", tx);
-        }
-
-        if (tx.from != null) {
-            assertArgument(result.isSigned(), "unsigned transaction cannot define '.from'", "tx", tx);
-            assertArgument(result.from.toLowerCase() === (tx.from || "").toLowerCase(), "from mismatch", "tx", tx);
-        }
-
-        return result;
-    }
-}