ox 0.0.1 → 0.1.0

package/_types/AbiParameters.d.ts

@@ -0,0 +1,466 @@
+import * as abitype from 'abitype';
+import * as Bytes from './Bytes.js';
+import * as Errors from './Errors.js';
+import * as Hex from './Hex.js';
+import * as internal from './internal/abiParameters.js';
+/** Root type for ABI parameters. */
+export type AbiParameters = readonly abitype.AbiParameter[];
+/** A parameter on an {@link ox#AbiParameters.AbiParameters}. */
+export type Parameter = abitype.AbiParameter;
+/** A packed ABI type. */
+export type PackedAbiType = abitype.SolidityAddress | abitype.SolidityBool | abitype.SolidityBytes | abitype.SolidityInt | abitype.SolidityString | abitype.SolidityArrayWithoutTuple;
+/**
+ * Decodes ABI-encoded data into its respective primitive values based on ABI Parameters.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const data = AbiParameters.decode(
+ *   AbiParameters.from(['string', 'uint', 'bool']),
+ *   '0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000001a4000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000057761676d69000000000000000000000000000000000000000000000000000000',
+ * )
+ * // @log: ['wagmi', 420n, true]
+ * ```
+ *
+ * @example
+ * ### JSON Parameters
+ *
+ * You can pass **JSON ABI** Parameters:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const data = AbiParameters.decode(
+ *   [
+ *     { name: 'x', type: 'string' },
+ *     { name: 'y', type: 'uint' },
+ *     { name: 'z', type: 'bool' },
+ *   ],
+ *   '0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000001a4000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000057761676d69000000000000000000000000000000000000000000000000000000',
+ * )
+ * // @log: ['wagmi', 420n, true]
+ * ```
+ *
+ * @param parameters - The set of ABI parameters to decode, in the shape of the `inputs` or `outputs` attribute of an ABI Item. These parameters must include valid [ABI types](https://docs.soliditylang.org/en/latest/types.html).
+ * @param data - ABI encoded data.
+ * @param options - Decoding options.
+ * @returns Array of decoded values.
+ */
+export declare function decode<const parameters extends AbiParameters, as extends 'Object' | 'Array' = 'Array'>(parameters: parameters, data: Bytes.Bytes | Hex.Hex, options?: decode.Options<as>): decode.ReturnType<parameters, as>;
+export declare namespace decode {
+    var parseError: (error: unknown) => decode.ErrorType;
+}
+export declare namespace decode {
+    type Options<as extends 'Object' | 'Array'> = {
+        /**
+         * Whether the decoded values should be returned as an `Object` or `Array`.
+         *
+         * @default "Array"
+         */
+        as?: as | 'Object' | 'Array' | undefined;
+    };
+    type ReturnType<parameters extends AbiParameters = AbiParameters, as extends 'Object' | 'Array' = 'Array'> = parameters extends readonly [] ? as extends 'Object' ? {} : [] : as extends 'Object' ? internal.ToObject<parameters> : internal.ToPrimitiveTypes<parameters>;
+    type ErrorType = Bytes.fromHex.ErrorType | internal.decodeParameter.ErrorType | ZeroDataError | DataSizeTooSmallError | Errors.GlobalErrorType;
+}
+/**
+ * Encodes primitive values into ABI encoded data as per the [Application Binary Interface (ABI) Specification](https://docs.soliditylang.org/en/latest/abi-spec).
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const data = AbiParameters.encode(
+ *   AbiParameters.from(['string', 'uint', 'bool']),
+ *   ['wagmi', 420n, true],
+ * )
+ * ```
+ *
+ * @example
+ * ### JSON Parameters
+ *
+ * Specify **JSON ABI** Parameters as schema:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const data = AbiParameters.encode(
+ *   [
+ *     { type: 'string', name: 'name' },
+ *     { type: 'uint', name: 'age' },
+ *     { type: 'bool', name: 'isOwner' },
+ *   ],
+ *   ['wagmi', 420n, true],
+ * )
+ * ```
+ *
+ * @param parameters - The set of ABI parameters to encode, in the shape of the `inputs` or `outputs` attribute of an ABI Item. These parameters must include valid [ABI types](https://docs.soliditylang.org/en/latest/types.html).
+ * @param values - The set of primitive values that correspond to the ABI types defined in `parameters`.
+ * @returns ABI encoded data.
+ */
+export declare function encode<const parameters extends AbiParameters | readonly unknown[]>(parameters: parameters, values: parameters extends AbiParameters ? internal.ToPrimitiveTypes<parameters> : never): Hex.Hex;
+export declare namespace encode {
+    var parseError: (error: unknown) => encode.ErrorType;
+}
+export declare namespace encode {
+    type ErrorType = LengthMismatchError | internal.encode.ErrorType | internal.prepareParameters.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Encodes an array of primitive values to a [packed ABI encoding](https://docs.soliditylang.org/en/latest/abi-spec.html#non-standard-packed-mode).
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const encoded = AbiParameters.encodePacked(
+ *   ['address', 'string'],
+ *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 'hello world'],
+ * )
+ * // @log: '0xd8da6bf26964af9d7eed9e03e53415d37aa9604568656c6c6f20776f726c64'
+ * ```
+ *
+ * @param types - Set of ABI types to pack encode.
+ * @param values - The set of primitive values that correspond to the ABI types defined in `types`.
+ * @returns The encoded packed data.
+ */
+export declare function encodePacked<const packedAbiTypes extends readonly PackedAbiType[] | readonly unknown[]>(types: packedAbiTypes, values: encodePacked.Values<packedAbiTypes>): Hex.Hex;
+export declare namespace encodePacked {
+    var parseError: (error: unknown) => encodePacked.ErrorType;
+}
+export declare namespace encodePacked {
+    type ErrorType = Hex.concat.ErrorType | LengthMismatchError | Errors.GlobalErrorType;
+    type Values<packedAbiTypes extends readonly PackedAbiType[] | readonly unknown[]> = {
+        [key in keyof packedAbiTypes]: packedAbiTypes[key] extends abitype.AbiType ? abitype.AbiParameterToPrimitiveType<{
+            type: packedAbiTypes[key];
+        }> : unknown;
+    };
+    function encode<const packedAbiType extends PackedAbiType | unknown>(type: packedAbiType, value: Values<[packedAbiType]>[0], isArray?: boolean): Hex.Hex;
+}
+/**
+ * Formats {@link ox#AbiParameters.AbiParameters} into **Human Readable ABI Parameters**.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const formatted = AbiParameters.format([
+ *   {
+ *     name: 'spender',
+ *     type: 'address',
+ *   },
+ *   {
+ *     name: 'amount',
+ *     type: 'uint256',
+ *   },
+ * ])
+ *
+ * formatted
+ * //    ^?
+ *
+ *
+ * ```
+ *
+ * @param parameters - The ABI Parameters to format.
+ * @returns The formatted ABI Parameters  .
+ */
+export declare function format<const parameters extends readonly [
+    Parameter | abitype.AbiEventParameter,
+    ...(readonly (Parameter | abitype.AbiEventParameter)[])
+]>(parameters: parameters | readonly [
+    Parameter | abitype.AbiEventParameter,
+    ...(readonly (Parameter | abitype.AbiEventParameter)[])
+]): abitype.FormatAbiParameters<parameters>;
+export declare namespace format {
+    var parseError: (error: unknown) => format.ErrorType;
+}
+export declare namespace format {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Parses arbitrary **JSON ABI Parameters** or **Human Readable ABI Parameters** into typed {@link ox#AbiParameters.AbiParameters}.
+ *
+ * @example
+ * ### JSON Parameters
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const parameters = AbiParameters.from([
+ *   {
+ *     name: 'spender',
+ *     type: 'address',
+ *   },
+ *   {
+ *     name: 'amount',
+ *     type: 'uint256',
+ *   },
+ * ])
+ *
+ * parameters
+ * //^?
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * ```
+ *
+ * @example
+ * ### Human Readable Parameters
+ *
+ * Human Readable ABI Parameters can be parsed into a typed {@link ox#AbiParameters.AbiParameters}:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const parameters = AbiParameters.from('address spender, uint256 amount')
+ *
+ * parameters
+ * //^?
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * ```
+ *
+ * @example
+ * It is possible to specify `struct`s along with your definitions:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const parameters = AbiParameters.from([
+ *   'struct Foo { address spender; uint256 amount; }', // [!code hl]
+ *   'Foo foo, address bar',
+ * ])
+ *
+ * parameters
+ * //^?
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * ```
+ *
+ *
+ *
+ * @param parameters - The ABI Parameters to parse.
+ * @returns The typed ABI Parameters.
+ */
+export declare function from<const parameters extends AbiParameters | string | readonly string[]>(parameters: parameters | AbiParameters | string | readonly string[]): from.ReturnType<parameters>;
+export declare namespace from {
+    var parseError: (error: unknown) => from.ErrorType;
+}
+export declare namespace from {
+    type ReturnType<parameters extends AbiParameters | string | readonly string[]> = parameters extends string ? abitype.ParseAbiParameters<parameters> : parameters extends readonly string[] ? abitype.ParseAbiParameters<parameters> : parameters;
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Throws when the data size is too small for the given parameters.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'uint256' }], '0x010f')
+ * //                                             ↑ ❌ 2 bytes
+ * // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.
+ * // @error: Params: (uint256)
+ * // @error: Data:   0x010f (2 bytes)
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass a valid data size.
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')
+ * //                                             ↑ ✅ 32 bytes
+ * ```
+ */
+export declare class DataSizeTooSmallError extends Errors.BaseError {
+    readonly name = "AbiParameters.DataSizeTooSmallError";
+    constructor({ data, parameters, size, }: {
+        data: Hex.Hex;
+        parameters: readonly Parameter[];
+        size: number;
+    });
+}
+/**
+ * Throws when zero data is provided, but data is expected.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'uint256' }], '0x')
+ * //                                           ↑ ❌ zero data
+ * // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.
+ * // @error: Params: (uint256)
+ * // @error: Data:   0x010f (2 bytes)
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass valid data.
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')
+ * //                                             ↑ ✅ 32 bytes
+ * ```
+ */
+export declare class ZeroDataError extends Errors.BaseError {
+    readonly name = "AbiParameters.ZeroDataError";
+    constructor();
+}
+/**
+ * The length of the array value does not match the length specified in the corresponding ABI parameter.
+ *
+ * ### Example
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from('uint256[3]'), [[69n, 420n]])
+ * //                                               ↑ expected: 3  ↑ ❌ length: 2
+ * // @error: AbiParameters.ArrayLengthMismatchError: ABI encoding array length mismatch
+ * // @error: for type `uint256[3]`. Expected: `3`. Given: `2`.
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass an array of the correct length.
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from(['uint256[3]']), [[69n, 420n, 69n]])
+ * //                                                         ↑ ✅ length: 3
+ * ```
+ */
+export declare class ArrayLengthMismatchError extends Errors.BaseError {
+    readonly name = "AbiParameters.ArrayLengthMismatchError";
+    constructor({ expectedLength, givenLength, type, }: {
+        expectedLength: number;
+        givenLength: number;
+        type: string;
+    });
+}
+/**
+ * The size of the bytes value does not match the size specified in the corresponding ABI parameter.
+ *
+ * ### Example
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from('bytes8'), [['0xdeadbeefdeadbeefdeadbeef']])
+ * //                                            ↑ expected: 8 bytes  ↑ ❌ size: 12 bytes
+ * // @error: BytesSizeMismatchError: Size of bytes "0xdeadbeefdeadbeefdeadbeef"
+ * // @error: (bytes12) does not match expected size (bytes8).
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass a bytes value of the correct size.
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from(['bytes8']), ['0xdeadbeefdeadbeef'])
+ * //                                                       ↑ ✅ size: 8 bytes
+ * ```
+ */
+export declare class BytesSizeMismatchError extends Errors.BaseError {
+    readonly name = "AbiParameters.BytesSizeMismatchError";
+    constructor({ expectedSize, value, }: {
+        expectedSize: number;
+        value: Hex.Hex;
+    });
+}
+/**
+ * The length of the values to encode does not match the length of the ABI parameters.
+ *
+ * ### Example
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from(['string', 'uint256']), ['hello'])
+ * // @error: LengthMismatchError: ABI encoding params/values length mismatch.
+ * // @error: Expected length (params): 2
+ * // @error: Given length (values): 1
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass the correct number of values to encode.
+ *
+ * ### Solution
+ *
+ * Pass a [valid ABI type](https://docs.soliditylang.org/en/develop/abi-spec.html#types).
+ */
+export declare class LengthMismatchError extends Errors.BaseError {
+    readonly name = "AbiParameters.LengthMismatchError";
+    constructor({ expectedLength, givenLength, }: {
+        expectedLength: number;
+        givenLength: number;
+    });
+}
+/**
+ * The value provided is not a valid array as specified in the corresponding ABI parameter.
+ *
+ * ### Example
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from(['uint256[3]']), [69])
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass an array value.
+ */
+export declare class InvalidArrayError extends Errors.BaseError {
+    readonly name = "AbiParameters.InvalidArrayError";
+    constructor(value: unknown);
+}
+/**
+ * Throws when the ABI parameter type is invalid.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'lol' }], '0x00000000000000000000000000000000000000000000000000000000000010f')
+ * //                             ↑ ❌ invalid type
+ * // @error: AbiParameters.InvalidTypeError: Type `lol` is not a valid ABI Type.
+ * ```
+ */
+export declare class InvalidTypeError extends Errors.BaseError {
+    readonly name = "AbiParameters.InvalidTypeError";
+    constructor(type: string);
+}
+//# sourceMappingURL=AbiParameters.d.ts.map

package/_types/AbiParameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbiParameters.d.ts","sourceRoot":"","sources":["../AbiParameters.ts"],"names":[],"mappings":"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"}

package/_types/AccessList.d.ts

@@ -0,0 +1,83 @@
+import * as Address from './Address.js';
+import * as Errors from './Errors.js';
+import * as Hex from './Hex.js';
+import type { Compute } from './internal/types.js';
+export type AccessList = Compute<readonly Item[]>;
+export type Item = Compute<{
+    address: Address.Address;
+    storageKeys: readonly Hex.Hex[];
+}>;
+export type ItemTuple = Compute<[
+    address: Address.Address,
+    storageKeys: readonly Hex.Hex[]
+]>;
+export type Tuple = readonly ItemTuple[];
+/**
+ * Converts a list of Access List tuples into a object-formatted list.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AccessList } from 'ox'
+ *
+ * const accessList = AccessList.fromTupleList([
+ *   [
+ *     '0x0000000000000000000000000000000000000000',
+ *     [
+ *       '0x0000000000000000000000000000000000000000000000000000000000000001',
+ *       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',
+ *     ],
+ *   ],
+ * ])
+ * // @log: [
+ * // @log:   {
+ * // @log:     address: '0x0000000000000000000000000000000000000000',
+ * // @log:     storageKeys: [
+ * // @log:       '0x0000000000000000000000000000000000000000000000000000000000000001',
+ * // @log:       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',
+ * // @log:     ],
+ * // @log:   },
+ * // @log: ]
+ * ```
+ *
+ * @param accessList - List of tuples.
+ * @returns Access list.
+ */
+export declare function fromTupleList(accessList: Tuple): AccessList;
+/**
+ * Converts a structured Access List into a list of tuples.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AccessList } from 'ox'
+ *
+ * const accessList = AccessList.toTupleList([
+ *   {
+ *     address: '0x0000000000000000000000000000000000000000',
+ *     storageKeys: [
+ *       '0x0000000000000000000000000000000000000000000000000000000000000001',
+ *       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe'],
+ *   },
+ * ])
+ * // @log: [
+ * // @log:   [
+ * // @log:     '0x0000000000000000000000000000000000000000',
+ * // @log:     [
+ * // @log:       '0x0000000000000000000000000000000000000000000000000000000000000001',
+ * // @log:       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',
+ * // @log:     ],
+ * // @log:   ],
+ * // @log: ]
+ * ```
+ *
+ * @param accessList - Access list.
+ * @returns List of tuples.
+ */
+export declare function toTupleList(accessList?: AccessList | undefined): Compute<Tuple>;
+/** Thrown when the size of a storage key is invalid. */
+export declare class InvalidStorageKeySizeError extends Errors.BaseError {
+    readonly name = "AccessList.InvalidStorageKeySizeError";
+    constructor({ storageKey }: {
+        storageKey: Hex.Hex;
+    });
+}
+//# sourceMappingURL=AccessList.d.ts.map

package/_types/AccessList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccessList.d.ts","sourceRoot":"","sources":["../AccessList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,GAAG,MAAM,UAAU,CAAA;AAC/B,OAAO,KAAK,EAAE,OAAO,EAAW,MAAM,qBAAqB,CAAA;AAE3D,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAA;AAEjD,MAAM,MAAM,IAAI,GAAG,OAAO,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;IACxB,WAAW,EAAE,SAAS,GAAG,CAAC,GAAG,EAAE,CAAA;CAChC,CAAC,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,OAAO,CAC7B;IAAC,OAAO,EAAE,OAAO,CAAC,OAAO;IAAE,WAAW,EAAE,SAAS,GAAG,CAAC,GAAG,EAAE;CAAC,CAC5D,CAAA;AAED,MAAM,MAAM,KAAK,GAAG,SAAS,SAAS,EAAE,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,KAAK,GAAG,UAAU,CAe3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,WAAW,CACzB,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,GAClC,OAAO,CAAC,KAAK,CAAC,CAgBhB;AAED,wDAAwD;AACxD,qBAAa,0BAA2B,SAAQ,MAAM,CAAC,SAAS;IAC9D,SAAkB,IAAI,2CAA0C;gBACpD,EAAE,UAAU,EAAE,EAAE;QAAE,UAAU,EAAE,GAAG,CAAC,GAAG,CAAA;KAAE;CAKpD"}

package/_types/AccountProof.d.ts

@@ -0,0 +1,32 @@
+import type { Address, Hex } from './index.js';
+/** An Account Proof as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/state.yaml). */
+export type AccountProof<bigintType = bigint, numberType = number> = {
+    /** The address of the account. */
+    address: Address.Address;
+    /** The balance of the account. */
+    balance: bigintType;
+    /** The code hash of the account. */
+    codeHash: Hex.Hex;
+    /** The nonce of the account. */
+    nonce: numberType;
+    /** The storage hash of the account. */
+    storageHash: Hex.Hex;
+    /** The account proofs. */
+    accountProof: readonly Hex.Hex[];
+    /** The storage proofs. */
+    storageProof: readonly StorageProof<bigintType>[];
+};
+/** An RPC Account Proof as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/state.yaml). */
+export type Rpc = AccountProof<Hex.Hex, Hex.Hex>;
+/** A Storage Proof as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/state.yaml). */
+export type StorageProof<bigintType = bigint> = {
+    /** The key of the storage. */
+    key: Hex.Hex;
+    /** The proofs of the storage. */
+    proof: readonly Hex.Hex[];
+    /** The value of the storage. */
+    value: bigintType;
+};
+/** An RPC Storage Proof as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/state.yaml). */
+export type StorageProofRpc = StorageProof<Hex.Hex>;
+//# sourceMappingURL=AccountProof.d.ts.map

package/_types/AccountProof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountProof.d.ts","sourceRoot":"","sources":["../AccountProof.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAE9C,qJAAqJ;AACrJ,MAAM,MAAM,YAAY,CAAC,UAAU,GAAG,MAAM,EAAE,UAAU,GAAG,MAAM,IAAI;IACnE,kCAAkC;IAClC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;IACxB,kCAAkC;IAClC,OAAO,EAAE,UAAU,CAAA;IACnB,oCAAoC;IACpC,QAAQ,EAAE,GAAG,CAAC,GAAG,CAAA;IACjB,gCAAgC;IAChC,KAAK,EAAE,UAAU,CAAA;IACjB,uCAAuC;IACvC,WAAW,EAAE,GAAG,CAAC,GAAG,CAAA;IACpB,0BAA0B;IAC1B,YAAY,EAAE,SAAS,GAAG,CAAC,GAAG,EAAE,CAAA;IAChC,0BAA0B;IAC1B,YAAY,EAAE,SAAS,YAAY,CAAC,UAAU,CAAC,EAAE,CAAA;CAClD,CAAA;AAED,yJAAyJ;AACzJ,MAAM,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAA;AAEhD,oJAAoJ;AACpJ,MAAM,MAAM,YAAY,CAAC,UAAU,GAAG,MAAM,IAAI;IAC9C,8BAA8B;IAC9B,GAAG,EAAE,GAAG,CAAC,GAAG,CAAA;IACZ,iCAAiC;IACjC,KAAK,EAAE,SAAS,GAAG,CAAC,GAAG,EAAE,CAAA;IACzB,gCAAgC;IAChC,KAAK,EAAE,UAAU,CAAA;CAClB,CAAA;AAED,yJAAyJ;AACzJ,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA"}