@lombard.finance/sdk-agentkit 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3738 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+require('reflect-metadata');
+const agentkit = require('@coinbase/agentkit');
+const sdk = require('@lombard.finance/sdk');
+const zod = require('zod');
+const sdkCommon = require('@lombard.finance/sdk-common');
+const viem = require('viem');
+
+function defineChain(chain) {
+    const chainInstance = {
+        formatters: undefined,
+        fees: undefined,
+        serializers: undefined,
+        ...chain,
+    };
+    function extend(base) {
+        return (fnOrExtended) => {
+            const properties = (typeof fnOrExtended === 'function' ? fnOrExtended(base) : fnOrExtended);
+            const combined = { ...base, ...properties };
+            return Object.assign(combined, { extend: extend(combined) });
+        };
+    }
+    return Object.assign(chainInstance, {
+        extend: extend(chainInstance),
+    });
+}
+
+const version = '2.47.6';
+
+let errorConfig = {
+    getDocsUrl: ({ docsBaseUrl, docsPath = '', docsSlug, }) => docsPath
+        ? `${docsBaseUrl ?? 'https://viem.sh'}${docsPath}${docsSlug ? `#${docsSlug}` : ''}`
+        : undefined,
+    version: `viem@${version}`,
+};
+class BaseError extends Error {
+    constructor(shortMessage, args = {}) {
+        const details = (() => {
+            if (args.cause instanceof BaseError)
+                return args.cause.details;
+            if (args.cause?.message)
+                return args.cause.message;
+            return args.details;
+        })();
+        const docsPath = (() => {
+            if (args.cause instanceof BaseError)
+                return args.cause.docsPath || args.docsPath;
+            return args.docsPath;
+        })();
+        const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath });
+        const message = [
+            shortMessage || 'An error occurred.',
+            '',
+            ...(args.metaMessages ? [...args.metaMessages, ''] : []),
+            ...(docsUrl ? [`Docs: ${docsUrl}`] : []),
+            ...(details ? [`Details: ${details}`] : []),
+            ...(errorConfig.version ? [`Version: ${errorConfig.version}`] : []),
+        ].join('\n');
+        super(message, args.cause ? { cause: args.cause } : undefined);
+        Object.defineProperty(this, "details", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "docsPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metaMessages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "shortMessage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'BaseError'
+        });
+        this.details = details;
+        this.docsPath = docsPath;
+        this.metaMessages = args.metaMessages;
+        this.name = args.name ?? this.name;
+        this.shortMessage = shortMessage;
+        this.version = version;
+    }
+    walk(fn) {
+        return walk(this, fn);
+    }
+}
+function walk(err, fn) {
+    if (fn?.(err))
+        return err;
+    if (err &&
+        typeof err === 'object' &&
+        'cause' in err &&
+        err.cause !== undefined)
+        return walk(err.cause, fn);
+    return fn ? null : err;
+}
+
+class IntegerOutOfRangeError extends BaseError {
+    constructor({ max, min, signed, size, value, }) {
+        super(`Number "${value}" is not in safe ${size ? `${size * 8}-bit ${signed ? 'signed' : 'unsigned'} ` : ''}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: 'IntegerOutOfRangeError' });
+    }
+}
+class SizeOverflowError extends BaseError {
+    constructor({ givenSize, maxSize }) {
+        super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: 'SizeOverflowError' });
+    }
+}
+
+function isHex(value, { strict = true } = {}) {
+    if (!value)
+        return false;
+    if (typeof value !== 'string')
+        return false;
+    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith('0x');
+}
+
+/**
+ * @description Retrieves the size of the value (in bytes).
+ *
+ * @param value The value (hex or byte array) to retrieve the size of.
+ * @returns The size of the value (in bytes).
+ */
+function size(value) {
+    if (isHex(value, { strict: false }))
+        return Math.ceil((value.length - 2) / 2);
+    return value.length;
+}
+
+function trim(hexOrBytes, { dir = 'left' } = {}) {
+    let data = typeof hexOrBytes === 'string' ? hexOrBytes.replace('0x', '') : hexOrBytes;
+    let sliceLength = 0;
+    for (let i = 0; i < data.length - 1; i++) {
+        if (data[dir === 'left' ? i : data.length - i - 1].toString() === '0')
+            sliceLength++;
+        else
+            break;
+    }
+    data =
+        dir === 'left'
+            ? data.slice(sliceLength)
+            : data.slice(0, data.length - sliceLength);
+    if (typeof hexOrBytes === 'string') {
+        if (data.length === 1 && dir === 'right')
+            data = `${data}0`;
+        return `0x${data.length % 2 === 1 ? `0${data}` : data}`;
+    }
+    return data;
+}
+
+class SliceOffsetOutOfBoundsError extends BaseError {
+    constructor({ offset, position, size, }) {
+        super(`Slice ${position === 'start' ? 'starting' : 'ending'} at offset "${offset}" is out-of-bounds (size: ${size}).`, { name: 'SliceOffsetOutOfBoundsError' });
+    }
+}
+class SizeExceedsPaddingSizeError extends BaseError {
+    constructor({ size, targetSize, type, }) {
+        super(`${type.charAt(0).toUpperCase()}${type
+            .slice(1)
+            .toLowerCase()} size (${size}) exceeds padding size (${targetSize}).`, { name: 'SizeExceedsPaddingSizeError' });
+    }
+}
+
+function pad(hexOrBytes, { dir, size = 32 } = {}) {
+    if (typeof hexOrBytes === 'string')
+        return padHex(hexOrBytes, { dir, size });
+    return padBytes(hexOrBytes, { dir, size });
+}
+function padHex(hex_, { dir, size = 32 } = {}) {
+    if (size === null)
+        return hex_;
+    const hex = hex_.replace('0x', '');
+    if (hex.length > size * 2)
+        throw new SizeExceedsPaddingSizeError({
+            size: Math.ceil(hex.length / 2),
+            targetSize: size,
+            type: 'hex',
+        });
+    return `0x${hex[dir === 'right' ? 'padEnd' : 'padStart'](size * 2, '0')}`;
+}
+function padBytes(bytes, { dir, size = 32 } = {}) {
+    if (size === null)
+        return bytes;
+    if (bytes.length > size)
+        throw new SizeExceedsPaddingSizeError({
+            size: bytes.length,
+            targetSize: size,
+            type: 'bytes',
+        });
+    const paddedBytes = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+        const padEnd = dir === 'right';
+        paddedBytes[padEnd ? i : size - i - 1] =
+            bytes[padEnd ? i : bytes.length - i - 1];
+    }
+    return paddedBytes;
+}
+
+const hexes = /*#__PURE__*/ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, '0'));
+/**
+ * Encodes a string, number, bigint, or ByteArray into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex
+ * - Example: https://viem.sh/docs/utilities/toHex#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world')
+ * // '0x48656c6c6f20776f726c6421'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world', { size: 32 })
+ * // '0x48656c6c6f20776f726c64210000000000000000000000000000000000000000'
+ */
+function toHex(value, opts = {}) {
+    if (typeof value === 'number' || typeof value === 'bigint')
+        return numberToHex(value, opts);
+    if (typeof value === 'string') {
+        return stringToHex(value, opts);
+    }
+    if (typeof value === 'boolean')
+        return boolToHex(value, opts);
+    return bytesToHex(value, opts);
+}
+/**
+ * Encodes a boolean into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex#booltohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true)
+ * // '0x1'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(false)
+ * // '0x0'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true, { size: 32 })
+ * // '0x0000000000000000000000000000000000000000000000000000000000000001'
+ */
+function boolToHex(value, opts = {}) {
+    const hex = `0x${Number(value)}`;
+    if (typeof opts.size === 'number') {
+        assertSize(hex, { size: opts.size });
+        return pad(hex, { size: opts.size });
+    }
+    return hex;
+}
+/**
+ * Encodes a bytes array into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex#bytestohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]), { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+ */
+function bytesToHex(value, opts = {}) {
+    let string = '';
+    for (let i = 0; i < value.length; i++) {
+        string += hexes[value[i]];
+    }
+    const hex = `0x${string}`;
+    if (typeof opts.size === 'number') {
+        assertSize(hex, { size: opts.size });
+        return pad(hex, { dir: 'right', size: opts.size });
+    }
+    return hex;
+}
+/**
+ * Encodes a number or bigint into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex#numbertohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420, { size: 32 })
+ * // '0x00000000000000000000000000000000000000000000000000000000000001a4'
+ */
+function numberToHex(value_, opts = {}) {
+    const { signed, size } = opts;
+    const value = BigInt(value_);
+    let maxValue;
+    if (size) {
+        if (signed)
+            maxValue = (1n << (BigInt(size) * 8n - 1n)) - 1n;
+        else
+            maxValue = 2n ** (BigInt(size) * 8n) - 1n;
+    }
+    else if (typeof value_ === 'number') {
+        maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+    }
+    const minValue = typeof maxValue === 'bigint' && signed ? -maxValue - 1n : 0;
+    if ((maxValue && value > maxValue) || value < minValue) {
+        const suffix = typeof value_ === 'bigint' ? 'n' : '';
+        throw new IntegerOutOfRangeError({
+            max: maxValue ? `${maxValue}${suffix}` : undefined,
+            min: `${minValue}${suffix}`,
+            signed,
+            size,
+            value: `${value_}${suffix}`,
+        });
+    }
+    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size * 8)) + BigInt(value) : value).toString(16)}`;
+    if (size)
+        return pad(hex, { size });
+    return hex;
+}
+const encoder$1 = /*#__PURE__*/ new TextEncoder();
+/**
+ * Encodes a UTF-8 string into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex#stringtohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!')
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!', { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+ */
+function stringToHex(value_, opts = {}) {
+    const value = encoder$1.encode(value_);
+    return bytesToHex(value, opts);
+}
+
+const encoder = /*#__PURE__*/ new TextEncoder();
+/**
+ * Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes
+ * - Example: https://viem.sh/docs/utilities/toBytes#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes('Hello world')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
+ */
+function toBytes$1(value, opts = {}) {
+    if (typeof value === 'number' || typeof value === 'bigint')
+        return numberToBytes(value, opts);
+    if (typeof value === 'boolean')
+        return boolToBytes(value, opts);
+    if (isHex(value))
+        return hexToBytes(value, opts);
+    return stringToBytes(value, opts);
+}
+/**
+ * Encodes a boolean into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes#booltobytes
+ *
+ * @param value Boolean value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true)
+ * // Uint8Array([1])
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true, { size: 32 })
+ * // Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+ */
+function boolToBytes(value, opts = {}) {
+    const bytes = new Uint8Array(1);
+    bytes[0] = Number(value);
+    if (typeof opts.size === 'number') {
+        assertSize(bytes, { size: opts.size });
+        return pad(bytes, { size: opts.size });
+    }
+    return bytes;
+}
+// We use very optimized technique to convert hex string to byte array
+const charCodeMap = {
+    zero: 48,
+    nine: 57,
+    A: 65,
+    F: 70,
+    a: 97,
+    f: 102,
+};
+function charCodeToBase16(char) {
+    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+        return char - charCodeMap.zero;
+    if (char >= charCodeMap.A && char <= charCodeMap.F)
+        return char - (charCodeMap.A - 10);
+    if (char >= charCodeMap.a && char <= charCodeMap.f)
+        return char - (charCodeMap.a - 10);
+    return undefined;
+}
+/**
+ * Encodes a hex string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes#hextobytes
+ *
+ * @param hex Hex string to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+ */
+function hexToBytes(hex_, opts = {}) {
+    let hex = hex_;
+    if (opts.size) {
+        assertSize(hex, { size: opts.size });
+        hex = pad(hex, { dir: 'right', size: opts.size });
+    }
+    let hexString = hex.slice(2);
+    if (hexString.length % 2)
+        hexString = `0${hexString}`;
+    const length = hexString.length / 2;
+    const bytes = new Uint8Array(length);
+    for (let index = 0, j = 0; index < length; index++) {
+        const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+        const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+        if (nibbleLeft === undefined || nibbleRight === undefined) {
+            throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+        }
+        bytes[index] = nibbleLeft * 16 + nibbleRight;
+    }
+    return bytes;
+}
+/**
+ * Encodes a number into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes#numbertobytes
+ *
+ * @param value Number to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
+ */
+function numberToBytes(value, opts) {
+    const hex = numberToHex(value, opts);
+    return hexToBytes(hex);
+}
+/**
+ * Encodes a UTF-8 string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes#stringtobytes
+ *
+ * @param value String to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+ */
+function stringToBytes(value, opts = {}) {
+    const bytes = encoder.encode(value);
+    if (typeof opts.size === 'number') {
+        assertSize(bytes, { size: opts.size });
+        return pad(bytes, { dir: 'right', size: opts.size });
+    }
+    return bytes;
+}
+
+function assertSize(hexOrBytes, { size: size$1 }) {
+    if (size(hexOrBytes) > size$1)
+        throw new SizeOverflowError({
+            givenSize: size(hexOrBytes),
+            maxSize: size$1,
+        });
+}
+/**
+ * Decodes a hex value into a bigint.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromHex#hextobigint
+ *
+ * @param hex Hex value to decode.
+ * @param opts Options.
+ * @returns BigInt value.
+ *
+ * @example
+ * import { hexToBigInt } from 'viem'
+ * const data = hexToBigInt('0x1a4', { signed: true })
+ * // 420n
+ *
+ * @example
+ * import { hexToBigInt } from 'viem'
+ * const data = hexToBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+ * // 420n
+ */
+function hexToBigInt(hex, opts = {}) {
+    const { signed } = opts;
+    if (opts.size)
+        assertSize(hex, { size: opts.size });
+    const value = BigInt(hex);
+    if (!signed)
+        return value;
+    const size = (hex.length - 2) / 2;
+    const max = (1n << (BigInt(size) * 8n - 1n)) - 1n;
+    if (value <= max)
+        return value;
+    return value - BigInt(`0x${'f'.padStart(size * 2, 'f')}`) - 1n;
+}
+/**
+ * Decodes a hex string into a number.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromHex#hextonumber
+ *
+ * @param hex Hex value to decode.
+ * @param opts Options.
+ * @returns Number value.
+ *
+ * @example
+ * import { hexToNumber } from 'viem'
+ * const data = hexToNumber('0x1a4')
+ * // 420
+ *
+ * @example
+ * import { hexToNumber } from 'viem'
+ * const data = hexToBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+ * // 420
+ */
+function hexToNumber(hex, opts = {}) {
+    const value = hexToBigInt(hex, opts);
+    const number = Number(value);
+    if (!Number.isSafeInteger(number))
+        throw new IntegerOutOfRangeError({
+            max: `${Number.MAX_SAFE_INTEGER}`,
+            min: `${Number.MIN_SAFE_INTEGER}`,
+            signed: opts.signed,
+            size: opts.size,
+            value: `${value}n`,
+        });
+    return number;
+}
+
+function defineFormatter(type, format) {
+    return ({ exclude, format: overrides, }) => {
+        return {
+            exclude,
+            format: (args, action) => {
+                const formatted = format(args, action);
+                if (exclude) {
+                    for (const key of exclude) {
+                        delete formatted[key];
+                    }
+                }
+                return {
+                    ...formatted,
+                    ...overrides(args, action),
+                };
+            },
+            type,
+        };
+    };
+}
+
+const transactionType = {
+    '0x0': 'legacy',
+    '0x1': 'eip2930',
+    '0x2': 'eip1559',
+    '0x3': 'eip4844',
+    '0x4': 'eip7702',
+};
+function formatTransaction(transaction, _) {
+    const transaction_ = {
+        ...transaction,
+        blockHash: transaction.blockHash ? transaction.blockHash : null,
+        blockNumber: transaction.blockNumber
+            ? BigInt(transaction.blockNumber)
+            : null,
+        chainId: transaction.chainId ? hexToNumber(transaction.chainId) : undefined,
+        gas: transaction.gas ? BigInt(transaction.gas) : undefined,
+        gasPrice: transaction.gasPrice ? BigInt(transaction.gasPrice) : undefined,
+        maxFeePerBlobGas: transaction.maxFeePerBlobGas
+            ? BigInt(transaction.maxFeePerBlobGas)
+            : undefined,
+        maxFeePerGas: transaction.maxFeePerGas
+            ? BigInt(transaction.maxFeePerGas)
+            : undefined,
+        maxPriorityFeePerGas: transaction.maxPriorityFeePerGas
+            ? BigInt(transaction.maxPriorityFeePerGas)
+            : undefined,
+        nonce: transaction.nonce ? hexToNumber(transaction.nonce) : undefined,
+        to: transaction.to ? transaction.to : null,
+        transactionIndex: transaction.transactionIndex
+            ? Number(transaction.transactionIndex)
+            : null,
+        type: transaction.type
+            ? transactionType[transaction.type]
+            : undefined,
+        typeHex: transaction.type ? transaction.type : undefined,
+        value: transaction.value ? BigInt(transaction.value) : undefined,
+        v: transaction.v ? BigInt(transaction.v) : undefined,
+    };
+    if (transaction.authorizationList)
+        transaction_.authorizationList = formatAuthorizationList(transaction.authorizationList);
+    transaction_.yParity = (() => {
+        // If `yParity` is provided, we will use it.
+        if (transaction.yParity)
+            return Number(transaction.yParity);
+        // If no `yParity` provided, try derive from `v`.
+        if (typeof transaction_.v === 'bigint') {
+            if (transaction_.v === 0n || transaction_.v === 27n)
+                return 0;
+            if (transaction_.v === 1n || transaction_.v === 28n)
+                return 1;
+            if (transaction_.v >= 35n)
+                return transaction_.v % 2n === 0n ? 1 : 0;
+        }
+        return undefined;
+    })();
+    if (transaction_.type === 'legacy') {
+        delete transaction_.accessList;
+        delete transaction_.maxFeePerBlobGas;
+        delete transaction_.maxFeePerGas;
+        delete transaction_.maxPriorityFeePerGas;
+        delete transaction_.yParity;
+    }
+    if (transaction_.type === 'eip2930') {
+        delete transaction_.maxFeePerBlobGas;
+        delete transaction_.maxFeePerGas;
+        delete transaction_.maxPriorityFeePerGas;
+    }
+    if (transaction_.type === 'eip1559')
+        delete transaction_.maxFeePerBlobGas;
+    return transaction_;
+}
+const defineTransaction = /*#__PURE__*/ defineFormatter('transaction', formatTransaction);
+//////////////////////////////////////////////////////////////////////////////
+function formatAuthorizationList(authorizationList) {
+    return authorizationList.map((authorization) => ({
+        address: authorization.address,
+        chainId: Number(authorization.chainId),
+        nonce: Number(authorization.nonce),
+        r: authorization.r,
+        s: authorization.s,
+        yParity: Number(authorization.yParity),
+    }));
+}
+
+function formatBlock(block, _) {
+    const transactions = (block.transactions ?? []).map((transaction) => {
+        if (typeof transaction === 'string')
+            return transaction;
+        return formatTransaction(transaction);
+    });
+    return {
+        ...block,
+        baseFeePerGas: block.baseFeePerGas ? BigInt(block.baseFeePerGas) : null,
+        blobGasUsed: block.blobGasUsed ? BigInt(block.blobGasUsed) : undefined,
+        difficulty: block.difficulty ? BigInt(block.difficulty) : undefined,
+        excessBlobGas: block.excessBlobGas
+            ? BigInt(block.excessBlobGas)
+            : undefined,
+        gasLimit: block.gasLimit ? BigInt(block.gasLimit) : undefined,
+        gasUsed: block.gasUsed ? BigInt(block.gasUsed) : undefined,
+        hash: block.hash ? block.hash : null,
+        logsBloom: block.logsBloom ? block.logsBloom : null,
+        nonce: block.nonce ? block.nonce : null,
+        number: block.number ? BigInt(block.number) : null,
+        size: block.size ? BigInt(block.size) : undefined,
+        timestamp: block.timestamp ? BigInt(block.timestamp) : undefined,
+        transactions,
+        totalDifficulty: block.totalDifficulty
+            ? BigInt(block.totalDifficulty)
+            : null,
+    };
+}
+const defineBlock = /*#__PURE__*/ defineFormatter('block', formatBlock);
+
+function formatLog(log, { args, eventName, } = {}) {
+    return {
+        ...log,
+        blockHash: log.blockHash ? log.blockHash : null,
+        blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
+        blockTimestamp: log.blockTimestamp
+            ? BigInt(log.blockTimestamp)
+            : log.blockTimestamp === null
+                ? null
+                : undefined,
+        logIndex: log.logIndex ? Number(log.logIndex) : null,
+        transactionHash: log.transactionHash ? log.transactionHash : null,
+        transactionIndex: log.transactionIndex
+            ? Number(log.transactionIndex)
+            : null,
+        ...(eventName ? { args, eventName } : {}),
+    };
+}
+
+const receiptStatuses = {
+    '0x0': 'reverted',
+    '0x1': 'success',
+};
+function formatTransactionReceipt(transactionReceipt, _) {
+    const receipt = {
+        ...transactionReceipt,
+        blockNumber: transactionReceipt.blockNumber
+            ? BigInt(transactionReceipt.blockNumber)
+            : null,
+        contractAddress: transactionReceipt.contractAddress
+            ? transactionReceipt.contractAddress
+            : null,
+        cumulativeGasUsed: transactionReceipt.cumulativeGasUsed
+            ? BigInt(transactionReceipt.cumulativeGasUsed)
+            : null,
+        effectiveGasPrice: transactionReceipt.effectiveGasPrice
+            ? BigInt(transactionReceipt.effectiveGasPrice)
+            : null,
+        gasUsed: transactionReceipt.gasUsed
+            ? BigInt(transactionReceipt.gasUsed)
+            : null,
+        logs: transactionReceipt.logs
+            ? transactionReceipt.logs.map((log) => formatLog(log))
+            : null,
+        to: transactionReceipt.to ? transactionReceipt.to : null,
+        transactionIndex: transactionReceipt.transactionIndex
+            ? hexToNumber(transactionReceipt.transactionIndex)
+            : null,
+        status: transactionReceipt.status
+            ? receiptStatuses[transactionReceipt.status]
+            : null,
+        type: transactionReceipt.type
+            ? transactionType[transactionReceipt.type] || transactionReceipt.type
+            : null,
+    };
+    if (transactionReceipt.blobGasPrice)
+        receipt.blobGasPrice = BigInt(transactionReceipt.blobGasPrice);
+    if (transactionReceipt.blobGasUsed)
+        receipt.blobGasUsed = BigInt(transactionReceipt.blobGasUsed);
+    return receipt;
+}
+const defineTransactionReceipt = /*#__PURE__*/ defineFormatter('transactionReceipt', formatTransactionReceipt);
+
+const maxUint256 = 2n ** 256n - 1n;
+
+function concatHex(values) {
+    return `0x${values.reduce((acc, x) => acc + x.replace('0x', ''), '')}`;
+}
+
+class NegativeOffsetError extends BaseError {
+    constructor({ offset }) {
+        super(`Offset \`${offset}\` cannot be negative.`, {
+            name: 'NegativeOffsetError',
+        });
+    }
+}
+class PositionOutOfBoundsError extends BaseError {
+    constructor({ length, position }) {
+        super(`Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`, { name: 'PositionOutOfBoundsError' });
+    }
+}
+class RecursiveReadLimitExceededError extends BaseError {
+    constructor({ count, limit }) {
+        super(`Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`, { name: 'RecursiveReadLimitExceededError' });
+    }
+}
+
+const staticCursor = {
+    bytes: new Uint8Array(),
+    dataView: new DataView(new ArrayBuffer(0)),
+    position: 0,
+    positionReadCount: new Map(),
+    recursiveReadCount: 0,
+    recursiveReadLimit: Number.POSITIVE_INFINITY,
+    assertReadLimit() {
+        if (this.recursiveReadCount >= this.recursiveReadLimit)
+            throw new RecursiveReadLimitExceededError({
+                count: this.recursiveReadCount + 1,
+                limit: this.recursiveReadLimit,
+            });
+    },
+    assertPosition(position) {
+        if (position < 0 || position > this.bytes.length - 1)
+            throw new PositionOutOfBoundsError({
+                length: this.bytes.length,
+                position,
+            });
+    },
+    decrementPosition(offset) {
+        if (offset < 0)
+            throw new NegativeOffsetError({ offset });
+        const position = this.position - offset;
+        this.assertPosition(position);
+        this.position = position;
+    },
+    getReadCount(position) {
+        return this.positionReadCount.get(position || this.position) || 0;
+    },
+    incrementPosition(offset) {
+        if (offset < 0)
+            throw new NegativeOffsetError({ offset });
+        const position = this.position + offset;
+        this.assertPosition(position);
+        this.position = position;
+    },
+    inspectByte(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position);
+        return this.bytes[position];
+    },
+    inspectBytes(length, position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position + length - 1);
+        return this.bytes.subarray(position, position + length);
+    },
+    inspectUint8(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position);
+        return this.bytes[position];
+    },
+    inspectUint16(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position + 1);
+        return this.dataView.getUint16(position);
+    },
+    inspectUint24(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position + 2);
+        return ((this.dataView.getUint16(position) << 8) +
+            this.dataView.getUint8(position + 2));
+    },
+    inspectUint32(position_) {
+        const position = position_ ?? this.position;
+        this.assertPosition(position + 3);
+        return this.dataView.getUint32(position);
+    },
+    pushByte(byte) {
+        this.assertPosition(this.position);
+        this.bytes[this.position] = byte;
+        this.position++;
+    },
+    pushBytes(bytes) {
+        this.assertPosition(this.position + bytes.length - 1);
+        this.bytes.set(bytes, this.position);
+        this.position += bytes.length;
+    },
+    pushUint8(value) {
+        this.assertPosition(this.position);
+        this.bytes[this.position] = value;
+        this.position++;
+    },
+    pushUint16(value) {
+        this.assertPosition(this.position + 1);
+        this.dataView.setUint16(this.position, value);
+        this.position += 2;
+    },
+    pushUint24(value) {
+        this.assertPosition(this.position + 2);
+        this.dataView.setUint16(this.position, value >> 8);
+        this.dataView.setUint8(this.position + 2, value & 255);
+        this.position += 3;
+    },
+    pushUint32(value) {
+        this.assertPosition(this.position + 3);
+        this.dataView.setUint32(this.position, value);
+        this.position += 4;
+    },
+    readByte() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectByte();
+        this.position++;
+        return value;
+    },
+    readBytes(length, size) {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectBytes(length);
+        this.position += size ?? length;
+        return value;
+    },
+    readUint8() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectUint8();
+        this.position += 1;
+        return value;
+    },
+    readUint16() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectUint16();
+        this.position += 2;
+        return value;
+    },
+    readUint24() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectUint24();
+        this.position += 3;
+        return value;
+    },
+    readUint32() {
+        this.assertReadLimit();
+        this._touch();
+        const value = this.inspectUint32();
+        this.position += 4;
+        return value;
+    },
+    get remaining() {
+        return this.bytes.length - this.position;
+    },
+    setPosition(position) {
+        const oldPosition = this.position;
+        this.assertPosition(position);
+        this.position = position;
+        return () => (this.position = oldPosition);
+    },
+    _touch() {
+        if (this.recursiveReadLimit === Number.POSITIVE_INFINITY)
+            return;
+        const count = this.getReadCount();
+        this.positionReadCount.set(this.position, count + 1);
+        if (count > 0)
+            this.recursiveReadCount++;
+    },
+};
+function createCursor(bytes, { recursiveReadLimit = 8_192 } = {}) {
+    const cursor = Object.create(staticCursor);
+    cursor.bytes = bytes;
+    cursor.dataView = new DataView(bytes.buffer ?? bytes, bytes.byteOffset, bytes.byteLength);
+    cursor.positionReadCount = new Map();
+    cursor.recursiveReadLimit = recursiveReadLimit;
+    return cursor;
+}
+
+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 getEncodable(bytes) {
+    if (Array.isArray(bytes))
+        return getEncodableList(bytes.map((x) => getEncodable(x)));
+    return getEncodableBytes(bytes);
+}
+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.');
+}
+
+const gweiUnits = {
+    ether: -9,
+    wei: 9,
+};
+
+/**
+ *  Divides a number by a given exponent of base 10 (10exponent), and formats it into a string representation of the number..
+ *
+ * - Docs: https://viem.sh/docs/utilities/formatUnits
+ *
+ * @example
+ * import { formatUnits } from 'viem'
+ *
+ * formatUnits(420000000000n, 9)
+ * // '420'
+ */
+function formatUnits(value, decimals) {
+    let display = value.toString();
+    const negative = display.startsWith('-');
+    if (negative)
+        display = display.slice(1);
+    display = display.padStart(decimals, '0');
+    let [integer, fraction] = [
+        display.slice(0, display.length - decimals),
+        display.slice(display.length - decimals),
+    ];
+    fraction = fraction.replace(/(0+)$/, '');
+    return `${negative ? '-' : ''}${integer || '0'}${fraction ? `.${fraction}` : ''}`;
+}
+
+/**
+ * Converts numerical wei to a string representation of gwei.
+ *
+ * - Docs: https://viem.sh/docs/utilities/formatGwei
+ *
+ * @example
+ * import { formatGwei } from 'viem'
+ *
+ * formatGwei(1000000000n)
+ * // '1'
+ */
+function formatGwei(wei, unit = 'wei') {
+    return formatUnits(wei, gweiUnits[unit]);
+}
+
+function prettyPrint(args) {
+    const entries = Object.entries(args)
+        .map(([key, value]) => {
+        if (value === undefined || value === false)
+            return null;
+        return [key, value];
+    })
+        .filter(Boolean);
+    const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0);
+    return entries
+        .map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`)
+        .join('\n');
+}
+class InvalidLegacyVError extends BaseError {
+    constructor({ v }) {
+        super(`Invalid \`v\` value "${v}". Expected 27 or 28.`, {
+            name: 'InvalidLegacyVError',
+        });
+    }
+}
+class InvalidSerializableTransactionError extends BaseError {
+    constructor({ transaction }) {
+        super('Cannot infer a transaction type from provided transaction.', {
+            metaMessages: [
+                'Provided Transaction:',
+                '{',
+                prettyPrint(transaction),
+                '}',
+                '',
+                'To infer the type, either provide:',
+                '- a `type` to the Transaction, or',
+                '- an EIP-1559 Transaction with `maxFeePerGas`, or',
+                '- an EIP-2930 Transaction with `gasPrice` & `accessList`, or',
+                '- an EIP-4844 Transaction with `blobs`, `blobVersionedHashes`, `sidecars`, or',
+                '- an EIP-7702 Transaction with `authorizationList`, or',
+                '- a Legacy Transaction with `gasPrice`',
+            ],
+            name: 'InvalidSerializableTransactionError',
+        });
+    }
+}
+class InvalidStorageKeySizeError extends BaseError {
+    constructor({ storageKey }) {
+        super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Math.floor((storageKey.length - 2) / 2)} bytes.`, { name: 'InvalidStorageKeySizeError' });
+    }
+}
+
+/*
+ * Serializes an EIP-7702 authorization list.
+ */
+function serializeAuthorizationList(authorizationList) {
+    if (!authorizationList || authorizationList.length === 0)
+        return [];
+    const serializedAuthorizationList = [];
+    for (const authorization of authorizationList) {
+        const { chainId, nonce, ...signature } = authorization;
+        const contractAddress = authorization.address;
+        serializedAuthorizationList.push([
+            chainId ? toHex(chainId) : '0x',
+            contractAddress,
+            nonce ? toHex(nonce) : '0x',
+            ...toYParitySignatureArray({}, signature),
+        ]);
+    }
+    return serializedAuthorizationList;
+}
+
+/**
+ * Compute commitments from a list of blobs.
+ *
+ * @example
+ * ```ts
+ * import { blobsToCommitments, toBlobs } from 'viem'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = toBlobs({ data: '0x1234' })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * ```
+ */
+function blobsToCommitments(parameters) {
+    const { kzg } = parameters;
+    const to = parameters.to ?? (typeof parameters.blobs[0] === 'string' ? 'hex' : 'bytes');
+    const blobs = (typeof parameters.blobs[0] === 'string'
+        ? parameters.blobs.map((x) => hexToBytes(x))
+        : parameters.blobs);
+    const commitments = [];
+    for (const blob of blobs)
+        commitments.push(Uint8Array.from(kzg.blobToKzgCommitment(blob)));
+    return (to === 'bytes'
+        ? commitments
+        : commitments.map((x) => bytesToHex(x)));
+}
+
+/**
+ * Compute the proofs for a list of blobs and their commitments.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   toBlobs
+ * } from 'viem'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = toBlobs({ data: '0x1234' })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * const proofs = blobsToProofs({ blobs, commitments, kzg })
+ * ```
+ */
+function blobsToProofs(parameters) {
+    const { kzg } = parameters;
+    const to = parameters.to ?? (typeof parameters.blobs[0] === 'string' ? 'hex' : 'bytes');
+    const blobs = (typeof parameters.blobs[0] === 'string'
+        ? parameters.blobs.map((x) => hexToBytes(x))
+        : parameters.blobs);
+    const commitments = (typeof parameters.commitments[0] === 'string'
+        ? parameters.commitments.map((x) => hexToBytes(x))
+        : parameters.commitments);
+    const proofs = [];
+    for (let i = 0; i < blobs.length; i++) {
+        const blob = blobs[i];
+        const commitment = commitments[i];
+        proofs.push(Uint8Array.from(kzg.computeBlobKzgProof(blob, commitment)));
+    }
+    return (to === 'bytes'
+        ? proofs
+        : proofs.map((x) => bytesToHex(x)));
+}
+
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+/** Asserts something is positive integer. */
+function anumber(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error('positive integer expected, got ' + n);
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+    abytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error('digestInto() expects output buffer of length at least ' + min);
+    }
+}
+/** Cast u8 / u16 / u32 to u32. */
+function u32(arr) {
+    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+    }
+}
+/** Create DataView of an array for easy byte-level manipulation. */
+function createView(arr) {
+    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+    return (word << (32 - shift)) | (word >>> shift);
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+/** The byte swap operation for uint32 */
+function byteSwap(word) {
+    return (((word << 24) & 0xff000000) |
+        ((word << 8) & 0xff0000) |
+        ((word >>> 8) & 0xff00) |
+        ((word >>> 24) & 0xff));
+}
+/** In place byte swap for Uint32Array */
+function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = byteSwap(arr[i]);
+    }
+    return arr;
+}
+const swap32IfBE = isLE
+    ? (u) => u
+    : byteSwap32;
+/**
+ * Converts string to bytes using UTF8 encoding.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+ */
+function utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error('string expected');
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes(data);
+    abytes(data);
+    return data;
+}
+/** For runtime check if class implements interface */
+class Hash {
+}
+/** Wraps hash function, creating an interface on top of it */
+function createHasher(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+}
+
+/**
+ * Internal Merkle-Damgard hash utils.
+ * @module
+ */
+/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
+function setBigUint64(view, byteOffset, value, isLE) {
+    if (typeof view.setBigUint64 === 'function')
+        return view.setBigUint64(byteOffset, value, isLE);
+    const _32n = BigInt(32);
+    const _u32_max = BigInt(0xffffffff);
+    const wh = Number((value >> _32n) & _u32_max);
+    const wl = Number(value & _u32_max);
+    const h = isLE ? 4 : 0;
+    const l = isLE ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE);
+    view.setUint32(byteOffset + l, wl, isLE);
+}
+/** Choice: a ? b : c */
+function Chi(a, b, c) {
+    return (a & b) ^ (~a & c);
+}
+/** Majority function, true if any two inputs is true. */
+function Maj(a, b, c) {
+    return (a & b) ^ (a & c) ^ (b & c);
+}
+/**
+ * Merkle-Damgard hash construction base class.
+ * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+ */
+class HashMD extends Hash {
+    constructor(blockLen, outputLen, padOffset, isLE) {
+        super();
+        this.finished = false;
+        this.length = 0;
+        this.pos = 0;
+        this.destroyed = false;
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.padOffset = padOffset;
+        this.isLE = isLE;
+        this.buffer = new Uint8Array(blockLen);
+        this.view = createView(this.buffer);
+    }
+    update(data) {
+        aexists(this);
+        data = toBytes(data);
+        abytes(data);
+        const { view, buffer, blockLen } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            // Fast path: we have at least one block in input, cast it to view and process
+            if (take === blockLen) {
+                const dataView = createView(data);
+                for (; blockLen <= len - pos; pos += blockLen)
+                    this.process(dataView, pos);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            pos += take;
+            if (this.pos === blockLen) {
+                this.process(view, 0);
+                this.pos = 0;
+            }
+        }
+        this.length += data.length;
+        this.roundClean();
+        return this;
+    }
+    digestInto(out) {
+        aexists(this);
+        aoutput(out, this);
+        this.finished = true;
+        // Padding
+        // We can avoid allocation of buffer for padding completely if it
+        // was previously not allocated here. But it won't change performance.
+        const { buffer, view, blockLen, isLE } = this;
+        let { pos } = this;
+        // append the bit '1' to the message
+        buffer[pos++] = 0b10000000;
+        clean(this.buffer.subarray(pos));
+        // we have less than padOffset left in buffer, so we cannot put length in
+        // current block, need process it and pad again
+        if (this.padOffset > blockLen - pos) {
+            this.process(view, 0);
+            pos = 0;
+        }
+        // Pad until full block byte with zeros
+        for (let i = pos; i < blockLen; i++)
+            buffer[i] = 0;
+        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+        // So we just write lowest 64 bits of that value.
+        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+        this.process(view, 0);
+        const oview = createView(out);
+        const len = this.outputLen;
+        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
+        if (len % 4)
+            throw new Error('_sha2: outputLen should be aligned to 32bit');
+        const outLen = len / 4;
+        const state = this.get();
+        if (outLen > state.length)
+            throw new Error('_sha2: outputLen bigger than state');
+        for (let i = 0; i < outLen; i++)
+            oview.setUint32(4 * i, state[i], isLE);
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        to || (to = new this.constructor());
+        to.set(...this.get());
+        const { blockLen, buffer, length, finished, destroyed, pos } = this;
+        to.destroyed = destroyed;
+        to.finished = finished;
+        to.length = length;
+        to.pos = pos;
+        if (length % blockLen)
+            to.buffer.set(buffer);
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+}
+/**
+ * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+ * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+ */
+/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
+
+/**
+ * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+ * @todo re-check https://issues.chromium.org/issues/42212588
+ * @module
+ */
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+    if (le)
+        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
+    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+    const len = lst.length;
+    let Ah = new Uint32Array(len);
+    let Al = new Uint32Array(len);
+    for (let i = 0; i < len; i++) {
+        const { h, l } = fromBig(lst[i], le);
+        [Ah[i], Al[i]] = [h, l];
+    }
+    return [Ah, Al];
+}
+// Left rotate for Shift in [1, 32)
+const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+
+/**
+ * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+ * SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+ * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+ * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * @module
+ */
+/**
+ * Round constants:
+ * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+ */
+// prettier-ignore
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+/** Reusable temporary buffer. "W" comes straight from spec. */
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+class SHA256 extends HashMD {
+    constructor(outputLen = 32) {
+        super(64, outputLen, 8, false);
+        // We cannot use array here since array allows indexing by variable
+        // which means optimizer/compiler cannot use registers.
+        this.A = SHA256_IV[0] | 0;
+        this.B = SHA256_IV[1] | 0;
+        this.C = SHA256_IV[2] | 0;
+        this.D = SHA256_IV[3] | 0;
+        this.E = SHA256_IV[4] | 0;
+        this.F = SHA256_IV[5] | 0;
+        this.G = SHA256_IV[6] | 0;
+        this.H = SHA256_IV[7] | 0;
+    }
+    get() {
+        const { A, B, C, D, E, F, G, H } = this;
+        return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+        this.A = A | 0;
+        this.B = B | 0;
+        this.C = C | 0;
+        this.D = D | 0;
+        this.E = E | 0;
+        this.F = F | 0;
+        this.G = G | 0;
+        this.H = H | 0;
+    }
+    process(view, offset) {
+        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+        for (let i = 0; i < 16; i++, offset += 4)
+            SHA256_W[i] = view.getUint32(offset, false);
+        for (let i = 16; i < 64; i++) {
+            const W15 = SHA256_W[i - 15];
+            const W2 = SHA256_W[i - 2];
+            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
+            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
+            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+        }
+        // Compression function main loop, 64 rounds
+        let { A, B, C, D, E, F, G, H } = this;
+        for (let i = 0; i < 64; i++) {
+            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+            const T2 = (sigma0 + Maj(A, B, C)) | 0;
+            H = G;
+            G = F;
+            F = E;
+            E = (D + T1) | 0;
+            D = C;
+            C = B;
+            B = A;
+            A = (T1 + T2) | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        A = (A + this.A) | 0;
+        B = (B + this.B) | 0;
+        C = (C + this.C) | 0;
+        D = (D + this.D) | 0;
+        E = (E + this.E) | 0;
+        F = (F + this.F) | 0;
+        G = (G + this.G) | 0;
+        H = (H + this.H) | 0;
+        this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+        clean(SHA256_W);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+        clean(this.buffer);
+    }
+}
+/**
+ * SHA2-256 hash function from RFC 4634.
+ *
+ * It is the fastest JS hash, even faster than Blake3.
+ * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+ * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ */
+const sha256$2 = /* @__PURE__ */ createHasher(() => new SHA256());
+
+/**
+ * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
+ *
+ * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+ * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ *
+ * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * @module
+ * @deprecated
+ */
+/** @deprecated Use import from `noble/hashes/sha2` module */
+const sha256$1 = sha256$2;
+
+function sha256(value, to_) {
+    const bytes = sha256$1(isHex(value, { strict: false }) ? toBytes$1(value) : value);
+    return bytes;
+}
+
+/**
+ * Transform a commitment to it's versioned hash.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   commitmentToVersionedHash,
+ *   toBlobs
+ * } from 'viem'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = toBlobs({ data: '0x1234' })
+ * const [commitment] = blobsToCommitments({ blobs, kzg })
+ * const versionedHash = commitmentToVersionedHash({ commitment })
+ * ```
+ */
+function commitmentToVersionedHash(parameters) {
+    const { commitment, version = 1 } = parameters;
+    const to = parameters.to ?? (typeof commitment === 'string' ? 'hex' : 'bytes');
+    const versionedHash = sha256(commitment);
+    versionedHash.set([version], 0);
+    return (to === 'bytes' ? versionedHash : bytesToHex(versionedHash));
+}
+
+/**
+ * Transform a list of commitments to their versioned hashes.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   commitmentsToVersionedHashes,
+ *   toBlobs
+ * } from 'viem'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = toBlobs({ data: '0x1234' })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * const versionedHashes = commitmentsToVersionedHashes({ commitments })
+ * ```
+ */
+function commitmentsToVersionedHashes(parameters) {
+    const { commitments, version } = parameters;
+    const to = parameters.to ?? (typeof commitments[0] === 'string' ? 'hex' : 'bytes');
+    const hashes = [];
+    for (const commitment of commitments) {
+        hashes.push(commitmentToVersionedHash({
+            commitment,
+            to,
+            version,
+        }));
+    }
+    return hashes;
+}
+
+// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-4844.md#parameters
+/** Blob limit per transaction. */
+const blobsPerTransaction = 6;
+/** The number of bytes in a BLS scalar field element. */
+const bytesPerFieldElement = 32;
+/** The number of field elements in a blob. */
+const fieldElementsPerBlob = 4096;
+/** The number of bytes in a blob. */
+const bytesPerBlob = bytesPerFieldElement * fieldElementsPerBlob;
+/** Blob bytes limit per transaction. */
+const maxBytesPerTransaction = bytesPerBlob * blobsPerTransaction -
+    // terminator byte (0x80).
+    1 -
+    // zero byte (0x00) appended to each field element.
+    1 * fieldElementsPerBlob * blobsPerTransaction;
+
+// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-4844.md#parameters
+const versionedHashVersionKzg = 1;
+
+class BlobSizeTooLargeError extends BaseError {
+    constructor({ maxSize, size }) {
+        super('Blob size is too large.', {
+            metaMessages: [`Max: ${maxSize} bytes`, `Given: ${size} bytes`],
+            name: 'BlobSizeTooLargeError',
+        });
+    }
+}
+class EmptyBlobError extends BaseError {
+    constructor() {
+        super('Blob data must not be empty.', { name: 'EmptyBlobError' });
+    }
+}
+class InvalidVersionedHashSizeError extends BaseError {
+    constructor({ hash, size, }) {
+        super(`Versioned hash "${hash}" size is invalid.`, {
+            metaMessages: ['Expected: 32', `Received: ${size}`],
+            name: 'InvalidVersionedHashSizeError',
+        });
+    }
+}
+class InvalidVersionedHashVersionError extends BaseError {
+    constructor({ hash, version, }) {
+        super(`Versioned hash "${hash}" version is invalid.`, {
+            metaMessages: [
+                `Expected: ${versionedHashVersionKzg}`,
+                `Received: ${version}`,
+            ],
+            name: 'InvalidVersionedHashVersionError',
+        });
+    }
+}
+
+/**
+ * Transforms arbitrary data to blobs.
+ *
+ * @example
+ * ```ts
+ * import { toBlobs, stringToHex } from 'viem'
+ *
+ * const blobs = toBlobs({ data: stringToHex('hello world') })
+ * ```
+ */
+function toBlobs(parameters) {
+    const to = parameters.to ?? (typeof parameters.data === 'string' ? 'hex' : 'bytes');
+    const data = (typeof parameters.data === 'string'
+        ? hexToBytes(parameters.data)
+        : parameters.data);
+    const size_ = size(data);
+    if (!size_)
+        throw new EmptyBlobError();
+    if (size_ > maxBytesPerTransaction)
+        throw new BlobSizeTooLargeError({
+            maxSize: maxBytesPerTransaction,
+            size: size_,
+        });
+    const blobs = [];
+    let active = true;
+    let position = 0;
+    while (active) {
+        const blob = createCursor(new Uint8Array(bytesPerBlob));
+        let size = 0;
+        while (size < fieldElementsPerBlob) {
+            const bytes = data.slice(position, position + (bytesPerFieldElement - 1));
+            // Push a zero byte so the field element doesn't overflow the BLS modulus.
+            blob.pushByte(0x00);
+            // Push the current segment of data bytes.
+            blob.pushBytes(bytes);
+            // If we detect that the current segment of data bytes is less than 31 bytes,
+            // we can stop processing and push a terminator byte to indicate the end of the blob.
+            if (bytes.length < 31) {
+                blob.pushByte(0x80);
+                active = false;
+                break;
+            }
+            size++;
+            position += 31;
+        }
+        blobs.push(blob);
+    }
+    return (to === 'bytes'
+        ? blobs.map((x) => x.bytes)
+        : blobs.map((x) => bytesToHex(x.bytes)));
+}
+
+/**
+ * Transforms arbitrary data (or blobs, commitments, & proofs) into a sidecar array.
+ *
+ * @example
+ * ```ts
+ * import { toBlobSidecars, stringToHex } from 'viem'
+ *
+ * const sidecars = toBlobSidecars({ data: stringToHex('hello world') })
+ * ```
+ *
+ * @example
+ * ```ts
+ * import {
+ *   blobsToCommitments,
+ *   toBlobs,
+ *   blobsToProofs,
+ *   toBlobSidecars,
+ *   stringToHex
+ * } from 'viem'
+ *
+ * const blobs = toBlobs({ data: stringToHex('hello world') })
+ * const commitments = blobsToCommitments({ blobs, kzg })
+ * const proofs = blobsToProofs({ blobs, commitments, kzg })
+ *
+ * const sidecars = toBlobSidecars({ blobs, commitments, proofs })
+ * ```
+ */
+function toBlobSidecars(parameters) {
+    const { data, kzg, to } = parameters;
+    const blobs = parameters.blobs ?? toBlobs({ data: data, to });
+    const commitments = parameters.commitments ?? blobsToCommitments({ blobs, kzg: kzg, to });
+    const proofs = parameters.proofs ?? blobsToProofs({ blobs, commitments, kzg: kzg, to });
+    const sidecars = [];
+    for (let i = 0; i < blobs.length; i++)
+        sidecars.push({
+            blob: blobs[i],
+            commitment: commitments[i],
+            proof: proofs[i],
+        });
+    return sidecars;
+}
+
+class InvalidAddressError extends BaseError {
+    constructor({ address }) {
+        super(`Address "${address}" is invalid.`, {
+            metaMessages: [
+                '- Address must be a hex value of 20 bytes (40 hex characters).',
+                '- Address must match its checksum counterpart.',
+            ],
+            name: 'InvalidAddressError',
+        });
+    }
+}
+
+class InvalidChainIdError extends BaseError {
+    constructor({ chainId }) {
+        super(typeof chainId === 'number'
+            ? `Chain ID "${chainId}" is invalid.`
+            : 'Chain ID is invalid.', { name: 'InvalidChainIdError' });
+    }
+}
+
+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,
+            name: 'FeeCapTooHighError',
+        });
+    }
+}
+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,
+            name: '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/
+});
+
+/**
+ * Map with a LRU (Least recently used) policy.
+ *
+ * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+class LruMap extends Map {
+    constructor(size) {
+        super();
+        Object.defineProperty(this, "maxSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxSize = size;
+    }
+    get(key) {
+        const value = super.get(key);
+        if (super.has(key)) {
+            super.delete(key);
+            super.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (super.has(key))
+            super.delete(key);
+        super.set(key, value);
+        if (this.maxSize && this.size > this.maxSize) {
+            const firstKey = super.keys().next().value;
+            if (firstKey !== undefined)
+                super.delete(firstKey);
+        }
+        return this;
+    }
+}
+
+/**
+ * SHA3 (keccak) hash function, based on a new "Sponge function" design.
+ * Different from older hashes, the internal state is bigger than output size.
+ *
+ * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+ * [Website](https://keccak.team/keccak.html),
+ * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
+ *
+ * Check out `sha3-addons` module for cSHAKE, k12, and others.
+ * @module
+ */
+// No __PURE__ annotations in sha3 header:
+// EVERYTHING is in fact used on every export.
+// Various per round constants calculations
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _2n = BigInt(2);
+const _7n = BigInt(7);
+const _256n = BigInt(256);
+const _0x71n = BigInt(0x71);
+const SHA3_PI = [];
+const SHA3_ROTL = [];
+const _SHA3_IOTA = [];
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+    // Pi
+    [x, y] = [y, (2 * x + 3 * y) % 5];
+    SHA3_PI.push(2 * (5 * y + x));
+    // Rotational
+    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+    // Iota
+    let t = _0n;
+    for (let j = 0; j < 7; j++) {
+        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
+        if (R & _2n)
+            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);
+    }
+    _SHA3_IOTA.push(t);
+}
+const IOTAS = split(_SHA3_IOTA, true);
+const SHA3_IOTA_H = IOTAS[0];
+const SHA3_IOTA_L = IOTAS[1];
+// Left rotation (without 0, 32, 64)
+const rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
+const rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
+/** `keccakf1600` internal function, additionally allows to adjust round count. */
+function keccakP(s, rounds = 24) {
+    const B = new Uint32Array(5 * 2);
+    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
+    for (let round = 24 - rounds; round < 24; round++) {
+        // Theta θ
+        for (let x = 0; x < 10; x++)
+            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+        for (let x = 0; x < 10; x += 2) {
+            const idx1 = (x + 8) % 10;
+            const idx0 = (x + 2) % 10;
+            const B0 = B[idx0];
+            const B1 = B[idx0 + 1];
+            const Th = rotlH(B0, B1, 1) ^ B[idx1];
+            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+            for (let y = 0; y < 50; y += 10) {
+                s[x + y] ^= Th;
+                s[x + y + 1] ^= Tl;
+            }
+        }
+        // Rho (ρ) and Pi (π)
+        let curH = s[2];
+        let curL = s[3];
+        for (let t = 0; t < 24; t++) {
+            const shift = SHA3_ROTL[t];
+            const Th = rotlH(curH, curL, shift);
+            const Tl = rotlL(curH, curL, shift);
+            const PI = SHA3_PI[t];
+            curH = s[PI];
+            curL = s[PI + 1];
+            s[PI] = Th;
+            s[PI + 1] = Tl;
+        }
+        // Chi (χ)
+        for (let y = 0; y < 50; y += 10) {
+            for (let x = 0; x < 10; x++)
+                B[x] = s[y + x];
+            for (let x = 0; x < 10; x++)
+                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+        }
+        // Iota (ι)
+        s[0] ^= SHA3_IOTA_H[round];
+        s[1] ^= SHA3_IOTA_L[round];
+    }
+    clean(B);
+}
+/** Keccak sponge function. */
+class Keccak extends Hash {
+    // NOTE: we accept arguments in bytes instead of bits here.
+    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        super();
+        this.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
+        this.enableXOF = false;
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        // Can be passed from user as dkLen
+        anumber(outputLen);
+        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
+        // 0 < blockLen < 200
+        if (!(0 < blockLen && blockLen < 200))
+            throw new Error('only keccak-f1600 function is supported');
+        this.state = new Uint8Array(200);
+        this.state32 = u32(this.state);
+    }
+    clone() {
+        return this._cloneInto();
+    }
+    keccak() {
+        swap32IfBE(this.state32);
+        keccakP(this.state32, this.rounds);
+        swap32IfBE(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+    }
+    update(data) {
+        aexists(this);
+        data = toBytes(data);
+        abytes(data);
+        const { blockLen, state } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            for (let i = 0; i < take; i++)
+                state[this.pos++] ^= data[pos++];
+            if (this.pos === blockLen)
+                this.keccak();
+        }
+        return this;
+    }
+    finish() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        // Do the padding
+        state[pos] ^= suffix;
+        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
+            this.keccak();
+        state[blockLen - 1] ^= 0x80;
+        this.keccak();
+    }
+    writeInto(out) {
+        aexists(this, false);
+        abytes(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len;) {
+            if (this.posOut >= blockLen)
+                this.keccak();
+            const take = Math.min(blockLen - this.posOut, len - pos);
+            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+            this.posOut += take;
+            pos += take;
+        }
+        return out;
+    }
+    xofInto(out) {
+        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF
+        if (!this.enableXOF)
+            throw new Error('XOF is not possible for this instance');
+        return this.writeInto(out);
+    }
+    xof(bytes) {
+        anumber(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+        aoutput(out, this);
+        if (this.finished)
+            throw new Error('digest() was already called');
+        this.writeInto(out);
+        this.destroy();
+        return out;
+    }
+    digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+    }
+    destroy() {
+        this.destroyed = true;
+        clean(this.state);
+    }
+    _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        // Suffix can change in cSHAKE
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.destroyed = this.destroyed;
+        return to;
+    }
+}
+const gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
+/** keccak-256 hash function. Different from SHA3-256. */
+const keccak_256 = /* @__PURE__ */ (() => gen(0x01, 136, 256 / 8))();
+
+function keccak256(value, to_) {
+    const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes$1(value) : value);
+    return bytes;
+}
+
+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));
+    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();
+        }
+        if ((hash[i >> 1] & 0x0f) >= 8 && address[i + 1]) {
+            address[i + 1] = address[i + 1].toUpperCase();
+        }
+    }
+    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 ?? {};
+    const cacheKey = `${address}.${strict}`;
+    if (isAddressCache.has(cacheKey))
+        return isAddressCache.get(cacheKey);
+    const result = (() => {
+        if (!addressRegex.test(address))
+            return false;
+        if (address.toLowerCase() === address)
+            return true;
+        if (strict)
+            return checksumAddress(address) === address;
+        return true;
+    })();
+    isAddressCache.set(cacheKey, result);
+    return result;
+}
+
+/**
+ * @description Returns a section of the hex or byte array given a start/end bytes offset.
+ *
+ * @param value The hex or byte array to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+function slice(value, start, end, { strict } = {}) {
+    if (isHex(value, { strict: false }))
+        return sliceHex(value, start, end, {
+            strict,
+        });
+    return sliceBytes(value, start, end, {
+        strict,
+    });
+}
+function assertEndOffset(value, start, end) {
+    if (size(value) !== end - start) {
+        throw new SliceOffsetOutOfBoundsError({
+            offset: end,
+            position: 'end',
+            size: size(value),
+        });
+    }
+}
+/**
+ * @description Returns a section of the byte array given a start/end bytes offset.
+ *
+ * @param value The byte array to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+function sliceBytes(value_, start, end, { strict } = {}) {
+    const value = value_.slice(start, end);
+    if (strict)
+        assertEndOffset(value, start, end);
+    return value;
+}
+/**
+ * @description Returns a section of the hex value given a start/end bytes offset.
+ *
+ * @param value The hex value to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+function sliceHex(value_, start, end, { strict } = {}) {
+    const value = `0x${value_
+        .replace('0x', '')
+        .slice((start) * 2, (end) * 2)}`;
+    if (strict)
+        assertEndOffset(value, start, end);
+    return value;
+}
+
+function assertTransactionEIP7702(transaction) {
+    const { authorizationList } = transaction;
+    if (authorizationList) {
+        for (const authorization of authorizationList) {
+            const { chainId } = authorization;
+            const address = authorization.address;
+            if (!isAddress(address))
+                throw new InvalidAddressError({ address });
+            if (chainId < 0)
+                throw new InvalidChainIdError({ chainId });
+        }
+    }
+    assertTransactionEIP1559(transaction);
+}
+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,
+                });
+        }
+    }
+    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 > maxUint256)
+        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 > maxUint256)
+        throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
+}
+function assertTransactionLegacy(transaction) {
+    const { chainId, maxPriorityFeePerGas, gasPrice, maxFeePerGas, to } = 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 > maxUint256)
+        throw new FeeCapTooHighError({ maxFeePerGas: gasPrice });
+}
+
+function getTransactionType(transaction) {
+    if (transaction.type)
+        return transaction.type;
+    if (typeof transaction.authorizationList !== 'undefined')
+        return 'eip7702';
+    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';
+    }
+    throw new InvalidSerializableTransactionError({ transaction });
+}
+
+/*
+ * 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 });
+        }
+        serializedAccessList.push([address, storageKeys]);
+    }
+    return serializedAccessList;
+}
+
+function serializeTransaction$1(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);
+    if (type === 'eip7702')
+        return serializeTransactionEIP7702(transaction, signature);
+    return serializeTransactionLegacy(transaction, signature);
+}
+function serializeTransactionEIP7702(transaction, signature) {
+    const { authorizationList, chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data, } = transaction;
+    assertTransactionEIP7702(transaction);
+    const serializedAccessList = serializeAccessList(accessList);
+    const serializedAuthorizationList = serializeAuthorizationList(authorizationList);
+    return concatHex([
+        '0x04',
+        toRlp([
+            numberToHex(chainId),
+            nonce ? numberToHex(nonce) : '0x',
+            maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : '0x',
+            maxFeePerGas ? numberToHex(maxFeePerGas) : '0x',
+            gas ? numberToHex(gas) : '0x',
+            to ?? '0x',
+            value ? numberToHex(value) : '0x',
+            data ?? '0x',
+            serializedAccessList,
+            serializedAuthorizationList,
+            ...toYParitySignatureArray(transaction, signature),
+        ]),
+    ]);
+}
+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,
+        });
+        if (typeof blobVersionedHashes === 'undefined')
+            blobVersionedHashes = commitmentsToVersionedHashes({
+                commitments,
+            });
+        if (typeof sidecars === 'undefined') {
+            const proofs = blobsToProofs({ blobs, commitments, kzg });
+            sidecars = toBlobSidecars({ blobs, commitments, proofs });
+        }
+    }
+    const serializedAccessList = serializeAccessList(accessList);
+    const serializedTransaction = [
+        numberToHex(chainId),
+        nonce ? numberToHex(nonce) : '0x',
+        maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : '0x',
+        maxFeePerGas ? numberToHex(maxFeePerGas) : '0x',
+        gas ? numberToHex(gas) : '0x',
+        to ?? '0x',
+        value ? numberToHex(value) : '0x',
+        data ?? '0x',
+        serializedAccessList,
+        maxFeePerBlobGas ? numberToHex(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 serializeTransactionEIP1559(transaction, signature) {
+    const { chainId, gas, nonce, to, value, maxFeePerGas, maxPriorityFeePerGas, accessList, data, } = transaction;
+    assertTransactionEIP1559(transaction);
+    const serializedAccessList = serializeAccessList(accessList);
+    const serializedTransaction = [
+        numberToHex(chainId),
+        nonce ? numberToHex(nonce) : '0x',
+        maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : '0x',
+        maxFeePerGas ? numberToHex(maxFeePerGas) : '0x',
+        gas ? numberToHex(gas) : '0x',
+        to ?? '0x',
+        value ? numberToHex(value) : '0x',
+        data ?? '0x',
+        serializedAccessList,
+        ...toYParitySignatureArray(transaction, signature),
+    ];
+    return concatHex([
+        '0x02',
+        toRlp(serializedTransaction),
+    ]);
+}
+function serializeTransactionEIP2930(transaction, signature) {
+    const { chainId, gas, data, nonce, to, value, accessList, gasPrice } = transaction;
+    assertTransactionEIP2930(transaction);
+    const serializedAccessList = serializeAccessList(accessList);
+    const serializedTransaction = [
+        numberToHex(chainId),
+        nonce ? numberToHex(nonce) : '0x',
+        gasPrice ? numberToHex(gasPrice) : '0x',
+        gas ? numberToHex(gas) : '0x',
+        to ?? '0x',
+        value ? numberToHex(value) : '0x',
+        data ?? '0x',
+        serializedAccessList,
+        ...toYParitySignatureArray(transaction, signature),
+    ];
+    return concatHex([
+        '0x01',
+        toRlp(serializedTransaction),
+    ]);
+}
+function serializeTransactionLegacy(transaction, signature) {
+    const { chainId = 0, gas, data, nonce, to, value, gasPrice } = transaction;
+    assertTransactionLegacy(transaction);
+    let serializedTransaction = [
+        nonce ? numberToHex(nonce) : '0x',
+        gasPrice ? numberToHex(gasPrice) : '0x',
+        gas ? numberToHex(gas) : '0x',
+        to ?? '0x',
+        value ? numberToHex(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;
+        })();
+        const r = trim(signature.r);
+        const s = trim(signature.s);
+        serializedTransaction = [
+            ...serializedTransaction,
+            numberToHex(v),
+            r === '0x00' ? '0x' : r,
+            s === '0x00' ? '0x' : s,
+        ];
+    }
+    else if (chainId > 0) {
+        serializedTransaction = [
+            ...serializedTransaction,
+            numberToHex(chainId),
+            '0x',
+            '0x',
+        ];
+    }
+    return toRlp(serializedTransaction);
+}
+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 ? numberToHex(1) : '0x';
+        if (v === 0n)
+            return '0x';
+        if (v === 1n)
+            return numberToHex(1);
+        return v === 27n ? '0x' : numberToHex(1);
+    })();
+    return [yParity_, r === '0x00' ? '0x' : r, s === '0x00' ? '0x' : s];
+}
+
+/**
+ * Predeploy contracts for OP Stack.
+ * @see https://github.com/ethereum-optimism/optimism/blob/develop/specs/predeploys.md
+ */
+const contracts = {
+    gasPriceOracle: { address: '0x420000000000000000000000000000000000000F' },
+    l1Block: { address: '0x4200000000000000000000000000000000000015' },
+    l2CrossDomainMessenger: {
+        address: '0x4200000000000000000000000000000000000007',
+    },
+    l2Erc721Bridge: { address: '0x4200000000000000000000000000000000000014' },
+    l2StandardBridge: { address: '0x4200000000000000000000000000000000000010' },
+    l2ToL1MessagePasser: {
+        address: '0x4200000000000000000000000000000000000016',
+    },
+};
+
+const formatters = {
+    block: /*#__PURE__*/ defineBlock({
+        format(args) {
+            const transactions = args.transactions?.map((transaction) => {
+                if (typeof transaction === 'string')
+                    return transaction;
+                const formatted = formatTransaction(transaction);
+                if (formatted.typeHex === '0x7e') {
+                    formatted.isSystemTx = transaction.isSystemTx;
+                    formatted.mint = transaction.mint
+                        ? hexToBigInt(transaction.mint)
+                        : undefined;
+                    formatted.sourceHash = transaction.sourceHash;
+                    formatted.type = 'deposit';
+                }
+                return formatted;
+            });
+            return {
+                transactions,
+                stateRoot: args.stateRoot,
+            };
+        },
+    }),
+    transaction: /*#__PURE__*/ defineTransaction({
+        format(args) {
+            const transaction = {};
+            if (args.type === '0x7e') {
+                transaction.isSystemTx = args.isSystemTx;
+                transaction.mint = args.mint ? hexToBigInt(args.mint) : undefined;
+                transaction.sourceHash = args.sourceHash;
+                transaction.type = 'deposit';
+            }
+            return transaction;
+        },
+    }),
+    transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
+        format(args) {
+            return {
+                l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
+                l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
+                l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
+                l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null,
+            };
+        },
+    }),
+};
+
+function serializeTransaction(transaction, signature) {
+    if (isDeposit(transaction))
+        return serializeTransactionDeposit(transaction);
+    return serializeTransaction$1(transaction, signature);
+}
+const serializers = {
+    transaction: serializeTransaction,
+};
+function serializeTransactionDeposit(transaction) {
+    assertTransactionDeposit(transaction);
+    const { sourceHash, data, from, gas, isSystemTx, mint, to, value } = transaction;
+    const serializedTransaction = [
+        sourceHash,
+        from,
+        to ?? '0x',
+        mint ? toHex(mint) : '0x',
+        value ? toHex(value) : '0x',
+        gas ? toHex(gas) : '0x',
+        isSystemTx ? '0x1' : '0x',
+        data ?? '0x',
+    ];
+    return concatHex([
+        '0x7e',
+        toRlp(serializedTransaction),
+    ]);
+}
+function isDeposit(transaction) {
+    if (transaction.type === 'deposit')
+        return true;
+    if (typeof transaction.sourceHash !== 'undefined')
+        return true;
+    return false;
+}
+function assertTransactionDeposit(transaction) {
+    const { from, to } = transaction;
+    if (from && !isAddress(from))
+        throw new InvalidAddressError({ address: from });
+    if (to && !isAddress(to))
+        throw new InvalidAddressError({ address: to });
+}
+
+const chainConfig = {
+    blockTime: 2_000,
+    contracts,
+    formatters,
+    serializers,
+};
+
+const sourceId$1 = 1; // mainnet
+const base = /*#__PURE__*/ defineChain({
+    ...chainConfig,
+    id: 8453,
+    name: 'Base',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: {
+        default: {
+            http: ['https://mainnet.base.org'],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: 'Basescan',
+            url: 'https://basescan.org',
+            apiUrl: 'https://api.basescan.org/api',
+        },
+    },
+    contracts: {
+        ...chainConfig.contracts,
+        disputeGameFactory: {
+            [sourceId$1]: {
+                address: '0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e',
+            },
+        },
+        l2OutputOracle: {
+            [sourceId$1]: {
+                address: '0x56315b90c40730925ec5485cf004d835058518A0',
+            },
+        },
+        multicall3: {
+            address: '0xca11bde05977b3631167028862be2a173976ca11',
+            blockCreated: 5022,
+        },
+        portal: {
+            [sourceId$1]: {
+                address: '0x49048044D57e1C92A77f79988d21Fa8fAF74E97e',
+                blockCreated: 17482143,
+            },
+        },
+        l1StandardBridge: {
+            [sourceId$1]: {
+                address: '0x3154Cf16ccdb4C6d922629664174b904d80F2C35',
+                blockCreated: 17482143,
+            },
+        },
+    },
+    sourceId: sourceId$1,
+});
+/*#__PURE__*/ defineChain({
+    ...base,
+    experimental_preconfirmationTime: 200,
+    rpcUrls: {
+        default: {
+            http: ['https://mainnet-preconf.base.org'],
+        },
+    },
+});
+
+const sourceId = 11_155_111; // sepolia
+const baseSepolia = /*#__PURE__*/ defineChain({
+    ...chainConfig,
+    id: 84532,
+    network: 'base-sepolia',
+    name: 'Base Sepolia',
+    nativeCurrency: { name: 'Sepolia Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: {
+        default: {
+            http: ['https://sepolia.base.org'],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: 'Basescan',
+            url: 'https://sepolia.basescan.org',
+            apiUrl: 'https://api-sepolia.basescan.org/api',
+        },
+    },
+    contracts: {
+        ...chainConfig.contracts,
+        disputeGameFactory: {
+            [sourceId]: {
+                address: '0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1',
+            },
+        },
+        l2OutputOracle: {
+            [sourceId]: {
+                address: '0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254',
+            },
+        },
+        portal: {
+            [sourceId]: {
+                address: '0x49f53e41452c74589e85ca1677426ba426459e85',
+                blockCreated: 4446677,
+            },
+        },
+        l1StandardBridge: {
+            [sourceId]: {
+                address: '0xfd0Bf71F60660E2f608ed56e1659C450eB113120',
+                blockCreated: 4446677,
+            },
+        },
+        multicall3: {
+            address: '0xca11bde05977b3631167028862be2a173976ca11',
+            blockCreated: 1059647,
+        },
+    },
+    testnet: true,
+    sourceId,
+});
+/*#__PURE__*/ defineChain({
+    ...baseSepolia,
+    experimental_preconfirmationTime: 200,
+    rpcUrls: {
+        default: {
+            http: ['https://sepolia-preconf.base.org'],
+        },
+    },
+});
+
+const mainnet = /*#__PURE__*/ defineChain({
+    id: 1,
+    name: 'Ethereum',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    blockTime: 12_000,
+    rpcUrls: {
+        default: {
+            http: ['https://eth.merkle.io'],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: 'Etherscan',
+            url: 'https://etherscan.io',
+            apiUrl: 'https://api.etherscan.io/api',
+        },
+    },
+    contracts: {
+        ensUniversalResolver: {
+            address: '0xeeeeeeee14d718c2b47d9923deab1335e144eeee',
+            blockCreated: 23_085_558,
+        },
+        multicall3: {
+            address: '0xca11bde05977b3631167028862be2a173976ca11',
+            blockCreated: 14_353_601,
+        },
+    },
+});
+
+const sepolia = /*#__PURE__*/ defineChain({
+    id: 11_155_111,
+    name: 'Sepolia',
+    nativeCurrency: { name: 'Sepolia Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: {
+        default: {
+            http: ['https://11155111.rpc.thirdweb.com'],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: 'Etherscan',
+            url: 'https://sepolia.etherscan.io',
+            apiUrl: 'https://api-sepolia.etherscan.io/api',
+        },
+    },
+    contracts: {
+        multicall3: {
+            address: '0xca11bde05977b3631167028862be2a173976ca11',
+            blockCreated: 751532,
+        },
+        ensUniversalResolver: {
+            address: '0xeeeeeeee14d718c2b47d9923deab1335e144eeee',
+            blockCreated: 8_928_790,
+        },
+    },
+    testnet: true,
+});
+
+/**
+ * Maps AgentKit network IDs to Lombard SDK ChainId values.
+ *
+ * Only includes networks where Lombard contracts are deployed.
+ */ const NETWORK_ID_TO_LOMBARD_CHAIN = {
+    "ethereum-mainnet": sdk.ChainId.ethereum,
+    "ethereum-sepolia": sdk.ChainId.sepolia,
+    "base-mainnet": sdk.ChainId.base,
+    "base-sepolia": sdk.ChainId.baseSepoliaTestnet
+};
+/**
+ * Maps AgentKit network IDs to Lombard SDK Env values.
+ */ const NETWORK_ID_TO_ENV = {
+    "ethereum-mainnet": sdkCommon.Env.prod,
+    "ethereum-sepolia": sdkCommon.Env.testnet,
+    "base-mainnet": sdkCommon.Env.prod,
+    "base-sepolia": sdkCommon.Env.testnet
+};
+/**
+ * Maps AgentKit network IDs to viem `Chain` objects, for callers that need
+ * to construct a wallet/public client outside of the action provider.
+ */ const NETWORK_ID_TO_VIEM_CHAIN = {
+    "ethereum-mainnet": mainnet,
+    "ethereum-sepolia": sepolia,
+    "base-mainnet": base,
+    "base-sepolia": baseSepolia
+};
+/**
+ * Resolves an AgentKit Network to Lombard SDK chain parameters.
+ *
+ * @returns ResolvedNetwork or null if the network is not supported
+ */ function resolveNetwork(network) {
+    const networkId = network.networkId;
+    if (!networkId) return null;
+    const chainId = NETWORK_ID_TO_LOMBARD_CHAIN[networkId];
+    const env = NETWORK_ID_TO_ENV[networkId];
+    if (chainId === undefined || !env) return null;
+    return {
+        chainId,
+        env,
+        networkId
+    };
+}
+/**
+ * Resolves a user-supplied chain name string to Lombard SDK chain parameters.
+ *
+ * Accepts both AgentKit network IDs (e.g., "ethereum-mainnet") and
+ * friendly names (e.g., "ethereum", "base-sepolia").
+ */ function resolveChainName(chainName) {
+    const normalized = chainName.toLowerCase().trim();
+    // Try direct match on network ID
+    if (NETWORK_ID_TO_LOMBARD_CHAIN[normalized] !== undefined) {
+        return {
+            chainId: NETWORK_ID_TO_LOMBARD_CHAIN[normalized],
+            env: NETWORK_ID_TO_ENV[normalized],
+            networkId: normalized
+        };
+    }
+    // Friendly name aliases
+    const aliases = {
+        ethereum: "ethereum-mainnet",
+        eth: "ethereum-mainnet",
+        mainnet: "ethereum-mainnet",
+        sepolia: "ethereum-sepolia",
+        base: "base-mainnet",
+        "base-sep": "base-sepolia"
+    };
+    const resolved = aliases[normalized];
+    if (resolved && NETWORK_ID_TO_LOMBARD_CHAIN[resolved] !== undefined) {
+        return {
+            chainId: NETWORK_ID_TO_LOMBARD_CHAIN[resolved],
+            env: NETWORK_ID_TO_ENV[resolved],
+            networkId: resolved
+        };
+    }
+    return null;
+}
+/**
+ * Checks if a given AgentKit Network is supported by the Lombard provider.
+ */ function isLombardSupportedNetwork(network) {
+    return resolveNetwork(network) !== null;
+}
+
+const StakeBtcbToLbtcSchema = zod.z.object({
+    amount: zod.z.string().describe("Amount of BTC.b to stake in human-readable format (e.g. '0.1' for 0.1 BTC.b). Will be converted to LBTC.").refine((v)=>/^\d+(\.\d+)?$/.test(v), "Amount must be a numeric string").refine((v)=>parseFloat(v) > 0, "Amount must be positive").refine((v)=>parseFloat(v) < 1000, "Amount must be under 1000 BTC")
+});
+const UnstakeLbtcSchema = zod.z.object({
+    amount: zod.z.string().describe("Amount of LBTC to unstake in human-readable format (e.g. '0.1')").refine((v)=>/^\d+(\.\d+)?$/.test(v), "Amount must be a numeric string").refine((v)=>parseFloat(v) > 0, "Amount must be positive").refine((v)=>parseFloat(v) < 1000, "Amount must be under 1000 BTC"),
+    recipient: zod.z.string().describe("Destination address. For BTC output, use a Bitcoin address (e.g. bc1q...). For BTCb output, use an EVM address (e.g. 0x...).").refine((v)=>/^0x[a-fA-F0-9]{40}$/.test(v) || /^(bc1|[13])[a-zA-HJ-NP-Z0-9]{25,62}$/.test(v), "Invalid address: must be an EVM address (0x...) or a Bitcoin address (bc1.../1.../3...)"),
+    outputAsset: zod.z.enum([
+        "BTC",
+        "BTCb"
+    ]).describe("Output asset: 'BTC' for native Bitcoin (cross-chain, takes longer), 'BTCb' for wrapped BTC on the same EVM chain (faster)")
+});
+const RedeemLbtcToBtcbSchema = zod.z.object({
+    amount: zod.z.string().describe("Amount of LBTC to redeem in human-readable format (e.g. '0.1'). Will be converted to BTC.b on the same chain.").refine((v)=>/^\d+(\.\d+)?$/.test(v), "Amount must be a numeric string").refine((v)=>parseFloat(v) > 0, "Amount must be positive").refine((v)=>parseFloat(v) < 1000, "Amount must be under 1000 BTC")
+});
+const DeployToDefiSchema = zod.z.object({
+    amount: zod.z.string().describe("Amount to deploy in human-readable format (e.g. '0.1')").refine((v)=>/^\d+(\.\d+)?$/.test(v), "Amount must be a numeric string").refine((v)=>parseFloat(v) > 0, "Amount must be positive").refine((v)=>parseFloat(v) < 1000, "Amount must be under 1000 BTC")
+});
+const ClaimDepositSchema = zod.z.object({
+    depositTxHash: zod.z.string().describe("Transaction hash of the original deposit to claim. Use get_deposit_status first to check if the deposit is claimable.")
+});
+const GetLbtcBalanceSchema = zod.z.object({
+    address: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM address").optional().describe("EVM address to check balance for. If omitted, uses the connected wallet address.")
+});
+const GetBtcbBalanceSchema = zod.z.object({
+    address: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM address").optional().describe("EVM address to check balance for. If omitted, uses the connected wallet address.")
+});
+const GetLbtcExchangeRateSchema = zod.z.object({});
+const GetDepositStatusSchema = zod.z.object({
+    address: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM address").optional().describe("EVM address to check deposits for. If omitted, uses the connected wallet address.")
+});
+const GetUnstakeStatusSchema = zod.z.object({
+    address: zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM address").optional().describe("EVM address to check unstakes for. If omitted, uses the connected wallet address.")
+});
+
+/**
+ * Adapts a Coinbase AgentKit EvmWalletProvider into a viem-compatible
+ * EIP1193Provider that the Lombard SDK contract functions expect.
+ *
+ * The adapter implements the `request` method by delegating to the
+ * appropriate EvmWalletProvider method for each JSON-RPC call.
+ */ function toEIP1193Provider(walletProvider, chainId) {
+    const chain = sdk.CHAIN_ID_TO_VIEM_CHAIN_MAP[chainId];
+    // Use the SDK's makePublicClient for reliable RPC calls
+    const publicClient = chain ? sdk.makePublicClient({
+        chainId
+    }) : null;
+    // Use a Proxy to implement the EIP1193 request interface.
+    // This avoids complex viem type gymnastics while correctly routing
+    // wallet operations to the AgentKit provider and reads to a public client.
+    const handler = async ({ method, params })=>{
+        switch(method){
+            case "eth_accounts":
+                return [
+                    walletProvider.getAddress()
+                ];
+            case "eth_chainId":
+                return `0x${chainId.toString(16)}`;
+            case "eth_sendTransaction":
+                {
+                    if (!params || params.length === 0) {
+                        throw new Error("eth_sendTransaction requires transaction parameter");
+                    }
+                    const tx = params[0];
+                    return walletProvider.sendTransaction({
+                        to: tx.to,
+                        value: tx.value ? BigInt(tx.value) : undefined,
+                        data: tx.data,
+                        gas: tx.gas ? BigInt(tx.gas) : undefined
+                    });
+                }
+            case "personal_sign":
+                {
+                    const [message] = params;
+                    return walletProvider.signMessage(message);
+                }
+            case "eth_signTypedData_v4":
+                {
+                    const [, typedDataJson] = params;
+                    const typedData = typeof typedDataJson === "string" ? JSON.parse(typedDataJson) : typedDataJson;
+                    return walletProvider.signTypedData(typedData);
+                }
+            default:
+                {
+                    if (!publicClient) {
+                        throw new Error(`Unsupported RPC method: ${method}`);
+                    }
+                    return publicClient.request({
+                        method,
+                        params
+                    });
+                }
+        }
+    };
+    return {
+        request: handler
+    };
+}
+/**
+ * Reads an ERC20 token balance using the AgentKit wallet provider's
+ * readContract method directly (avoids needing EIP1193 adapter for reads).
+ */ async function getTokenBalance(walletProvider, token, chainId, address, env) {
+    const tokenInfo = await sdk.getTokenContractInfo(token, chainId, env);
+    const tokenAddress = tokenInfo.address;
+    const balance = await walletProvider.readContract({
+        address: tokenAddress,
+        abi: [
+            {
+                name: "balanceOf",
+                type: "function",
+                stateMutability: "view",
+                inputs: [
+                    {
+                        name: "account",
+                        type: "address"
+                    }
+                ],
+                outputs: [
+                    {
+                        name: "",
+                        type: "uint256"
+                    }
+                ]
+            }
+        ],
+        functionName: "balanceOf",
+        args: [
+            address
+        ]
+    });
+    // Use decimals from token info when available, default to 8 for BTC-like tokens
+    const decimals = "decimals" in tokenInfo && typeof tokenInfo.decimals === "number" ? tokenInfo.decimals : 8;
+    const formatted = viem.formatUnits(balance, decimals);
+    return {
+        balance: balance,
+        formatted,
+        decimals
+    };
+}
+/**
+ * Format a result string for AgentKit action responses.
+ */ function formatSuccess(action, details) {
+    return JSON.stringify({
+        success: true,
+        action,
+        ...details
+    });
+}
+function formatError(action, error) {
+    let message;
+    if (error instanceof Error) {
+        // Strip RPC URLs and internal details
+        message = error.message.replace(/https?:\/\/[^\s]+/g, "[redacted-url]").replace(/0x[a-fA-F0-9]{64,}/g, "[redacted-data]");
+    } else {
+        message = String(error);
+    }
+    return JSON.stringify({
+        success: false,
+        action,
+        error: message
+    });
+}
+
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+/**
+ * LombardActionProvider exposes Lombard protocol operations
+ * (stake, unstake, redeem, deploy, claim) as Coinbase AgentKit actions.
+ *
+ * SECURITY: This provider executes real transactions. Configure your wallet
+ * provider with appropriate spending limits. All amounts are validated to be
+ * positive numeric strings under 1000 BTC equivalent.
+ *
+ * Usage:
+ * ```ts
+ * import { lombardActionProvider } from '@lombard.finance/sdk-agentkit';
+ *
+ * const agentkit = await AgentKit.from({
+ *   walletProvider,
+ *   actionProviders: [lombardActionProvider()],
+ * });
+ * ```
+ */ class LombardActionProvider extends agentkit.ActionProvider {
+    constructor(){
+        super("lombard", []);
+    }
+    supportsNetwork = (network)=>{
+        return isLombardSupportedNetwork(network);
+    };
+    // ─── Write Actions ──────────────────────────────────────────────────
+    async stakeBtcbToLbtc(walletProvider, args) {
+        try {
+            const resolved = resolveNetwork(walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("stake_btcb_to_lbtc", "Current network is not supported by Lombard");
+            }
+            const { chainId, env } = resolved;
+            const account = walletProvider.getAddress();
+            const provider = toEIP1193Provider(walletProvider, chainId);
+            // Handle fee authorization for chains that require it
+            await this.ensureFeeAuthorization(walletProvider, chainId, env, account, provider);
+            // Check allowance and approve if needed
+            const routerAddress = await sdk.getAssetRouterAddress({
+                tokenIn: sdk.Token.BTCb,
+                chainId,
+                env
+            });
+            const allowance = await sdk.getTokenAllowance({
+                token: sdk.Token.BTCb,
+                owner: account,
+                spender: routerAddress,
+                chainId,
+                env
+            });
+            if (allowance.isLessThan(args.amount)) {
+                await sdk.approveToken({
+                    token: sdk.Token.BTCb,
+                    spender: routerAddress,
+                    amount: args.amount,
+                    account,
+                    chainId,
+                    provider,
+                    env
+                });
+            }
+            const txHash = await sdk.depositToken({
+                amount: args.amount,
+                tokenIn: sdk.Token.BTCb,
+                tokenOut: sdk.Token.LBTC,
+                account,
+                chainId,
+                provider,
+                env
+            });
+            return formatSuccess("stake_btcb_to_lbtc", {
+                txHash,
+                amount: args.amount,
+                from: "BTC.b",
+                to: "LBTC"
+            });
+        } catch (error) {
+            return formatError("stake_btcb_to_lbtc", error);
+        }
+    }
+    async unstakeLbtc(walletProvider, args) {
+        try {
+            const resolved = resolveNetwork(walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("unstake_lbtc", "Current network is not supported by Lombard");
+            }
+            const { chainId, env } = resolved;
+            const account = walletProvider.getAddress();
+            const provider = toEIP1193Provider(walletProvider, chainId);
+            // Handle fee authorization for chains that require it
+            await this.ensureFeeAuthorization(walletProvider, chainId, env, account, provider);
+            if (args.outputAsset === "BTC") {
+                const txHash = await sdk.unstakeLBTC({
+                    amount: args.amount,
+                    btcAddress: args.recipient,
+                    tokenIn: sdk.Token.LBTC,
+                    account,
+                    chainId,
+                    provider,
+                    env
+                });
+                return formatSuccess("unstake_lbtc", {
+                    txHash,
+                    amount: args.amount,
+                    to: "BTC",
+                    recipient: args.recipient,
+                    note: "Cross-chain unstake initiated. BTC will arrive after processing (may take hours)."
+                });
+            }
+            // BTCb output - same chain redeem (always sends to caller's address)
+            const txHash = await sdk.redeemToken({
+                amount: args.amount,
+                tokenIn: sdk.Token.LBTC,
+                tokenOut: sdk.Token.BTCb,
+                account,
+                chainId,
+                provider,
+                env
+            });
+            const result = {
+                txHash,
+                amount: args.amount,
+                to: "BTC.b"
+            };
+            if (args.recipient && args.recipient.toLowerCase() !== account.toLowerCase()) {
+                result.warning = "BTC.b redemption always sends to the connected wallet. The recipient address was ignored.";
+            }
+            return formatSuccess("unstake_lbtc", result);
+        } catch (error) {
+            return formatError("unstake_lbtc", error);
+        }
+    }
+    async redeemLbtcToBtcb(walletProvider, args) {
+        try {
+            const resolved = resolveNetwork(walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("redeem_lbtc_to_btcb", "Current network is not supported by Lombard");
+            }
+            const { chainId, env } = resolved;
+            const account = walletProvider.getAddress();
+            const provider = toEIP1193Provider(walletProvider, chainId);
+            await this.ensureFeeAuthorization(walletProvider, chainId, env, account, provider);
+            const txHash = await sdk.redeemToken({
+                amount: args.amount,
+                tokenIn: sdk.Token.LBTC,
+                tokenOut: sdk.Token.BTCb,
+                account,
+                chainId,
+                provider,
+                env
+            });
+            return formatSuccess("redeem_lbtc_to_btcb", {
+                txHash,
+                amount: args.amount,
+                from: "LBTC",
+                to: "BTC.b"
+            });
+        } catch (error) {
+            return formatError("redeem_lbtc_to_btcb", error);
+        }
+    }
+    async deployToDefi(walletProvider, args) {
+        try {
+            const resolved = resolveNetwork(walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("deploy_to_defi", "Current network is not supported by Lombard");
+            }
+            const { chainId } = resolved;
+            const account = walletProvider.getAddress();
+            const provider = toEIP1193Provider(walletProvider, chainId);
+            const txHash = await sdk.depositEarn({
+                amount: args.amount,
+                approve: true,
+                token: sdk.Token.LBTC,
+                account,
+                chainId,
+                provider,
+                rpcUrl: undefined,
+                env: resolved.env
+            });
+            return formatSuccess("deploy_to_defi", {
+                txHash,
+                amount: args.amount,
+                asset: "LBTC"
+            });
+        } catch (error) {
+            return formatError("deploy_to_defi", error);
+        }
+    }
+    async claimDeposit(walletProvider, args) {
+        try {
+            const resolved = resolveNetwork(walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("claim_deposit", "Current network is not supported by Lombard");
+            }
+            const { chainId, env } = resolved;
+            const account = walletProvider.getAddress();
+            const provider = toEIP1193Provider(walletProvider, chainId);
+            // Find the claimable deposit by tx hash
+            const deposits = await sdk.getDepositsByAddress({
+                address: account,
+                env
+            });
+            const deposit = deposits.find((d)=>d.txHash === args.depositTxHash);
+            if (!deposit) {
+                return formatError("claim_deposit", `No deposit found with txHash: ${args.depositTxHash}`);
+            }
+            const status = sdk.getDepositStatus(deposit);
+            if (status !== "claimable") {
+                const display = sdk.getDepositStatusDisplay(status);
+                return formatError("claim_deposit", `Deposit is not claimable. Current status: ${display.label} - ${display.description}`);
+            }
+            if (!deposit.rawPayload || !deposit.proof) {
+                return formatError("claim_deposit", "Deposit proof data is not yet available");
+            }
+            const txHash = await sdk.claimLBTC({
+                data: deposit.rawPayload,
+                proofSignature: deposit.proof,
+                account,
+                chainId,
+                provider,
+                env
+            });
+            return formatSuccess("claim_deposit", {
+                txHash,
+                depositTxHash: args.depositTxHash
+            });
+        } catch (error) {
+            return formatError("claim_deposit", error);
+        }
+    }
+    // ─── Read Actions ───────────────────────────────────────────────────
+    async getLbtcBalance(walletProvider, args) {
+        try {
+            const resolved = resolveNetwork(walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("get_lbtc_balance", "Current network is not supported by Lombard");
+            }
+            const { chainId, env } = resolved;
+            const address = args.address || walletProvider.getAddress();
+            const { formatted } = await getTokenBalance(walletProvider, sdk.Token.LBTC, chainId, address, env);
+            return formatSuccess("get_lbtc_balance", {
+                address,
+                balance: formatted,
+                token: "LBTC",
+                chain: resolved.networkId
+            });
+        } catch (error) {
+            return formatError("get_lbtc_balance", error);
+        }
+    }
+    async getBtcbBalance(walletProvider, args) {
+        try {
+            const resolved = resolveNetwork(walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("get_btcb_balance", "Current network is not supported by Lombard");
+            }
+            const { chainId, env } = resolved;
+            const address = args.address || walletProvider.getAddress();
+            const { formatted } = await getTokenBalance(walletProvider, sdk.Token.BTCb, chainId, address, env);
+            return formatSuccess("get_btcb_balance", {
+                address,
+                balance: formatted,
+                token: "BTC.b",
+                chain: resolved.networkId
+            });
+        } catch (error) {
+            return formatError("get_btcb_balance", error);
+        }
+    }
+    async getLbtcExchangeRate(_walletProvider, _args) {
+        try {
+            const resolved = resolveNetwork(_walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("get_lbtc_exchange_rate", "Current network is not supported by Lombard");
+            }
+            const env = resolved.env;
+            const rate = await sdk.getLBTCExchangeRate({
+                env
+            });
+            return formatSuccess("get_lbtc_exchange_rate", {
+                exchangeRate: rate.exchangeRate,
+                minStakeAmountBtc: sdk.fromSatoshi(rate.minAmount).toString()
+            });
+        } catch (error) {
+            return formatError("get_lbtc_exchange_rate", error);
+        }
+    }
+    async getDepositStatusAction(walletProvider, args) {
+        try {
+            const resolved = resolveNetwork(walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("get_deposit_status", "Current network is not supported by Lombard");
+            }
+            const { env } = resolved;
+            const address = args.address || walletProvider.getAddress();
+            const deposits = await sdk.getDepositsByAddress({
+                address,
+                env
+            });
+            if (deposits.length === 0) {
+                return formatSuccess("get_deposit_status", {
+                    address,
+                    deposits: [],
+                    message: "No deposits found for this address"
+                });
+            }
+            const summaries = deposits.map((d)=>{
+                const status = sdk.getDepositStatus(d);
+                const display = sdk.getDepositStatusDisplay(status);
+                return {
+                    txHash: d.txHash,
+                    amount: d.amount?.toString(),
+                    status,
+                    statusLabel: display.label,
+                    description: display.description,
+                    requiresAction: display.requiresAction,
+                    isTerminal: display.isTerminal,
+                    claimTxHash: d.claimTxHash || null
+                };
+            });
+            return formatSuccess("get_deposit_status", {
+                address,
+                totalDeposits: deposits.length,
+                deposits: summaries
+            });
+        } catch (error) {
+            return formatError("get_deposit_status", error);
+        }
+    }
+    async getUnstakeStatus(walletProvider, args) {
+        try {
+            const resolved = resolveNetwork(walletProvider.getNetwork());
+            if (!resolved) {
+                return formatError("get_unstake_status", "Current network is not supported by Lombard");
+            }
+            const { env } = resolved;
+            const address = args.address || walletProvider.getAddress();
+            const unstakes = await sdk.getUnstakesByAddress({
+                address,
+                env
+            });
+            if (unstakes.length === 0) {
+                return formatSuccess("get_unstake_status", {
+                    address,
+                    unstakes: [],
+                    message: "No unstakes found for this address"
+                });
+            }
+            const summaries = unstakes.map((u)=>({
+                    txHash: u.txHash,
+                    amount: u.amount?.toString(),
+                    payoutStatus: u.payoutTxStatus,
+                    payoutTxHash: u.payoutTxHash || null,
+                    toAddress: u.toAddress || null
+                }));
+            return formatSuccess("get_unstake_status", {
+                address,
+                totalUnstakes: unstakes.length,
+                unstakes: summaries
+            });
+        } catch (error) {
+            return formatError("get_unstake_status", error);
+        }
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────
+    /**
+   * Ensures fee authorization is in place for chains that require it.
+   * On Ethereum and Sepolia, staking/unstaking requires an EIP-712 fee
+   * signature stored with the backend before the transaction can proceed.
+   */ async ensureFeeAuthorization(_walletProvider, chainId, env, account, provider) {
+        if (!sdk.requiresAutoMintFee(chainId)) {
+            return;
+        }
+        // Check if a valid fee signature already exists
+        const existing = await sdk.getNetworkFeeSignature({
+            address: account,
+            chainId,
+            env
+        });
+        if (existing.hasSignature) {
+            // Check expiration
+            const expirationMs = new Date(existing.expirationDate).getTime();
+            const bufferMs = 60 * 60 * 1000; // 1 hour buffer
+            if (expirationMs > Date.now() + bufferMs) {
+                return; // Existing signature is still valid
+            }
+        }
+        // Need to sign a new fee authorization
+        const mintingFee = await sdk.getLBTCMintingFee({
+            chainId,
+            env
+        });
+        const { signature, typedData } = await sdk.signNetworkFee({
+            fee: mintingFee,
+            account,
+            chainId,
+            provider,
+            env
+        });
+        await sdk.storeNetworkFeeSignature({
+            signature,
+            typedData,
+            address: account,
+            env
+        });
+    }
+}
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "stake_btcb_to_lbtc",
+        description: "Stake BTC.b (cross-chain Bitcoin) to receive LBTC (Lombard Staked Bitcoin). " + "This converts BTC.b into LBTC which earns staking yield. " + "Handles token approval and fee authorization automatically.",
+        schema: StakeBtcbToLbtcSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "stakeBtcbToLbtc", null);
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "unstake_lbtc",
+        description: "Unstake LBTC (Lombard Staked Bitcoin). " + "Output can be native BTC (cross-chain, requires a Bitcoin address) or BTC.b (same EVM chain). " + "BTC unstaking takes longer as it crosses chains. BTC.b is faster, same-chain.",
+        schema: UnstakeLbtcSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "unstakeLbtc", null);
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "redeem_lbtc_to_btcb",
+        description: "Use this for simple same-chain LBTC to BTC.b conversion. " + "For cross-chain unstaking to native BTC, use unstake_lbtc instead.",
+        schema: RedeemLbtcToBtcbSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "redeemLbtcToBtcb", null);
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "deploy_to_defi",
+        description: "Deploy LBTC into a DeFi vault to earn additional yield. " + "Currently supports the Veda vault. " + "Handles approval automatically.",
+        schema: DeployToDefiSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "deployToDefi", null);
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "claim_deposit",
+        description: "Claim a notarized deposit to mint LBTC. " + "Use get_deposit_status first to check if a deposit is claimable. " + 'Only deposits with status "claimable" can be claimed.',
+        schema: ClaimDepositSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "claimDeposit", null);
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "get_lbtc_balance",
+        description: "Check the LBTC (Lombard Staked Bitcoin) balance for an address on the current chain.",
+        schema: GetLbtcBalanceSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "getLbtcBalance", null);
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "get_btcb_balance",
+        description: "Check the BTC.b (cross-chain Bitcoin) balance for an address on the current chain.",
+        schema: GetBtcbBalanceSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "getBtcbBalance", null);
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "get_lbtc_exchange_rate",
+        description: "Get the current LBTC/BTC exchange rate and minimum stake amount. " + "LBTC is a rebasing token, so the rate is typically close to 1:1.",
+        schema: GetLbtcExchangeRateSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "getLbtcExchangeRate", null);
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "get_deposit_status",
+        description: "Check the status of all deposits for an address. " + "Shows pending, claimable, claimed, and failed deposits. " + "Use this to find claimable deposits before calling claim_deposit.",
+        schema: GetDepositStatusSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "getDepositStatusAction", null);
+_ts_decorate([
+    agentkit.CreateAction({
+        name: "get_unstake_status",
+        description: "Check the status of all unstake/redeem operations for an address. " + "Shows pending and completed unstakes with payout transaction details.",
+        schema: GetUnstakeStatusSchema
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof agentkit.EvmWalletProvider === "undefined" ? Object : agentkit.EvmWalletProvider,
+        typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], LombardActionProvider.prototype, "getUnstakeStatus", null);
+const lombardActionProvider = ()=>new LombardActionProvider();
+
+exports.ClaimDepositSchema = ClaimDepositSchema;
+exports.DeployToDefiSchema = DeployToDefiSchema;
+exports.GetBtcbBalanceSchema = GetBtcbBalanceSchema;
+exports.GetDepositStatusSchema = GetDepositStatusSchema;
+exports.GetLbtcBalanceSchema = GetLbtcBalanceSchema;
+exports.GetLbtcExchangeRateSchema = GetLbtcExchangeRateSchema;
+exports.GetUnstakeStatusSchema = GetUnstakeStatusSchema;
+exports.LombardActionProvider = LombardActionProvider;
+exports.NETWORK_ID_TO_VIEM_CHAIN = NETWORK_ID_TO_VIEM_CHAIN;
+exports.RedeemLbtcToBtcbSchema = RedeemLbtcToBtcbSchema;
+exports.StakeBtcbToLbtcSchema = StakeBtcbToLbtcSchema;
+exports.UnstakeLbtcSchema = UnstakeLbtcSchema;
+exports.isLombardSupportedNetwork = isLombardSupportedNetwork;
+exports.lombardActionProvider = lombardActionProvider;
+exports.resolveChainName = resolveChainName;
+exports.resolveNetwork = resolveNetwork;