@rocketh/signer 0.10.5 → 0.10.6

package/dist/index.mjs

@@ -2756,7 +2756,7 @@ function checksum(len, fn) {
 // -----------
 const genBase58 = (abc) => chain(radix(58), alphabet(abc), join(''));
 const base58 = /* @__PURE__ */ genBase58('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
-const createBase58check =  (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);
+const createBase58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);
 // legacy export, bad name
 const base58check$1 = createBase58check;
 
@@ -3096,7 +3096,7 @@ function mnemonicToSeedSync(mnemonic, passphrase = '') {
     return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
 }
 
-const version = '2.9.16';
+const version = '2.16.2';
 
 const getVersion = () => `viem@${version}`;
 
@@ -3153,7 +3153,7 @@ class BaseError extends Error {
             ...(args.metaMessages ? [...args.metaMessages, ''] : []),
             ...(docsPath
                 ? [
-                    `Docs: https://viem.sh${docsPath}${args.docsSlug ? `#${args.docsSlug}` : ''}`,
+                    `Docs: ${args.docsBaseUrl ?? 'https://viem.sh'}${docsPath}${args.docsSlug ? `#${args.docsSlug}` : ''}`,
                 ]
                 : []),
             ...(details ? [`Details: ${details}`] : []),
@@ -3950,12 +3950,24 @@ function keccak256(value, to_) {
     return toHex(bytes);
 }
 
-function checksumAddress(address_, chainId) {
-    const hexAddress = chainId
-        ? `${chainId}${address_.toLowerCase()}`
-        : address_.substring(2).toLowerCase();
+const checksumAddressCache = /*#__PURE__*/ new LruMap(8192);
+function checksumAddress(address_, 
+/**
+ * Warning: EIP-1191 checksum addresses are generally not backwards compatible with the
+ * wider Ethereum ecosystem, meaning it will break when validated against an application/tool
+ * that relies on EIP-55 checksum encoding (checksum without chainId).
+ *
+ * It is highly recommended to not use this feature unless you
+ * know what you are doing.
+ *
+ * See more: https://github.com/ethereum/EIPs/issues/1121
+ */
+chainId) {
+    if (checksumAddressCache.has(`${address_}.${chainId}`))
+        return checksumAddressCache.get(`${address_}.${chainId}`);
+    const hexAddress = address_.substring(2).toLowerCase();
     const hash = keccak256(stringToBytes(hexAddress), 'bytes');
-    const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split('');
+    const address = (hexAddress).split('');
     for (let i = 0; i < 40; i += 2) {
         if (hash[i >> 1] >> 4 >= 8 && address[i]) {
             address[i] = address[i].toUpperCase();
@@ -3964,15 +3976,19 @@ function checksumAddress(address_, chainId) {
             address[i + 1] = address[i + 1].toUpperCase();
         }
     }
-    return `0x${address.join('')}`;
+    const result = `0x${address.join('')}`;
+    checksumAddressCache.set(`${address_}.${chainId}`, result);
+    return result;
 }
 
 const addressRegex = /^0x[a-fA-F0-9]{40}$/;
+/** @internal */
 const isAddressCache = /*#__PURE__*/ new LruMap(8192);
 function isAddress(address, options) {
     const { strict = true } = options ?? {};
-    if (isAddressCache.has(address))
-        return isAddressCache.get(address);
+    const cacheKey = `${address}.${strict}`;
+    if (isAddressCache.has(cacheKey))
+        return isAddressCache.get(cacheKey);
     const result = (() => {
         if (!addressRegex.test(address))
             return false;
@@ -3982,7 +3998,7 @@ function isAddress(address, options) {
             return checksumAddress(address) === address;
         return true;
     })();
-    isAddressCache.set(address, result);
+    isAddressCache.set(cacheKey, result);
     return result;
 }
 
@@ -4004,6 +4020,7 @@ function toAccount(source) {
         throw new InvalidAddressError({ address: source.address });
     return {
         address: source.address,
+        nonceManager: source.nonceManager,
         signMessage: source.signMessage,
         signTransaction: source.signTransaction,
         signTypedData: source.signTypedData,
@@ -4048,16 +4065,20 @@ function concatHex(values) {
     return `0x${values.reduce((acc, x) => acc + x.replace('0x', ''), '')}`;
 }
 
-function hashMessage(message, to_) {
-    const messageBytes = (() => {
-        if (typeof message === 'string')
-            return stringToBytes(message);
-        if (message.raw instanceof Uint8Array)
-            return message.raw;
-        return toBytes(message.raw);
+function toPrefixedMessage(message_) {
+    const message = (() => {
+        if (typeof message_ === 'string')
+            return stringToHex(message_);
+        if (typeof message_.raw === 'string')
+            return message_.raw;
+        return bytesToHex(message_.raw);
     })();
-    const prefixBytes = stringToBytes(`${presignMessagePrefix}${messageBytes.length}`);
-    return keccak256(concat([prefixBytes, messageBytes]), to_);
+    const prefix = stringToHex(`${presignMessagePrefix}${size(message)}`);
+    return concat([prefix, message]);
+}
+
+function hashMessage(message, to_) {
+    return keccak256(toPrefixedMessage(message), to_);
 }
 
 /**
@@ -4067,22 +4088,22 @@ function hashMessage(message, to_) {
  * @returns The signature in hex format.
  *
  * @example
- * signatureToHex({
+ * serializeSignature({
  *   r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',
  *   s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
  *   yParity: 1
  * })
  * // "0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c"
  */
-function signatureToHex({ r, s, v, yParity }) {
-    const vHex = (() => {
-        if (v === 27n || yParity === 0)
-            return '1b';
-        if (v === 28n || yParity === 1)
-            return '1c';
-        throw new Error('Invalid v value');
+function serializeSignature({ r, s, v, yParity }) {
+    const yParity_ = (() => {
+        if (yParity === 0 || yParity === 1)
+            return yParity;
+        if (v && (v === 27n || v === 28n || v >= 35n))
+            return v % 2n === 0n ? 1 : 0;
+        throw new Error('Invalid `v` or `yParity` value');
     })();
-    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${vHex}`;
+    return `0x${new secp256k1.Signature(hexToBigInt(r), hexToBigInt(s)).toCompactHex()}${yParity_ === 0 ? '1b' : '1c'}`;
 }
 
 // TODO(v3): Convert to sync.
@@ -4112,7 +4133,7 @@ async function sign({ hash, privateKey, }) {
  */
 async function signMessage({ message, privateKey, }) {
     const signature = await sign({ hash: hashMessage(message), privateKey });
-    return signatureToHex(signature);
+    return serializeSignature(signature);
 }
 
 const gweiUnits = {
@@ -4284,11 +4305,8 @@ function blobsToProofs(parameters) {
 }
 
 function sha256(value, to_) {
-    const to = to_ || 'hex';
     const bytes = sha256$1(isHex(value, { strict: false }) ? toBytes(value) : value);
-    if (to === 'bytes')
-        return bytes;
-    return toHex(bytes);
+    return bytes;
 }
 
 /**
@@ -4311,7 +4329,7 @@ function sha256(value, to_) {
 function commitmentToVersionedHash(parameters) {
     const { commitment, version = 1 } = parameters;
     const to = parameters.to ?? (typeof commitment === 'string' ? 'hex' : 'bytes');
-    const versionedHash = sha256(commitment, 'bytes');
+    const versionedHash = sha256(commitment);
     versionedHash.set([version], 0);
     return (to === 'bytes' ? versionedHash : bytesToHex(versionedHash));
 }
@@ -4364,7 +4382,6 @@ const maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction -
     1 * fieldElementsPerBlob * blobsPerTransaction;
 
 // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-4844.md#parameters
-/** The number of bytes in a KZG commitment. */
 const versionedHashVersionKzg = 1;
 
 class BlobSizeTooLargeError extends BaseError {
@@ -4461,7 +4478,7 @@ const staticCursor = {
     position: 0,
     positionReadCount: new Map(),
     recursiveReadCount: 0,
-    recursiveReadLimit: Infinity,
+    recursiveReadLimit: Number.POSITIVE_INFINITY,
     assertReadLimit() {
         if (this.recursiveReadCount >= this.recursiveReadLimit)
             throw new RecursiveReadLimitExceededError({
@@ -4607,7 +4624,7 @@ const staticCursor = {
         return () => (this.position = oldPosition);
     },
     _touch() {
-        if (this.recursiveReadLimit === Infinity)
+        if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
             return;
         const count = this.getReadCount();
         this.positionReadCount.set(this.position, count + 1);
@@ -4718,83 +4735,153 @@ function toBlobSidecars(parameters) {
     return sidecars;
 }
 
-class AbiEncodingArrayLengthMismatchError extends BaseError {
-    constructor({ expectedLength, givenLength, type, }) {
-        super([
-            `ABI encoding array length mismatch for type ${type}.`,
-            `Expected length: ${expectedLength}`,
-            `Given length: ${givenLength}`,
-        ].join('\n'));
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'AbiEncodingArrayLengthMismatchError'
-        });
-    }
+function toRlp(bytes, to = 'hex') {
+    const encodable = getEncodable(bytes);
+    const cursor = createCursor(new Uint8Array(encodable.length));
+    encodable.encode(cursor);
+    if (to === 'hex')
+        return bytesToHex(cursor.bytes);
+    return cursor.bytes;
 }
-class AbiEncodingBytesSizeMismatchError extends BaseError {
-    constructor({ expectedSize, value }) {
-        super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'AbiEncodingBytesSizeMismatchError'
-        });
-    }
+function getEncodable(bytes) {
+    if (Array.isArray(bytes))
+        return getEncodableList(bytes.map((x) => getEncodable(x)));
+    return getEncodableBytes(bytes);
 }
-class AbiEncodingLengthMismatchError extends BaseError {
-    constructor({ expectedLength, givenLength, }) {
-        super([
-            'ABI encoding params/values length mismatch.',
-            `Expected length (params): ${expectedLength}`,
-            `Given length (values): ${givenLength}`,
-        ].join('\n'));
+function getEncodableList(list) {
+    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
+    const sizeOfBodyLength = getSizeOfLength(bodyLength);
+    const length = (() => {
+        if (bodyLength <= 55)
+            return 1 + bodyLength;
+        return 1 + sizeOfBodyLength + bodyLength;
+    })();
+    return {
+        length,
+        encode(cursor) {
+            if (bodyLength <= 55) {
+                cursor.pushByte(0xc0 + bodyLength);
+            }
+            else {
+                cursor.pushByte(0xc0 + 55 + sizeOfBodyLength);
+                if (sizeOfBodyLength === 1)
+                    cursor.pushUint8(bodyLength);
+                else if (sizeOfBodyLength === 2)
+                    cursor.pushUint16(bodyLength);
+                else if (sizeOfBodyLength === 3)
+                    cursor.pushUint24(bodyLength);
+                else
+                    cursor.pushUint32(bodyLength);
+            }
+            for (const { encode } of list) {
+                encode(cursor);
+            }
+        },
+    };
+}
+function getEncodableBytes(bytesOrHex) {
+    const bytes = typeof bytesOrHex === 'string' ? hexToBytes(bytesOrHex) : bytesOrHex;
+    const sizeOfBytesLength = getSizeOfLength(bytes.length);
+    const length = (() => {
+        if (bytes.length === 1 && bytes[0] < 0x80)
+            return 1;
+        if (bytes.length <= 55)
+            return 1 + bytes.length;
+        return 1 + sizeOfBytesLength + bytes.length;
+    })();
+    return {
+        length,
+        encode(cursor) {
+            if (bytes.length === 1 && bytes[0] < 0x80) {
+                cursor.pushBytes(bytes);
+            }
+            else if (bytes.length <= 55) {
+                cursor.pushByte(0x80 + bytes.length);
+                cursor.pushBytes(bytes);
+            }
+            else {
+                cursor.pushByte(0x80 + 55 + sizeOfBytesLength);
+                if (sizeOfBytesLength === 1)
+                    cursor.pushUint8(bytes.length);
+                else if (sizeOfBytesLength === 2)
+                    cursor.pushUint16(bytes.length);
+                else if (sizeOfBytesLength === 3)
+                    cursor.pushUint24(bytes.length);
+                else
+                    cursor.pushUint32(bytes.length);
+                cursor.pushBytes(bytes);
+            }
+        },
+    };
+}
+function getSizeOfLength(length) {
+    if (length < 2 ** 8)
+        return 1;
+    if (length < 2 ** 16)
+        return 2;
+    if (length < 2 ** 24)
+        return 3;
+    if (length < 2 ** 32)
+        return 4;
+    throw new BaseError('Length is too large.');
+}
+
+class InvalidChainIdError extends BaseError {
+    constructor({ chainId }) {
+        super(typeof chainId === 'number'
+            ? `Chain ID "${chainId}" is invalid.`
+            : 'Chain ID is invalid.');
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'AbiEncodingLengthMismatchError'
+            value: 'InvalidChainIdError'
         });
     }
 }
-class BytesSizeMismatchError extends BaseError {
-    constructor({ expectedSize, givenSize, }) {
-        super(`Expected bytes${expectedSize}, got bytes${givenSize}.`);
+
+class FeeCapTooHighError extends BaseError {
+    constructor({ cause, maxFeePerGas, } = {}) {
+        super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ''}) cannot be higher than the maximum allowed value (2^256-1).`, {
+            cause,
+        });
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'BytesSizeMismatchError'
+            value: 'FeeCapTooHigh'
         });
     }
 }
-class InvalidAbiEncodingTypeError extends BaseError {
-    constructor(type, { docsPath }) {
+Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
+});
+class TipAboveFeeCapError extends BaseError {
+    constructor({ cause, maxPriorityFeePerGas, maxFeePerGas, } = {}) {
         super([
-            `Type "${type}" is not a valid encoding type.`,
-            'Please provide a valid ABI type.',
-        ].join('\n'), { docsPath });
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'InvalidAbiEncodingType'
+            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas
+                ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei`
+                : ''}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ''}).`,
+        ].join('\n'), {
+            cause,
         });
-    }
-}
-class InvalidArrayError extends BaseError {
-    constructor(value) {
-        super([`Value "${value}" is not a valid array.`].join('\n'));
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'InvalidArrayError'
+            value: 'TipAboveFeeCapError'
         });
     }
 }
+Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
+});
 
 /**
  * @description Returns a section of the hex or byte array given a start/end bytes offset.
@@ -4862,876 +4949,807 @@ function sliceHex(value_, start, end, { strict } = {}) {
     return value;
 }
 
-/**
- * @description Encodes a list of primitive values into an ABI-encoded hex value.
- *
- * - Docs: https://viem.sh/docs/abi/encodeAbiParameters#encodeabiparameters
- *
- *   Generates ABI encoded data using the [ABI specification](https://docs.soliditylang.org/en/latest/abi-spec), given a set of ABI parameters (inputs/outputs) and their corresponding values.
- *
- * @param params - a set of ABI Parameters (params), that can be in the shape of the inputs or outputs attribute of an ABI Item.
- * @param values - a set of values (values) that correspond to the given params.
- * @example
- * ```typescript
- * import { encodeAbiParameters } from 'viem'
- *
- * const encodedData = encodeAbiParameters(
- *   [
- *     { name: 'x', type: 'string' },
- *     { name: 'y', type: 'uint' },
- *     { name: 'z', type: 'bool' }
- *   ],
- *   ['wagmi', 420n, true]
- * )
- * ```
- *
- * You can also pass in Human Readable parameters with the parseAbiParameters utility.
- *
- * @example
- * ```typescript
- * import { encodeAbiParameters, parseAbiParameters } from 'viem'
- *
- * const encodedData = encodeAbiParameters(
- *   parseAbiParameters('string x, uint y, bool z'),
- *   ['wagmi', 420n, true]
- * )
- * ```
- */
-function encodeAbiParameters(params, values) {
-    if (params.length !== values.length)
-        throw new AbiEncodingLengthMismatchError({
-            expectedLength: params.length,
-            givenLength: values.length,
-        });
-    // Prepare the parameters to determine dynamic types to encode.
-    const preparedParams = prepareParams({
-        params: params,
-        values: values,
-    });
-    const data = encodeParams(preparedParams);
-    if (data.length === 0)
-        return '0x';
-    return data;
-}
-function prepareParams({ params, values, }) {
-    const preparedParams = [];
-    for (let i = 0; i < params.length; i++) {
-        preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
-    }
-    return preparedParams;
-}
-function prepareParam({ param, value, }) {
-    const arrayComponents = getArrayComponents(param.type);
-    if (arrayComponents) {
-        const [length, type] = arrayComponents;
-        return encodeArray(value, { length, param: { ...param, type } });
-    }
-    if (param.type === 'tuple') {
-        return encodeTuple(value, {
-            param: param,
-        });
-    }
-    if (param.type === 'address') {
-        return encodeAddress(value);
-    }
-    if (param.type === 'bool') {
-        return encodeBool(value);
-    }
-    if (param.type.startsWith('uint') || param.type.startsWith('int')) {
-        const signed = param.type.startsWith('int');
-        return encodeNumber(value, { signed });
+function assertTransactionEIP4844(transaction) {
+    const { blobVersionedHashes } = transaction;
+    if (blobVersionedHashes) {
+        if (blobVersionedHashes.length === 0)
+            throw new EmptyBlobError();
+        for (const hash of blobVersionedHashes) {
+            const size_ = size(hash);
+            const version = hexToNumber(slice(hash, 0, 1));
+            if (size_ !== 32)
+                throw new InvalidVersionedHashSizeError({ hash, size: size_ });
+            if (version !== versionedHashVersionKzg)
+                throw new InvalidVersionedHashVersionError({
+                    hash,
+                    version,
+                });
+        }
     }
-    if (param.type.startsWith('bytes')) {
-        return encodeBytes(value, { param });
+    assertTransactionEIP1559(transaction);
+}
+function assertTransactionEIP1559(transaction) {
+    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
+    if (chainId <= 0)
+        throw new InvalidChainIdError({ chainId });
+    if (to && !isAddress(to))
+        throw new InvalidAddressError({ address: to });
+    if (maxFeePerGas && maxFeePerGas > 2n ** 256n - 1n)
+        throw new FeeCapTooHighError({ maxFeePerGas });
+    if (maxPriorityFeePerGas &&
+        maxFeePerGas &&
+        maxPriorityFeePerGas > maxFeePerGas)
+        throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
+}
+function assertTransactionEIP2930(transaction) {
+    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
+    if (chainId <= 0)
+        throw new InvalidChainIdError({ chainId });
+    if (to && !isAddress(to))
+        throw new InvalidAddressError({ address: to });
+    if (maxPriorityFeePerGas || maxFeePerGas)
+        throw new BaseError('`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.');
+    if (gasPrice && gasPrice > 2n ** 256n - 1n)
+        throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
+}
+function assertTransactionLegacy(transaction) {
+    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, accessList, } = transaction;
+    if (to && !isAddress(to))
+        throw new InvalidAddressError({ address: to });
+    if (typeof chainId !== 'undefined' && chainId <= 0)
+        throw new InvalidChainIdError({ chainId });
+    if (maxPriorityFeePerGas || maxFeePerGas)
+        throw new BaseError('`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.');
+    if (gasPrice && gasPrice > 2n ** 256n - 1n)
+        throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
+    if (accessList)
+        throw new BaseError('`accessList` is not a valid Legacy Transaction attribute.');
+}
+
+function getTransactionType(transaction) {
+    if (transaction.type)
+        return transaction.type;
+    if (typeof transaction.blobs !== 'undefined' ||
+        typeof transaction.blobVersionedHashes !== 'undefined' ||
+        typeof transaction.maxFeePerBlobGas !== 'undefined' ||
+        typeof transaction.sidecars !== 'undefined')
+        return 'eip4844';
+    if (typeof transaction.maxFeePerGas !== 'undefined' ||
+        typeof transaction.maxPriorityFeePerGas !== 'undefined') {
+        return 'eip1559';
     }
-    if (param.type === 'string') {
-        return encodeString(value);
+    if (typeof transaction.gasPrice !== 'undefined') {
+        if (typeof transaction.accessList !== 'undefined')
+            return 'eip2930';
+        return 'legacy';
     }
-    throw new InvalidAbiEncodingTypeError(param.type, {
-        docsPath: '/docs/contract/encodeAbiParameters',
-    });
+    throw new InvalidSerializableTransactionError({ transaction });
 }
-function encodeParams(preparedParams) {
-    // 1. Compute the size of the static part of the parameters.
-    let staticSize = 0;
-    for (let i = 0; i < preparedParams.length; i++) {
-        const { dynamic, encoded } = preparedParams[i];
-        if (dynamic)
-            staticSize += 32;
-        else
-            staticSize += size(encoded);
-    }
-    // 2. Split the parameters into static and dynamic parts.
-    const staticParams = [];
-    const dynamicParams = [];
-    let dynamicSize = 0;
-    for (let i = 0; i < preparedParams.length; i++) {
-        const { dynamic, encoded } = preparedParams[i];
-        if (dynamic) {
-            staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
-            dynamicParams.push(encoded);
-            dynamicSize += size(encoded);
+
+/*
+ * Serialize an  EIP-2930 access list
+ * @remarks
+ * Use to create a transaction serializer with support for EIP-2930 access lists
+ *
+ * @param accessList - Array of objects of address and arrays of Storage Keys
+ * @throws InvalidAddressError, InvalidStorageKeySizeError
+ * @returns Array of hex strings
+ */
+function serializeAccessList(accessList) {
+    if (!accessList || accessList.length === 0)
+        return [];
+    const serializedAccessList = [];
+    for (let i = 0; i < accessList.length; i++) {
+        const { address, storageKeys } = accessList[i];
+        for (let j = 0; j < storageKeys.length; j++) {
+            if (storageKeys[j].length - 2 !== 64) {
+                throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
+            }
         }
-        else {
-            staticParams.push(encoded);
+        if (!isAddress(address, { strict: false })) {
+            throw new InvalidAddressError({ address });
         }
+        serializedAccessList.push([address, storageKeys]);
     }
-    // 3. Concatenate static and dynamic parts.
-    return concat([...staticParams, ...dynamicParams]);
+    return serializedAccessList;
 }
-function encodeAddress(value) {
-    if (!isAddress(value))
-        throw new InvalidAddressError({ address: value });
-    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+
+function serializeTransaction(transaction, signature) {
+    const type = getTransactionType(transaction);
+    if (type === 'eip1559')
+        return serializeTransactionEIP1559(transaction, signature);
+    if (type === 'eip2930')
+        return serializeTransactionEIP2930(transaction, signature);
+    if (type === 'eip4844')
+        return serializeTransactionEIP4844(transaction, signature);
+    return serializeTransactionLegacy(transaction, signature);
 }
-function encodeArray(value, { length, param, }) {
-    const dynamic = length === null;
-    if (!Array.isArray(value))
-        throw new InvalidArrayError(value);
-    if (!dynamic && value.length !== length)
-        throw new AbiEncodingArrayLengthMismatchError({
-            expectedLength: length,
-            givenLength: value.length,
-            type: `${param.type}[${length}]`,
+function serializeTransactionEIP4844(transaction, signature) {
+    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data, } = transaction;
+    assertTransactionEIP4844(transaction);
+    let blobVersionedHashes = transaction.blobVersionedHashes;
+    let sidecars = transaction.sidecars;
+    // If `blobs` are passed, we will need to compute the KZG commitments & proofs.
+    if (transaction.blobs &&
+        (typeof blobVersionedHashes === 'undefined' ||
+            typeof sidecars === 'undefined')) {
+        const blobs = (typeof transaction.blobs[0] === 'string'
+            ? transaction.blobs
+            : transaction.blobs.map((x) => bytesToHex(x)));
+        const kzg = transaction.kzg;
+        const commitments = blobsToCommitments({
+            blobs,
+            kzg,
         });
-    let dynamicChild = false;
-    const preparedParams = [];
-    for (let i = 0; i < value.length; i++) {
-        const preparedParam = prepareParam({ param, value: value[i] });
-        if (preparedParam.dynamic)
-            dynamicChild = true;
-        preparedParams.push(preparedParam);
-    }
-    if (dynamic || dynamicChild) {
-        const data = encodeParams(preparedParams);
-        if (dynamic) {
-            const length = numberToHex(preparedParams.length, { size: 32 });
-            return {
-                dynamic: true,
-                encoded: preparedParams.length > 0 ? concat([length, data]) : length,
-            };
+        if (typeof blobVersionedHashes === 'undefined')
+            blobVersionedHashes = commitmentsToVersionedHashes({
+                commitments,
+            });
+        if (typeof sidecars === 'undefined') {
+            const proofs = blobsToProofs({ blobs, commitments, kzg });
+            sidecars = toBlobSidecars({ blobs, commitments, proofs });
         }
-        if (dynamicChild)
-            return { dynamic: true, encoded: data };
     }
-    return {
-        dynamic: false,
-        encoded: concat(preparedParams.map(({ encoded }) => encoded)),
-    };
+    const serializedAccessList = serializeAccessList(accessList);
+    const serializedTransaction = [
+        toHex(chainId),
+        nonce ? toHex(nonce) : '0x',
+        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
+        maxFeePerGas ? toHex(maxFeePerGas) : '0x',
+        gas ? toHex(gas) : '0x',
+        to ?? '0x',
+        value ? toHex(value) : '0x',
+        data ?? '0x',
+        serializedAccessList,
+        maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : '0x',
+        blobVersionedHashes ?? [],
+        ...toYParitySignatureArray(transaction, signature),
+    ];
+    const blobs = [];
+    const commitments = [];
+    const proofs = [];
+    if (sidecars)
+        for (let i = 0; i < sidecars.length; i++) {
+            const { blob, commitment, proof } = sidecars[i];
+            blobs.push(blob);
+            commitments.push(commitment);
+            proofs.push(proof);
+        }
+    return concatHex([
+        '0x03',
+        sidecars
+            ? // If sidecars are enabled, envelope turns into a "wrapper":
+                toRlp([serializedTransaction, blobs, commitments, proofs])
+            : // If sidecars are disabled, standard envelope is used:
+                toRlp(serializedTransaction),
+    ]);
 }
-function encodeBytes(value, { param }) {
-    const [, paramSize] = param.type.split('bytes');
-    const bytesSize = size(value);
-    if (!paramSize) {
-        let value_ = value;
-        // If the size is not divisible by 32 bytes, pad the end
-        // with empty bytes to the ceiling 32 bytes.
-        if (bytesSize % 32 !== 0)
-            value_ = padHex(value_, {
-                dir: 'right',
-                size: Math.ceil((value.length - 2) / 2 / 32) * 32,
-            });
-        return {
-            dynamic: true,
-            encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_]),
-        };
-    }
-    if (bytesSize !== parseInt(paramSize))
-        throw new AbiEncodingBytesSizeMismatchError({
-            expectedSize: parseInt(paramSize),
-            value,
-        });
-    return { dynamic: false, encoded: padHex(value, { dir: 'right' }) };
-}
-function encodeBool(value) {
-    if (typeof value !== 'boolean')
-        throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
-    return { dynamic: false, encoded: padHex(boolToHex(value)) };
+function serializeTransactionEIP1559(transaction, signature) {
+    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data, } = transaction;
+    assertTransactionEIP1559(transaction);
+    const serializedAccessList = serializeAccessList(accessList);
+    const serializedTransaction = [
+        toHex(chainId),
+        nonce ? toHex(nonce) : '0x',
+        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
+        maxFeePerGas ? toHex(maxFeePerGas) : '0x',
+        gas ? toHex(gas) : '0x',
+        to ?? '0x',
+        value ? toHex(value) : '0x',
+        data ?? '0x',
+        serializedAccessList,
+        ...toYParitySignatureArray(transaction, signature),
+    ];
+    return concatHex([
+        '0x02',
+        toRlp(serializedTransaction),
+    ]);
 }
-function encodeNumber(value, { signed }) {
-    return {
-        dynamic: false,
-        encoded: numberToHex(value, {
-            size: 32,
-            signed,
-        }),
-    };
+function serializeTransactionEIP2930(transaction, signature) {
+    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
+    assertTransactionEIP2930(transaction);
+    const serializedAccessList = serializeAccessList(accessList);
+    const serializedTransaction = [
+        toHex(chainId),
+        nonce ? toHex(nonce) : '0x',
+        gasPrice ? toHex(gasPrice) : '0x',
+        gas ? toHex(gas) : '0x',
+        to ?? '0x',
+        value ? toHex(value) : '0x',
+        data ?? '0x',
+        serializedAccessList,
+        ...toYParitySignatureArray(transaction, signature),
+    ];
+    return concatHex([
+        '0x01',
+        toRlp(serializedTransaction),
+    ]);
 }
-function encodeString(value) {
-    const hexValue = stringToHex(value);
-    const partsLength = Math.ceil(size(hexValue) / 32);
-    const parts = [];
-    for (let i = 0; i < partsLength; i++) {
-        parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
-            dir: 'right',
-        }));
+function serializeTransactionLegacy(transaction, signature) {
+    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
+    assertTransactionLegacy(transaction);
+    let serializedTransaction = [
+        nonce ? toHex(nonce) : '0x',
+        gasPrice ? toHex(gasPrice) : '0x',
+        gas ? toHex(gas) : '0x',
+        to ?? '0x',
+        value ? toHex(value) : '0x',
+        data ?? '0x',
+    ];
+    if (signature) {
+        const v = (() => {
+            // EIP-155 (inferred chainId)
+            if (signature.v >= 35n) {
+                const inferredChainId = (signature.v - 35n) / 2n;
+                if (inferredChainId > 0)
+                    return signature.v;
+                return 27n + (signature.v === 35n ? 0n : 1n);
+            }
+            // EIP-155 (explicit chainId)
+            if (chainId > 0)
+                return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
+            // Pre-EIP-155 (no chainId)
+            const v = 27n + (signature.v === 27n ? 0n : 1n);
+            if (signature.v !== v)
+                throw new InvalidLegacyVError({ v: signature.v });
+            return v;
+        })();
+        serializedTransaction = [
+            ...serializedTransaction,
+            toHex(v),
+            signature.r,
+            signature.s,
+        ];
     }
-    return {
-        dynamic: true,
-        encoded: concat([
-            padHex(numberToHex(size(hexValue), { size: 32 })),
-            ...parts,
-        ]),
-    };
-}
-function encodeTuple(value, { param }) {
-    let dynamic = false;
-    const preparedParams = [];
-    for (let i = 0; i < param.components.length; i++) {
-        const param_ = param.components[i];
-        const index = Array.isArray(value) ? i : param_.name;
-        const preparedParam = prepareParam({
-            param: param_,
-            value: value[index],
-        });
-        preparedParams.push(preparedParam);
-        if (preparedParam.dynamic)
-            dynamic = true;
+    else if (chainId > 0) {
+        serializedTransaction = [
+            ...serializedTransaction,
+            toHex(chainId),
+            '0x',
+            '0x',
+        ];
     }
-    return {
-        dynamic,
-        encoded: dynamic
-            ? encodeParams(preparedParams)
-            : concat(preparedParams.map(({ encoded }) => encoded)),
-    };
+    return toRlp(serializedTransaction);
 }
-function getArrayComponents(type) {
-    const matches = type.match(/^(.*)\[(\d+)?\]$/);
-    return matches
-        ? // Return `null` if the array is dynamic.
-            [matches[2] ? Number(matches[2]) : null, matches[1]]
-        : undefined;
+function toYParitySignatureArray(transaction, signature_) {
+    const signature = signature_ ?? transaction;
+    const { v, yParity } = signature;
+    if (typeof signature.r === 'undefined')
+        return [];
+    if (typeof signature.s === 'undefined')
+        return [];
+    if (typeof v === 'undefined' && typeof yParity === 'undefined')
+        return [];
+    const r = trim(signature.r);
+    const s = trim(signature.s);
+    const yParity_ = (() => {
+        if (typeof yParity === 'number')
+            return yParity ? toHex(1) : '0x';
+        if (v === 0n)
+            return '0x';
+        if (v === 1n)
+            return toHex(1);
+        return v === 27n ? '0x' : toHex(1);
+    })();
+    return [yParity_, r === '0x00' ? '0x' : r, s === '0x00' ? '0x' : s];
 }
 
-class FeeCapTooHighError extends BaseError {
-    constructor({ cause, maxFeePerGas, } = {}) {
-        super(`The fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ''}) cannot be higher than the maximum allowed value (2^256-1).`, {
-            cause,
-        });
+async function signTransaction(parameters) {
+    const { privateKey, transaction, serializer = serializeTransaction, } = parameters;
+    const signableTransaction = (() => {
+        // For EIP-4844 Transactions, we want to sign the transaction payload body (tx_payload_body) without the sidecars (ie. without the network wrapper).
+        // See: https://github.com/ethereum/EIPs/blob/e00f4daa66bd56e2dbd5f1d36d09fd613811a48b/EIPS/eip-4844.md#networking
+        if (transaction.type === 'eip4844')
+            return {
+                ...transaction,
+                sidecars: false,
+            };
+        return transaction;
+    })();
+    const signature = await sign({
+        hash: keccak256(serializer(signableTransaction)),
+        privateKey,
+    });
+    return serializer(transaction, signature);
+}
+
+class AbiEncodingArrayLengthMismatchError extends BaseError {
+    constructor({ expectedLength, givenLength, type, }) {
+        super([
+            `ABI encoding array length mismatch for type ${type}.`,
+            `Expected length: ${expectedLength}`,
+            `Given length: ${givenLength}`,
+        ].join('\n'));
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'FeeCapTooHigh'
+            value: 'AbiEncodingArrayLengthMismatchError'
         });
     }
 }
-Object.defineProperty(FeeCapTooHighError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /max fee per gas higher than 2\^256-1|fee cap higher than 2\^256-1/
-});
-class TipAboveFeeCapError extends BaseError {
-    constructor({ cause, maxPriorityFeePerGas, maxFeePerGas, } = {}) {
-        super([
-            `The provided tip (\`maxPriorityFeePerGas\`${maxPriorityFeePerGas
-                ? ` = ${formatGwei(maxPriorityFeePerGas)} gwei`
-                : ''}) cannot be higher than the fee cap (\`maxFeePerGas\`${maxFeePerGas ? ` = ${formatGwei(maxFeePerGas)} gwei` : ''}).`,
-        ].join('\n'), {
-            cause,
-        });
+class AbiEncodingBytesSizeMismatchError extends BaseError {
+    constructor({ expectedSize, value }) {
+        super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`);
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'TipAboveFeeCapError'
+            value: 'AbiEncodingBytesSizeMismatchError'
         });
     }
 }
-Object.defineProperty(TipAboveFeeCapError, "nodeMessage", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: /max priority fee per gas higher than max fee per gas|tip higher than fee cap/
-});
-
-function getTransactionType(transaction) {
-    if (transaction.type)
-        return transaction.type;
-    if (typeof transaction.blobs !== 'undefined' ||
-        typeof transaction.blobVersionedHashes !== 'undefined' ||
-        typeof transaction.maxFeePerBlobGas !== 'undefined' ||
-        typeof transaction.sidecars !== 'undefined')
-        return 'eip4844';
-    if (typeof transaction.maxFeePerGas !== 'undefined' ||
-        typeof transaction.maxPriorityFeePerGas !== 'undefined') {
-        return 'eip1559';
-    }
-    if (typeof transaction.gasPrice !== 'undefined') {
-        if (typeof transaction.accessList !== 'undefined')
-            return 'eip2930';
-        return 'legacy';
+class AbiEncodingLengthMismatchError extends BaseError {
+    constructor({ expectedLength, givenLength, }) {
+        super([
+            'ABI encoding params/values length mismatch.',
+            `Expected length (params): ${expectedLength}`,
+            `Given length (values): ${givenLength}`,
+        ].join('\n'));
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AbiEncodingLengthMismatchError'
+        });
     }
-    throw new InvalidSerializableTransactionError({ transaction });
 }
-
-class InvalidChainIdError extends BaseError {
-    constructor({ chainId }) {
-        super(typeof chainId === 'number'
-            ? `Chain ID "${chainId}" is invalid.`
-            : 'Chain ID is invalid.');
+class BytesSizeMismatchError extends BaseError {
+    constructor({ expectedSize, givenSize, }) {
+        super(`Expected bytes${expectedSize}, got bytes${givenSize}.`);
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: 'InvalidChainIdError'
+            value: 'BytesSizeMismatchError'
         });
     }
 }
-
-// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`
-// https://regexr.com/6va55
-const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
-// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
-// https://regexr.com/6v8hp
-const integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
-
-// Implementation forked and adapted from https://github.com/MetaMask/eth-sig-util/blob/main/src/sign-typed-data.ts
-function hashTypedData(parameters) {
-    const { domain = {}, message, primaryType, } = parameters;
-    const types = {
-        EIP712Domain: getTypesForEIP712Domain({ domain }),
-        ...parameters.types,
-    };
-    // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc
-    // as we can't statically check this with TypeScript.
-    validateTypedData({
-        domain,
-        message,
-        primaryType,
-        types,
-    });
-    const parts = ['0x1901'];
-    if (domain)
-        parts.push(hashDomain({
-            domain,
-            types: types,
-        }));
-    if (primaryType !== 'EIP712Domain')
-        parts.push(hashStruct({
-            data: message,
-            primaryType,
-            types: types,
-        }));
-    return keccak256(concat(parts));
-}
-function hashDomain({ domain, types, }) {
-    return hashStruct({
-        data: domain,
-        primaryType: 'EIP712Domain',
-        types,
-    });
-}
-function hashStruct({ data, primaryType, types, }) {
-    const encoded = encodeData({
-        data,
-        primaryType,
-        types,
-    });
-    return keccak256(encoded);
+class InvalidAbiEncodingTypeError extends BaseError {
+    constructor(type, { docsPath }) {
+        super([
+            `Type "${type}" is not a valid encoding type.`,
+            'Please provide a valid ABI type.',
+        ].join('\n'), { docsPath });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'InvalidAbiEncodingType'
+        });
+    }
 }
-function encodeData({ data, primaryType, types, }) {
-    const encodedTypes = [{ type: 'bytes32' }];
-    const encodedValues = [hashType({ primaryType, types })];
-    for (const field of types[primaryType]) {
-        const [type, value] = encodeField({
-            types,
-            name: field.name,
-            type: field.type,
-            value: data[field.name],
+class InvalidArrayError extends BaseError {
+    constructor(value) {
+        super([`Value "${value}" is not a valid array.`].join('\n'));
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'InvalidArrayError'
         });
-        encodedTypes.push(type);
-        encodedValues.push(value);
     }
-    return encodeAbiParameters(encodedTypes, encodedValues);
 }
-function hashType({ primaryType, types, }) {
-    const encodedHashType = toHex(encodeType({ primaryType, types }));
-    return keccak256(encodedHashType);
+
+/**
+ * @description Encodes a list of primitive values into an ABI-encoded hex value.
+ *
+ * - Docs: https://viem.sh/docs/abi/encodeAbiParameters#encodeabiparameters
+ *
+ *   Generates ABI encoded data using the [ABI specification](https://docs.soliditylang.org/en/latest/abi-spec), given a set of ABI parameters (inputs/outputs) and their corresponding values.
+ *
+ * @param params - a set of ABI Parameters (params), that can be in the shape of the inputs or outputs attribute of an ABI Item.
+ * @param values - a set of values (values) that correspond to the given params.
+ * @example
+ * ```typescript
+ * import { encodeAbiParameters } from 'viem'
+ *
+ * const encodedData = encodeAbiParameters(
+ *   [
+ *     { name: 'x', type: 'string' },
+ *     { name: 'y', type: 'uint' },
+ *     { name: 'z', type: 'bool' }
+ *   ],
+ *   ['wagmi', 420n, true]
+ * )
+ * ```
+ *
+ * You can also pass in Human Readable parameters with the parseAbiParameters utility.
+ *
+ * @example
+ * ```typescript
+ * import { encodeAbiParameters, parseAbiParameters } from 'viem'
+ *
+ * const encodedData = encodeAbiParameters(
+ *   parseAbiParameters('string x, uint y, bool z'),
+ *   ['wagmi', 420n, true]
+ * )
+ * ```
+ */
+function encodeAbiParameters(params, values) {
+    if (params.length !== values.length)
+        throw new AbiEncodingLengthMismatchError({
+            expectedLength: params.length,
+            givenLength: values.length,
+        });
+    // Prepare the parameters to determine dynamic types to encode.
+    const preparedParams = prepareParams({
+        params: params,
+        values: values,
+    });
+    const data = encodeParams(preparedParams);
+    if (data.length === 0)
+        return '0x';
+    return data;
 }
-function encodeType({ primaryType, types, }) {
-    let result = '';
-    const unsortedDeps = findTypeDependencies({ primaryType, types });
-    unsortedDeps.delete(primaryType);
-    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
-    for (const type of deps) {
-        result += `${type}(${types[type]
-            .map(({ name, type: t }) => `${t} ${name}`)
-            .join(',')})`;
+function prepareParams({ params, values, }) {
+    const preparedParams = [];
+    for (let i = 0; i < params.length; i++) {
+        preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
     }
-    return result;
+    return preparedParams;
 }
-function findTypeDependencies({ primaryType: primaryType_, types, }, results = new Set()) {
-    const match = primaryType_.match(/^\w*/u);
-    const primaryType = match?.[0];
-    if (results.has(primaryType) || types[primaryType] === undefined) {
-        return results;
+function prepareParam({ param, value, }) {
+    const arrayComponents = getArrayComponents(param.type);
+    if (arrayComponents) {
+        const [length, type] = arrayComponents;
+        return encodeArray(value, { length, param: { ...param, type } });
     }
-    results.add(primaryType);
-    for (const field of types[primaryType]) {
-        findTypeDependencies({ primaryType: field.type, types }, results);
+    if (param.type === 'tuple') {
+        return encodeTuple(value, {
+            param: param,
+        });
     }
-    return results;
-}
-function encodeField({ types, name, type, value, }) {
-    if (types[type] !== undefined) {
-        return [
-            { type: 'bytes32' },
-            keccak256(encodeData({ data: value, primaryType: type, types })),
-        ];
+    if (param.type === 'address') {
+        return encodeAddress(value);
     }
-    if (type === 'bytes') {
-        const prepend = value.length % 2 ? '0' : '';
-        value = `0x${prepend + value.slice(2)}`;
-        return [{ type: 'bytes32' }, keccak256(value)];
+    if (param.type === 'bool') {
+        return encodeBool(value);
     }
-    if (type === 'string')
-        return [{ type: 'bytes32' }, keccak256(toHex(value))];
-    if (type.lastIndexOf(']') === type.length - 1) {
-        const parsedType = type.slice(0, type.lastIndexOf('['));
-        const typeValuePairs = value.map((item) => encodeField({
-            name,
-            type: parsedType,
-            types,
-            value: item,
-        }));
-        return [
-            { type: 'bytes32' },
-            keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v))),
-        ];
+    if (param.type.startsWith('uint') || param.type.startsWith('int')) {
+        const signed = param.type.startsWith('int');
+        return encodeNumber(value, { signed });
     }
-    return [{ type }, value];
-}
-
-function validateTypedData(parameters) {
-    const { domain, message, primaryType, types } = parameters;
-    const validateData = (struct, data) => {
-        for (const param of struct) {
-            const { name, type } = param;
-            const value = data[name];
-            const integerMatch = type.match(integerRegex);
-            if (integerMatch &&
-                (typeof value === 'number' || typeof value === 'bigint')) {
-                const [_type, base, size_] = integerMatch;
-                // If number cannot be cast to a sized hex value, it is out of range
-                // and will throw.
-                numberToHex(value, {
-                    signed: base === 'int',
-                    size: parseInt(size_) / 8,
-                });
-            }
-            if (type === 'address' && typeof value === 'string' && !isAddress(value))
-                throw new InvalidAddressError({ address: value });
-            const bytesMatch = type.match(bytesRegex);
-            if (bytesMatch) {
-                const [_type, size_] = bytesMatch;
-                if (size_ && size(value) !== parseInt(size_))
-                    throw new BytesSizeMismatchError({
-                        expectedSize: parseInt(size_),
-                        givenSize: size(value),
-                    });
-            }
-            const struct = types[type];
-            if (struct)
-                validateData(struct, value);
-        }
-    };
-    // Validate domain types.
-    if (types.EIP712Domain && domain)
-        validateData(types.EIP712Domain, domain);
-    if (primaryType !== 'EIP712Domain') {
-        // Validate message types.
-        const type = types[primaryType];
-        validateData(type, message);
+    if (param.type.startsWith('bytes')) {
+        return encodeBytes(value, { param });
+    }
+    if (param.type === 'string') {
+        return encodeString(value);
     }
+    throw new InvalidAbiEncodingTypeError(param.type, {
+        docsPath: '/docs/contract/encodeAbiParameters',
+    });
 }
-function getTypesForEIP712Domain({ domain, }) {
-    return [
-        typeof domain?.name === 'string' && { name: 'name', type: 'string' },
-        domain?.version && { name: 'version', type: 'string' },
-        typeof domain?.chainId === 'number' && {
-            name: 'chainId',
-            type: 'uint256',
-        },
-        domain?.verifyingContract && {
-            name: 'verifyingContract',
-            type: 'address',
-        },
-        domain?.salt && { name: 'salt', type: 'bytes32' },
-    ].filter(Boolean);
-}
-
-function assertTransactionEIP4844(transaction) {
-    const { blobVersionedHashes } = transaction;
-    if (blobVersionedHashes) {
-        if (blobVersionedHashes.length === 0)
-            throw new EmptyBlobError();
-        for (const hash of blobVersionedHashes) {
-            const size_ = size(hash);
-            const version = hexToNumber(slice(hash, 0, 1));
-            if (size_ !== 32)
-                throw new InvalidVersionedHashSizeError({ hash, size: size_ });
-            if (version !== versionedHashVersionKzg)
-                throw new InvalidVersionedHashVersionError({
-                    hash,
-                    version,
-                });
+function encodeParams(preparedParams) {
+    // 1. Compute the size of the static part of the parameters.
+    let staticSize = 0;
+    for (let i = 0; i < preparedParams.length; i++) {
+        const { dynamic, encoded } = preparedParams[i];
+        if (dynamic)
+            staticSize += 32;
+        else
+            staticSize += size(encoded);
+    }
+    // 2. Split the parameters into static and dynamic parts.
+    const staticParams = [];
+    const dynamicParams = [];
+    let dynamicSize = 0;
+    for (let i = 0; i < preparedParams.length; i++) {
+        const { dynamic, encoded } = preparedParams[i];
+        if (dynamic) {
+            staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
+            dynamicParams.push(encoded);
+            dynamicSize += size(encoded);
+        }
+        else {
+            staticParams.push(encoded);
         }
     }
-    assertTransactionEIP1559(transaction);
-}
-function assertTransactionEIP1559(transaction) {
-    const { chainId, maxPriorityFeePerGas, maxFeePerGas, to } = transaction;
-    if (chainId <= 0)
-        throw new InvalidChainIdError({ chainId });
-    if (to && !isAddress(to))
-        throw new InvalidAddressError({ address: to });
-    if (maxFeePerGas && maxFeePerGas > 2n ** 256n - 1n)
-        throw new FeeCapTooHighError({ maxFeePerGas });
-    if (maxPriorityFeePerGas &&
-        maxFeePerGas &&
-        maxPriorityFeePerGas > maxFeePerGas)
-        throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas });
-}
-function assertTransactionEIP2930(transaction) {
-    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = transaction;
-    if (chainId <= 0)
-        throw new InvalidChainIdError({ chainId });
-    if (to && !isAddress(to))
-        throw new InvalidAddressError({ address: to });
-    if (maxPriorityFeePerGas || maxFeePerGas)
-        throw new BaseError('`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid EIP-2930 Transaction attribute.');
-    if (gasPrice && gasPrice > 2n ** 256n - 1n)
-        throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
+    // 3. Concatenate static and dynamic parts.
+    return concat([...staticParams, ...dynamicParams]);
 }
-function assertTransactionLegacy(transaction) {
-    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to, accessList, } = transaction;
-    if (to && !isAddress(to))
-        throw new InvalidAddressError({ address: to });
-    if (typeof chainId !== 'undefined' && chainId <= 0)
-        throw new InvalidChainIdError({ chainId });
-    if (maxPriorityFeePerGas || maxFeePerGas)
-        throw new BaseError('`maxFeePerGas`/`maxPriorityFeePerGas` is not a valid Legacy Transaction attribute.');
-    if (gasPrice && gasPrice > 2n ** 256n - 1n)
-        throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
-    if (accessList)
-        throw new BaseError('`accessList` is not a valid Legacy Transaction attribute.');
+function encodeAddress(value) {
+    if (!isAddress(value))
+        throw new InvalidAddressError({ address: value });
+    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
 }
-
-/*
- * Serialize an  EIP-2930 access list
- * @remarks
- * Use to create a transaction serializer with support for EIP-2930 access lists
- *
- * @param accessList - Array of objects of address and arrays of Storage Keys
- * @throws InvalidAddressError, InvalidStorageKeySizeError
- * @returns Array of hex strings
- */
-function serializeAccessList(accessList) {
-    if (!accessList || accessList.length === 0)
-        return [];
-    const serializedAccessList = [];
-    for (let i = 0; i < accessList.length; i++) {
-        const { address, storageKeys } = accessList[i];
-        for (let j = 0; j < storageKeys.length; j++) {
-            if (storageKeys[j].length - 2 !== 64) {
-                throw new InvalidStorageKeySizeError({ storageKey: storageKeys[j] });
-            }
-        }
-        if (!isAddress(address, { strict: false })) {
-            throw new InvalidAddressError({ address });
+function encodeArray(value, { length, param, }) {
+    const dynamic = length === null;
+    if (!Array.isArray(value))
+        throw new InvalidArrayError(value);
+    if (!dynamic && value.length !== length)
+        throw new AbiEncodingArrayLengthMismatchError({
+            expectedLength: length,
+            givenLength: value.length,
+            type: `${param.type}[${length}]`,
+        });
+    let dynamicChild = false;
+    const preparedParams = [];
+    for (let i = 0; i < value.length; i++) {
+        const preparedParam = prepareParam({ param, value: value[i] });
+        if (preparedParam.dynamic)
+            dynamicChild = true;
+        preparedParams.push(preparedParam);
+    }
+    if (dynamic || dynamicChild) {
+        const data = encodeParams(preparedParams);
+        if (dynamic) {
+            const length = numberToHex(preparedParams.length, { size: 32 });
+            return {
+                dynamic: true,
+                encoded: preparedParams.length > 0 ? concat([length, data]) : length,
+            };
         }
-        serializedAccessList.push([address, storageKeys]);
+        if (dynamicChild)
+            return { dynamic: true, encoded: data };
     }
-    return serializedAccessList;
+    return {
+        dynamic: false,
+        encoded: concat(preparedParams.map(({ encoded }) => encoded)),
+    };
 }
-
-function toRlp(bytes, to = 'hex') {
-    const encodable = getEncodable(bytes);
-    const cursor = createCursor(new Uint8Array(encodable.length));
-    encodable.encode(cursor);
-    if (to === 'hex')
-        return bytesToHex(cursor.bytes);
-    return cursor.bytes;
+function encodeBytes(value, { param }) {
+    const [, paramSize] = param.type.split('bytes');
+    const bytesSize = size(value);
+    if (!paramSize) {
+        let value_ = value;
+        // If the size is not divisible by 32 bytes, pad the end
+        // with empty bytes to the ceiling 32 bytes.
+        if (bytesSize % 32 !== 0)
+            value_ = padHex(value_, {
+                dir: 'right',
+                size: Math.ceil((value.length - 2) / 2 / 32) * 32,
+            });
+        return {
+            dynamic: true,
+            encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_]),
+        };
+    }
+    if (bytesSize !== Number.parseInt(paramSize))
+        throw new AbiEncodingBytesSizeMismatchError({
+            expectedSize: Number.parseInt(paramSize),
+            value,
+        });
+    return { dynamic: false, encoded: padHex(value, { dir: 'right' }) };
 }
-function getEncodable(bytes) {
-    if (Array.isArray(bytes))
-        return getEncodableList(bytes.map((x) => getEncodable(x)));
-    return getEncodableBytes(bytes);
+function encodeBool(value) {
+    if (typeof value !== 'boolean')
+        throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+    return { dynamic: false, encoded: padHex(boolToHex(value)) };
 }
-function getEncodableList(list) {
-    const bodyLength = list.reduce((acc, x) => acc + x.length, 0);
-    const sizeOfBodyLength = getSizeOfLength(bodyLength);
-    const length = (() => {
-        if (bodyLength <= 55)
-            return 1 + bodyLength;
-        return 1 + sizeOfBodyLength + bodyLength;
-    })();
+function encodeNumber(value, { signed }) {
     return {
-        length,
-        encode(cursor) {
-            if (bodyLength <= 55) {
-                cursor.pushByte(0xc0 + bodyLength);
-            }
-            else {
-                cursor.pushByte(0xc0 + 55 + sizeOfBodyLength);
-                if (sizeOfBodyLength === 1)
-                    cursor.pushUint8(bodyLength);
-                else if (sizeOfBodyLength === 2)
-                    cursor.pushUint16(bodyLength);
-                else if (sizeOfBodyLength === 3)
-                    cursor.pushUint24(bodyLength);
-                else
-                    cursor.pushUint32(bodyLength);
-            }
-            for (const { encode } of list) {
-                encode(cursor);
-            }
-        },
+        dynamic: false,
+        encoded: numberToHex(value, {
+            size: 32,
+            signed,
+        }),
     };
 }
-function getEncodableBytes(bytesOrHex) {
-    const bytes = typeof bytesOrHex === 'string' ? hexToBytes(bytesOrHex) : bytesOrHex;
-    const sizeOfBytesLength = getSizeOfLength(bytes.length);
-    const length = (() => {
-        if (bytes.length === 1 && bytes[0] < 0x80)
-            return 1;
-        if (bytes.length <= 55)
-            return 1 + bytes.length;
-        return 1 + sizeOfBytesLength + bytes.length;
-    })();
+function encodeString(value) {
+    const hexValue = stringToHex(value);
+    const partsLength = Math.ceil(size(hexValue) / 32);
+    const parts = [];
+    for (let i = 0; i < partsLength; i++) {
+        parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
+            dir: 'right',
+        }));
+    }
     return {
-        length,
-        encode(cursor) {
-            if (bytes.length === 1 && bytes[0] < 0x80) {
-                cursor.pushBytes(bytes);
-            }
-            else if (bytes.length <= 55) {
-                cursor.pushByte(0x80 + bytes.length);
-                cursor.pushBytes(bytes);
-            }
-            else {
-                cursor.pushByte(0x80 + 55 + sizeOfBytesLength);
-                if (sizeOfBytesLength === 1)
-                    cursor.pushUint8(bytes.length);
-                else if (sizeOfBytesLength === 2)
-                    cursor.pushUint16(bytes.length);
-                else if (sizeOfBytesLength === 3)
-                    cursor.pushUint24(bytes.length);
-                else
-                    cursor.pushUint32(bytes.length);
-                cursor.pushBytes(bytes);
-            }
-        },
-    };
+        dynamic: true,
+        encoded: concat([
+            padHex(numberToHex(size(hexValue), { size: 32 })),
+            ...parts,
+        ]),
+    };
 }
-function getSizeOfLength(length) {
-    if (length < 2 ** 8)
-        return 1;
-    if (length < 2 ** 16)
-        return 2;
-    if (length < 2 ** 24)
-        return 3;
-    if (length < 2 ** 32)
-        return 4;
-    throw new BaseError('Length is too large.');
+function encodeTuple(value, { param }) {
+    let dynamic = false;
+    const preparedParams = [];
+    for (let i = 0; i < param.components.length; i++) {
+        const param_ = param.components[i];
+        const index = Array.isArray(value) ? i : param_.name;
+        const preparedParam = prepareParam({
+            param: param_,
+            value: value[index],
+        });
+        preparedParams.push(preparedParam);
+        if (preparedParam.dynamic)
+            dynamic = true;
+    }
+    return {
+        dynamic,
+        encoded: dynamic
+            ? encodeParams(preparedParams)
+            : concat(preparedParams.map(({ encoded }) => encoded)),
+    };
+}
+function getArrayComponents(type) {
+    const matches = type.match(/^(.*)\[(\d+)?\]$/);
+    return matches
+        ? // Return `null` if the array is dynamic.
+            [matches[2] ? Number(matches[2]) : null, matches[1]]
+        : undefined;
 }
 
-function serializeTransaction(transaction, signature) {
-    const type = getTransactionType(transaction);
-    if (type === 'eip1559')
-        return serializeTransactionEIP1559(transaction, signature);
-    if (type === 'eip2930')
-        return serializeTransactionEIP2930(transaction, signature);
-    if (type === 'eip4844')
-        return serializeTransactionEIP4844(transaction, signature);
-    return serializeTransactionLegacy(transaction, signature);
+// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`
+// https://regexr.com/6va55
+const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
+// https://regexr.com/6v8hp
+const integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+
+function validateTypedData(parameters) {
+    const { domain, message, primaryType, types } = parameters;
+    const validateData = (struct, data) => {
+        for (const param of struct) {
+            const { name, type } = param;
+            const value = data[name];
+            const integerMatch = type.match(integerRegex);
+            if (integerMatch &&
+                (typeof value === 'number' || typeof value === 'bigint')) {
+                const [_type, base, size_] = integerMatch;
+                // If number cannot be cast to a sized hex value, it is out of range
+                // and will throw.
+                numberToHex(value, {
+                    signed: base === 'int',
+                    size: Number.parseInt(size_) / 8,
+                });
+            }
+            if (type === 'address' && typeof value === 'string' && !isAddress(value))
+                throw new InvalidAddressError({ address: value });
+            const bytesMatch = type.match(bytesRegex);
+            if (bytesMatch) {
+                const [_type, size_] = bytesMatch;
+                if (size_ && size(value) !== Number.parseInt(size_))
+                    throw new BytesSizeMismatchError({
+                        expectedSize: Number.parseInt(size_),
+                        givenSize: size(value),
+                    });
+            }
+            const struct = types[type];
+            if (struct)
+                validateData(struct, value);
+        }
+    };
+    // Validate domain types.
+    if (types.EIP712Domain && domain)
+        validateData(types.EIP712Domain, domain);
+    // Validate message types.
+    if (primaryType !== 'EIP712Domain')
+        validateData(types[primaryType], message);
 }
-function serializeTransactionEIP4844(transaction, signature) {
-    const { chainId, gas, nonce, to, value, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, accessList, data, } = transaction;
-    assertTransactionEIP4844(transaction);
-    let blobVersionedHashes = transaction.blobVersionedHashes;
-    let sidecars = transaction.sidecars;
-    // If `blobs` are passed, we will need to compute the KZG commitments & proofs.
-    if (transaction.blobs &&
-        (typeof blobVersionedHashes === 'undefined' ||
-            typeof sidecars === 'undefined')) {
-        const blobs = (typeof transaction.blobs[0] === 'string'
-            ? transaction.blobs
-            : transaction.blobs.map((x) => bytesToHex(x)));
-        const kzg = transaction.kzg;
-        const commitments = blobsToCommitments({
-            blobs,
-            kzg,
+function getTypesForEIP712Domain({ domain, }) {
+    return [
+        typeof domain?.name === 'string' && { name: 'name', type: 'string' },
+        domain?.version && { name: 'version', type: 'string' },
+        typeof domain?.chainId === 'number' && {
+            name: 'chainId',
+            type: 'uint256',
+        },
+        domain?.verifyingContract && {
+            name: 'verifyingContract',
+            type: 'address',
+        },
+        domain?.salt && { name: 'salt', type: 'bytes32' },
+    ].filter(Boolean);
+}
+
+// Implementation forked and adapted from https://github.com/MetaMask/eth-sig-util/blob/main/src/sign-typed-data.ts
+function hashTypedData(parameters) {
+    const { domain = {}, message, primaryType, } = parameters;
+    const types = {
+        EIP712Domain: getTypesForEIP712Domain({ domain }),
+        ...parameters.types,
+    };
+    // Need to do a runtime validation check on addresses, byte ranges, integer ranges, etc
+    // as we can't statically check this with TypeScript.
+    validateTypedData({
+        domain,
+        message,
+        primaryType,
+        types,
+    });
+    const parts = ['0x1901'];
+    if (domain)
+        parts.push(hashDomain({
+            domain,
+            types: types,
+        }));
+    if (primaryType !== 'EIP712Domain')
+        parts.push(hashStruct({
+            data: message,
+            primaryType,
+            types: types,
+        }));
+    return keccak256(concat(parts));
+}
+function hashDomain({ domain, types, }) {
+    return hashStruct({
+        data: domain,
+        primaryType: 'EIP712Domain',
+        types,
+    });
+}
+function hashStruct({ data, primaryType, types, }) {
+    const encoded = encodeData({
+        data,
+        primaryType,
+        types,
+    });
+    return keccak256(encoded);
+}
+function encodeData({ data, primaryType, types, }) {
+    const encodedTypes = [{ type: 'bytes32' }];
+    const encodedValues = [hashType({ primaryType, types })];
+    for (const field of types[primaryType]) {
+        const [type, value] = encodeField({
+            types,
+            name: field.name,
+            type: field.type,
+            value: data[field.name],
         });
-        if (typeof blobVersionedHashes === 'undefined')
-            blobVersionedHashes = commitmentsToVersionedHashes({
-                commitments,
-            });
-        if (typeof sidecars === 'undefined') {
-            const proofs = blobsToProofs({ blobs, commitments, kzg });
-            sidecars = toBlobSidecars({ blobs, commitments, proofs });
-        }
+        encodedTypes.push(type);
+        encodedValues.push(value);
     }
-    const serializedAccessList = serializeAccessList(accessList);
-    const serializedTransaction = [
-        toHex(chainId),
-        nonce ? toHex(nonce) : '0x',
-        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
-        maxFeePerGas ? toHex(maxFeePerGas) : '0x',
-        gas ? toHex(gas) : '0x',
-        to ?? '0x',
-        value ? toHex(value) : '0x',
-        data ?? '0x',
-        serializedAccessList,
-        maxFeePerBlobGas ? toHex(maxFeePerBlobGas) : '0x',
-        blobVersionedHashes ?? [],
-        ...toYParitySignatureArray(transaction, signature),
-    ];
-    const blobs = [];
-    const commitments = [];
-    const proofs = [];
-    if (sidecars)
-        for (let i = 0; i < sidecars.length; i++) {
-            const { blob, commitment, proof } = sidecars[i];
-            blobs.push(blob);
-            commitments.push(commitment);
-            proofs.push(proof);
-        }
-    return concatHex([
-        '0x03',
-        sidecars
-            ? // If sidecars are enabled, envelope turns into a "wrapper":
-                toRlp([serializedTransaction, blobs, commitments, proofs])
-            : // If sidecars are disabled, standard envelope is used:
-                toRlp(serializedTransaction),
-    ]);
+    return encodeAbiParameters(encodedTypes, encodedValues);
 }
-function serializeTransactionEIP1559(transaction, signature) {
-    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data, } = transaction;
-    assertTransactionEIP1559(transaction);
-    const serializedAccessList = serializeAccessList(accessList);
-    const serializedTransaction = [
-        toHex(chainId),
-        nonce ? toHex(nonce) : '0x',
-        maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
-        maxFeePerGas ? toHex(maxFeePerGas) : '0x',
-        gas ? toHex(gas) : '0x',
-        to ?? '0x',
-        value ? toHex(value) : '0x',
-        data ?? '0x',
-        serializedAccessList,
-        ...toYParitySignatureArray(transaction, signature),
-    ];
-    return concatHex([
-        '0x02',
-        toRlp(serializedTransaction),
-    ]);
+function hashType({ primaryType, types, }) {
+    const encodedHashType = toHex(encodeType({ primaryType, types }));
+    return keccak256(encodedHashType);
 }
-function serializeTransactionEIP2930(transaction, signature) {
-    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
-    assertTransactionEIP2930(transaction);
-    const serializedAccessList = serializeAccessList(accessList);
-    const serializedTransaction = [
-        toHex(chainId),
-        nonce ? toHex(nonce) : '0x',
-        gasPrice ? toHex(gasPrice) : '0x',
-        gas ? toHex(gas) : '0x',
-        to ?? '0x',
-        value ? toHex(value) : '0x',
-        data ?? '0x',
-        serializedAccessList,
-        ...toYParitySignatureArray(transaction, signature),
-    ];
-    return concatHex([
-        '0x01',
-        toRlp(serializedTransaction),
-    ]);
+function encodeType({ primaryType, types, }) {
+    let result = '';
+    const unsortedDeps = findTypeDependencies({ primaryType, types });
+    unsortedDeps.delete(primaryType);
+    const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
+    for (const type of deps) {
+        result += `${type}(${types[type]
+            .map(({ name, type: t }) => `${t} ${name}`)
+            .join(',')})`;
+    }
+    return result;
 }
-function serializeTransactionLegacy(transaction, signature) {
-    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
-    assertTransactionLegacy(transaction);
-    let serializedTransaction = [
-        nonce ? toHex(nonce) : '0x',
-        gasPrice ? toHex(gasPrice) : '0x',
-        gas ? toHex(gas) : '0x',
-        to ?? '0x',
-        value ? toHex(value) : '0x',
-        data ?? '0x',
-    ];
-    if (signature) {
-        const v = (() => {
-            // EIP-155 (inferred chainId)
-            if (signature.v >= 35n) {
-                const inferredChainId = (signature.v - 35n) / 2n;
-                if (inferredChainId > 0)
-                    return signature.v;
-                return 27n + (signature.v === 35n ? 0n : 1n);
-            }
-            // EIP-155 (explicit chainId)
-            if (chainId > 0)
-                return BigInt(chainId * 2) + BigInt(35n + signature.v - 27n);
-            // Pre-EIP-155 (no chainId)
-            const v = 27n + (signature.v === 27n ? 0n : 1n);
-            if (signature.v !== v)
-                throw new InvalidLegacyVError({ v: signature.v });
-            return v;
-        })();
-        serializedTransaction = [
-            ...serializedTransaction,
-            toHex(v),
-            signature.r,
-            signature.s,
+function findTypeDependencies({ primaryType: primaryType_, types, }, results = new Set()) {
+    const match = primaryType_.match(/^\w*/u);
+    const primaryType = match?.[0];
+    if (results.has(primaryType) || types[primaryType] === undefined) {
+        return results;
+    }
+    results.add(primaryType);
+    for (const field of types[primaryType]) {
+        findTypeDependencies({ primaryType: field.type, types }, results);
+    }
+    return results;
+}
+function encodeField({ types, name, type, value, }) {
+    if (types[type] !== undefined) {
+        return [
+            { type: 'bytes32' },
+            keccak256(encodeData({ data: value, primaryType: type, types })),
         ];
     }
-    else if (chainId > 0) {
-        serializedTransaction = [
-            ...serializedTransaction,
-            toHex(chainId),
-            '0x',
-            '0x',
+    if (type === 'bytes') {
+        const prepend = value.length % 2 ? '0' : '';
+        value = `0x${prepend + value.slice(2)}`;
+        return [{ type: 'bytes32' }, keccak256(value)];
+    }
+    if (type === 'string')
+        return [{ type: 'bytes32' }, keccak256(toHex(value))];
+    if (type.lastIndexOf(']') === type.length - 1) {
+        const parsedType = type.slice(0, type.lastIndexOf('['));
+        const typeValuePairs = value.map((item) => encodeField({
+            name,
+            type: parsedType,
+            types,
+            value: item,
+        }));
+        return [
+            { type: 'bytes32' },
+            keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v))),
         ];
     }
-    return toRlp(serializedTransaction);
-}
-function toYParitySignatureArray(transaction, signature) {
-    const { r, s, v, yParity } = signature ?? transaction;
-    if (typeof r === 'undefined')
-        return [];
-    if (typeof s === 'undefined')
-        return [];
-    if (typeof v === 'undefined' && typeof yParity === 'undefined')
-        return [];
-    const yParity_ = (() => {
-        if (typeof yParity === 'number')
-            return yParity ? toHex(1) : '0x';
-        if (v === 0n)
-            return '0x';
-        if (v === 1n)
-            return toHex(1);
-        return v === 27n ? '0x' : toHex(1);
-    })();
-    return [yParity_, trim(r), trim(s)];
-}
-
-async function signTransaction(parameters) {
-    const { privateKey, transaction, serializer = serializeTransaction, } = parameters;
-    const signableTransaction = (() => {
-        // For EIP-4844 Transactions, we want to sign the transaction payload body (tx_payload_body) without the sidecars (ie. without the network wrapper).
-        // See: https://github.com/ethereum/EIPs/blob/e00f4daa66bd56e2dbd5f1d36d09fd613811a48b/EIPS/eip-4844.md#networking
-        if (transaction.type === 'eip4844')
-            return {
-                ...transaction,
-                sidecars: false,
-            };
-        return transaction;
-    })();
-    const signature = await sign({
-        hash: keccak256(serializer(signableTransaction)),
-        privateKey,
-    });
-    return serializer(transaction, signature);
+    return [{ type }, value];
 }
 
 /**
@@ -5746,7 +5764,7 @@ async function signTypedData(parameters) {
         hash: hashTypedData(typedData),
         privateKey,
     });
-    return signatureToHex(signature);
+    return serializeSignature(signature);
 }
 
 /**
@@ -5754,11 +5772,13 @@ async function signTypedData(parameters) {
  *
  * @returns A Private Key Account.
  */
-function privateKeyToAccount(privateKey) {
+function privateKeyToAccount(privateKey, options = {}) {
+    const { nonceManager } = options;
     const publicKey = toHex(secp256k1.getPublicKey(privateKey.slice(2), false));
     const address = publicKeyToAddress(publicKey);
     const account = toAccount({
         address,
+        nonceManager,
         async signMessage({ message }) {
             return signMessage({ message, privateKey });
         },
@@ -5781,9 +5801,9 @@ function privateKeyToAccount(privateKey) {
  *
  * @returns A HD Account.
  */
-function hdKeyToAccount(hdKey_, { accountIndex = 0, addressIndex = 0, changeIndex = 0, path } = {}) {
+function hdKeyToAccount(hdKey_, { accountIndex = 0, addressIndex = 0, changeIndex = 0, path, ...options } = {}) {
     const hdKey = hdKey_.derive(path || `m/44'/60'/${accountIndex}'/${changeIndex}/${addressIndex}`);
-    const account = privateKeyToAccount(toHex(hdKey.privateKey));
+    const account = privateKeyToAccount(toHex(hdKey.privateKey), options);
     return {
         ...account,
         getHdKey: () => hdKey,