ox 0.14.28 → 1.0.0-beta.0

package/dist/index.js

@@ -0,0 +1,3786 @@
+/** @entrypointCategory Core */
+// biome-ignore lint/complexity/noUselessEmptyExport: tsdoc
+/**
+ * Utilities & types for working with [Application Binary Interfaces (ABIs)](https://docs.soliditylang.org/en/latest/abi-spec.html)
+ *
+ * :::note
+ *
+ * If you are looking for ABI parameter **encoding** & **decoding** functions, see {@link ox#AbiParameters.(encode:function)} & {@link ox#AbiParameters.(decode:function)}.
+ *
+ * :::
+ *
+ * @example
+ * ### Instantiating JSON ABIs
+ *
+ * An {@link ox#Abi.Abi} can be instantiated from a JSON ABI by using {@link ox#Abi.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { Abi } from 'ox'
+ *
+ * const abi = Abi.from([
+ *   {
+ *     type: 'function',
+ *     name: 'approve',
+ *     stateMutability: 'nonpayable',
+ *     inputs: [
+ *       {
+ *         name: 'spender',
+ *         type: 'address'
+ *       },
+ *       {
+ *         name: 'amount',
+ *         type: 'uint256'
+ *       }
+ *     ],
+ *     outputs: [{ type: 'bool' }]
+ *   }
+ * ])
+ *
+ * abi
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Instantiating Human Readable ABIs
+ *
+ * An {@link ox#Abi.Abi} can be instantiated from a human-readable ABI by using {@link ox#Abi.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { Abi } from 'ox'
+ *
+ * const abi = Abi.from([
+ *   'function approve(address spender, uint256 amount) returns (bool)'
+ * ])
+ *
+ * abi
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Formatting ABIs
+ *
+ * An {@link ox#Abi.Abi} can be formatted into a human-readable ABI by using {@link ox#Abi.(format:function)}:
+ *
+ * ```ts twoslash
+ * import { Abi } from 'ox'
+ * const abi = Abi.from([
+ *   {
+ *     type: 'function',
+ *     name: 'approve',
+ *     stateMutability: 'nonpayable',
+ *     inputs: [
+ *       {
+ *         name: 'spender',
+ *         type: 'address'
+ *       },
+ *       {
+ *         name: 'amount',
+ *         type: 'uint256'
+ *       }
+ *     ],
+ *     outputs: [{ type: 'bool' }]
+ *   }
+ * ])
+ * //---cut---
+ * const formatted = Abi.format(abi)
+ *
+ * formatted
+ * //    ^?
+ * ```
+ *
+ * @category ABI
+ */
+export * as Abi from './core/Abi.js';
+/**
+ * Utilities & types for working with [Constructors](https://docs.soliditylang.org/en/latest/abi-spec.html#json) on ABIs.
+ *
+ * `AbiConstructor` is a sub-type of [`AbiItem`](/api/AbiItem).
+ *
+ * @example
+ * ### Instantiating via JSON ABI
+ *
+ * An `AbiConstructor` can be instantiated from a JSON ABI by using {@link ox#AbiConstructor.(fromAbi:function)}:
+ *
+ * ```ts twoslash
+ * import { Abi, AbiConstructor } from 'ox'
+ *
+ * const abi = Abi.from([
+ *   'constructor(address owner)',
+ *   'function foo()',
+ *   'event Transfer(address owner, address to, uint256 tokenId)',
+ *   'function bar(string a) returns (uint256 x)'
+ * ])
+ *
+ * const item = AbiConstructor.fromAbi(abi) // [!code focus]
+ * //    ^?
+ * ```
+ *
+ * @example
+ * ### Instantiating via Human-Readable ABI Item
+ *
+ * An `AbiConstructor` can be instantiated from a human-readable ABI by using {@link ox#AbiConstructor.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiConstructor } from 'ox'
+ *
+ * const constructor = AbiConstructor.from(
+ *   'constructor(address owner)'
+ * )
+ *
+ * constructor
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Encoding to Deploy Data
+ *
+ * Constructor arguments can be ABI-encoded using {@link ox#AbiConstructor.(encode:function)} (with bytecode) into deploy data. This data can then be passed to a transaction to deploy a contract.
+ *
+ * ```ts twoslash
+ * import { AbiConstructor } from 'ox'
+ *
+ * const constructor = AbiConstructor.from(
+ *   'constructor(address, uint256)'
+ * )
+ *
+ * const data = AbiConstructor.encode(constructor, {
+ *   // [!code focus]
+ *   bytecode: '0x...', // [!code focus]
+ *   args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 123n] // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @category ABI
+ */
+export * as AbiConstructor from './core/AbiConstructor.js';
+/**
+ * Utilities & types for working with [Errors](https://docs.soliditylang.org/en/latest/abi-spec.html#json) on ABIs.
+ *
+ * `AbiError` is a sub-type of [`AbiItem`](/api/AbiItem).
+ *
+ * @example
+ * ### Instantiating via JSON ABI
+ *
+ * An `AbiError` can be instantiated from a JSON ABI by using {@link ox#AbiError.(fromAbi:function)}:
+ *
+ * ```ts twoslash
+ * import { Abi, AbiError } from 'ox'
+ *
+ * const abi = Abi.from([
+ *   'function foo()',
+ *   'error BadSignatureV(uint8 v)',
+ *   'function bar(string a) returns (uint256 x)'
+ * ])
+ *
+ * const item = AbiError.fromAbi(abi, 'BadSignatureV') // [!code focus]
+ * //    ^?
+ * ```
+ *
+ * @example
+ * ### Instantiating via Human-Readable ABI Item
+ *
+ * An `AbiError` can be instantiated from a human-readable ABI by using {@link ox#AbiError.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiError } from 'ox'
+ *
+ * const error = AbiError.from('error BadSignatureV(uint8 v)')
+ *
+ * error
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Decoding Error Data
+ *
+ * Error data can be ABI-decoded using the {@link ox#AbiError.(decode:function)} function.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Abi, AbiError } from 'ox'
+ *
+ * const abi = Abi.from([...])
+ * const error = AbiError.fromAbi(abi, 'InvalidSignature')
+ *
+ * const value = AbiError.decode(error, '0xecde634900000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000001') // [!code focus]
+ * // @log: [420n, 69n, 1]
+ * ```
+ *
+ * @category ABI
+ */
+export * as AbiError from './core/AbiError.js';
+/**
+ * Utilities & types for working with [Events](https://docs.soliditylang.org/en/latest/abi-spec.html#json) on ABIs.
+ *
+ * `AbiEvent` is a sub-type of [`AbiItem`](/api/AbiItem).
+ *
+ * @example
+ * ### Instantiating via JSON ABI
+ *
+ * An `AbiEvent` can be instantiated from a JSON ABI by using {@link ox#AbiEvent.(fromAbi:function)}:
+ *
+ * ```ts twoslash
+ * import { Abi, AbiEvent } from 'ox'
+ *
+ * const abi = Abi.from([
+ *   'function foo()',
+ *   'event Transfer(address owner, address to, uint256 tokenId)',
+ *   'function bar(string a) returns (uint256 x)'
+ * ])
+ *
+ * const item = AbiEvent.fromAbi(abi, 'Transfer') // [!code focus]
+ * //    ^?
+ * ```
+ *
+ * @example
+ * ### Instantiating via Human-Readable ABI Item
+ *
+ * An `AbiEvent` can be instantiated from a human-readable ABI by using {@link ox#AbiEvent.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiEvent } from 'ox'
+ *
+ * const transfer = AbiEvent.from(
+ *   'event Transfer(address indexed from, address indexed to, uint256 value)' // [!code hl]
+ * )
+ *
+ * transfer
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Encoding to Event Topics
+ *
+ * Encode an `AbiEvent` into topics using {@link ox#AbiEvent.(encode:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiEvent } from 'ox'
+ *
+ * const transfer = AbiEvent.from(
+ *   'event Transfer(address indexed from, address indexed to, uint256 value)'
+ * )
+ *
+ * const { topics } = AbiEvent.encode(transfer, {
+ *   from: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266', // [!code hl]
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8' // [!code hl]
+ * })
+ * // @log: [
+ * // @log:   '0x406dade31f7ae4b5dbc276258c28dde5ae6d5c2773c5745802c493a2360e55e0',
+ * // @log:   '0x00000000000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+ * // @log:   '0x0000000000000000000000000000000070997970c51812dc3a010c7d01b50e0d17dc79c8'
+ * // @log: ]
+ * ```
+ *
+ * @example
+ * ### Decoding Event Topics and Data
+ *
+ * Event topics and data can be decoded using {@link ox#AbiEvent.(decode:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiEvent } from 'ox'
+ *
+ * const transfer = AbiEvent.from(
+ *   'event Transfer(address indexed from, address indexed to, uint256 value)'
+ * )
+ *
+ * const log = {
+ *   // ...
+ *   data: '0x0000000000000000000000000000000000000000000000000000000000000001',
+ *   topics: [
+ *     '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+ *     '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+ *     '0x000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac'
+ *   ]
+ * } as const
+ *
+ * const decoded = AbiEvent.decode(transfer, log)
+ * // @log: {
+ * // @log:   from: '0xa5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+ * // @log:   to: '0xa5cc3c03994db5b0d9a5eedd10cabab0813678ac',
+ * // @log:   value: 1n
+ * // @log: }
+ * ```
+ *
+ * @category ABI
+ */
+export * as AbiEvent from './core/AbiEvent.js';
+/**
+ * Utilities & types for working with [Functions](https://docs.soliditylang.org/en/latest/abi-spec.html#json) on ABIs.
+ *
+ * `AbiFunction` is a sub-type of [`AbiItem`](/api/AbiItem).
+ *
+ * @example
+ * ### Instantiating via JSON ABI
+ *
+ * An `AbiFunction` can be instantiated from a JSON ABI by using {@link ox#AbiFunction.(fromAbi:function)}:
+ *
+ * ```ts twoslash
+ * import { Abi, AbiFunction } from 'ox'
+ *
+ * const abi = Abi.from([
+ *   'function foo()',
+ *   'event Transfer(address owner, address to, uint256 tokenId)',
+ *   'function bar(string a) returns (uint256 x)'
+ * ])
+ *
+ * const item = AbiFunction.fromAbi(abi, 'bar') // [!code focus]
+ * //    ^?
+ * ```
+ *
+ * @example
+ * ### Instantiating via Human-Readable ABI Item
+ *
+ * An `AbiFunction` can be instantiated from a human-readable ABI by using {@link ox#AbiFunction.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiFunction } from 'ox'
+ *
+ * const bar = AbiFunction.from(
+ *   'function bar(string a) returns (uint256 x)'
+ * )
+ *
+ * bar
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Encoding to Function Data
+ *
+ * A Function and its arguments can be ABI-encoded into data using the {@link ox#AbiFunction.(encodeData:function)} function. The output of this function can then be passed to `eth_sendTransaction` or `eth_call` as the `data` parameter.
+ *
+ * ```ts twoslash
+ * import { AbiFunction } from 'ox'
+ *
+ * const approve = AbiFunction.from(
+ *   'function approve(address, uint256)'
+ * )
+ *
+ * const data = AbiFunction.encodeData(
+ *   // [!code focus]
+ *   approve, // [!code focus]
+ *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 69420n] // [!code focus]
+ * ) // [!code focus]
+ * // @log: '0x095ea7b3000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa960450000000000000000000000000000000000000000000000000000000000010f2c'
+ * ```
+ *
+ * @example
+ * ### Decoding a Function's Result
+ *
+ * A Function's result can be ABI-decoded using the {@link ox#AbiFunction.(decodeResult:function)} function.
+ *
+ * ```ts twoslash
+ * import { AbiFunction } from 'ox'
+ *
+ * const data =
+ *   '0x000000000000000000000000000000000000000000000000000000000000002a'
+ * //    ↑ Example data that could be returned from a contract call via `eth_call`.
+ *
+ * const totalSupply = AbiFunction.from(
+ *   'function totalSupply() returns (uint256)'
+ * )
+ *
+ * const output = AbiFunction.decodeResult(totalSupply, data) // [!code focus]
+ * // @log: 42n
+ * ```
+ *
+ * @category ABI
+ */
+export * as AbiFunction from './core/AbiFunction.js';
+/**
+ * Utilities & types for working with [ABI Items](https://docs.soliditylang.org/en/latest/abi-spec.html#json)
+ *
+ * The `AbiItem` type is a super-type of:
+ * - [`AbiConstructor`](/api/AbiConstructor)
+ * - [`AbiFunction`](/api/AbiFunction)
+ * - [`AbiEvent`](/api/AbiEvent)
+ * - [`AbiError`](/api/AbiError)
+ *
+ * @example
+ * ### Instantiating via JSON ABI
+ *
+ * An `AbiItem` can be instantiated from a JSON ABI by using {@link ox#AbiItem.(fromAbi:function)}:
+ *
+ * ```ts twoslash
+ * import { Abi, AbiItem } from 'ox'
+ *
+ * const abi = Abi.from([
+ *   'function foo()',
+ *   'event Transfer(address owner, address to, uint256 tokenId)',
+ *   'function bar(string a) returns (uint256 x)'
+ * ])
+ *
+ * const item = AbiItem.fromAbi(abi, 'Transfer') // [!code focus]
+ * //    ^?
+ * ```
+ *
+ * @example
+ * ### Instantiating via Human-Readable ABI Item
+ *
+ * A Human Readable ABI can be parsed into a typed ABI object:
+ *
+ * ```ts twoslash
+ * import { AbiItem } from 'ox'
+ *
+ * const abiItem = AbiItem.from(
+ *   'function approve(address spender, uint256 amount) returns (bool)'
+ * )
+ *
+ * abiItem
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Formatting ABI Items
+ *
+ * An `AbiItem` can be formatted into a human-readable ABI Item by using {@link ox#AbiItem.(format:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiItem } from 'ox'
+ *
+ * const abiItem = AbiItem.from(
+ *   'function approve(address spender, uint256 amount) returns (bool)'
+ * )
+ *
+ * const formatted = AbiItem.format(abiItem)
+ * // @log: 'function approve(address spender, uint256 amount) returns (bool)'
+ * ```
+ *
+ * @category ABI
+ */
+export * as AbiItem from './core/AbiItem.js';
+/**
+ * Utilities & types for encoding, decoding, and working with [ABI Parameters](https://docs.soliditylang.org/en/latest/abi-spec.html#types)
+ *
+ * @example
+ * ### Encoding ABI Parameters
+ *
+ * ABI Parameters can be ABI-encoded as per the [Application Binary Interface (ABI) Specification](https://docs.soliditylang.org/en/latest/abi-spec) using {@link ox#AbiParameters.(encode:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const data = AbiParameters.encode(
+ *   AbiParameters.from('string, uint, bool'),
+ *   ['wagmi', 420n, true]
+ * )
+ * ```
+ *
+ * :::tip
+ *
+ * The example above uses {@link ox#AbiParameters.(from:function)} to specify human-readable ABI Parameters.
+ *
+ * However, you can also pass JSON-ABI Parameters:
+ *
+ * ```ts
+ * import { AbiParameters } from 'ox'
+ *
+ * const data = AbiParameters.encode(
+ *   [{ type: 'string' }, { type: 'uint' }, { type: 'bool' }],
+ *   ['wagmi', 420n, true]
+ * )
+ * ```
+ *
+ * :::
+ *
+ * @example
+ * ### Decoding ABI Parameters
+ *
+ * ABI-encoded data can be decoded using {@link ox#AbiParameters.(decode:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const data = AbiParameters.decode(
+ *   AbiParameters.from('string, uint, bool'),
+ *   '0x000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000001a4000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000057761676d69000000000000000000000000000000000000000000000000000000'
+ * )
+ * // @log: ['wagmi', 420n, true]
+ * ```
+ *
+ * @example
+ * ### JSON-ABI Parameters
+ *
+ * JSON-ABI Parameters can be instantiated using {@link ox#AbiParameters.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const parameters = AbiParameters.from([
+ *   {
+ *     name: 'spender',
+ *     type: 'address'
+ *   },
+ *   {
+ *     name: 'amount',
+ *     type: 'uint256'
+ *   }
+ * ])
+ *
+ * parameters
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Human Readable ABI Parameters
+ *
+ * Human Readable ABI Parameters can be instantiated using {@link ox#AbiParameters.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const parameters = AbiParameters.from(
+ *   'address spender, uint256 amount'
+ * )
+ *
+ * parameters
+ * //^?
+ * ```
+ *
+ * @category ABI
+ */
+export * as AbiParameters from './core/AbiParameters.js';
+/**
+ * Utilities & types for working with Access Lists as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/4140e528360fea53c34a766d86a000c6c039100e/src/schemas/transaction.yaml#L73)
+ *
+ * @category Execution Spec
+ */
+export * as AccessList from './core/AccessList.js';
+/**
+ * Utilities & types for working with Account Proofs as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/state.yaml)
+ *
+ * @category Execution Spec
+ */
+export * as AccountProof from './core/AccountProof.js';
+/**
+ * Utility functions for working with Ethereum addresses.
+ *
+ * @example
+ * ### Instantiating Addresses
+ *
+ * An {@link ox#Address.Address} can be instantiated from a hex string using {@link ox#Address.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * const address = Address.from(
+ *   '0xa0cf798816d4b9b9866b5330eea46a18382f251e'
+ * )
+ * // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'
+ * ```
+ *
+ * @example
+ * ### Validating Addresses
+ *
+ * The {@link ox#Address.(validate:function)} function will return `true` if the address is valid, and `false` otherwise:
+ *
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * const valid = Address.validate(
+ *   '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'
+ * )
+ * // @log: true
+ * ```
+ *
+ * The {@link ox#Address.(assert:function)} function will throw an error if the address is invalid:
+ *
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ *
+ * Address.assert('0xdeadbeef')
+ * // @error: InvalidAddressError: Address "0xdeadbeef" is invalid.
+ * ```
+ *
+ * @example
+ * ### Addresses from ECDSA Public Keys
+ *
+ * An {@link ox#Address.Address} can be computed from an ECDSA public key using {@link ox#Address.(fromPublicKey:function)}:
+ *
+ * ```ts twoslash
+ * import { Address, Secp256k1 } from 'ox'
+ *
+ * const privateKey = Secp256k1.randomPrivateKey()
+ * const publicKey = Secp256k1.getPublicKey({ privateKey })
+ *
+ * const address = Address.fromPublicKey(publicKey)
+ * // @log: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e'
+ * ```
+ *
+ * @category Addresses
+ */
+export * as Address from './core/Address.js';
+/**
+ * Utilities & types for working with AES-GCM encryption. Internally uses the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API).
+ *
+ * @example
+ * ### Encrypting Data
+ *
+ * Data can be encrypted using {@link ox#AesGcm.(encrypt:function)}:
+ *
+ * ```ts twoslash
+ * import { AesGcm, Hex } from 'ox'
+ *
+ * const key = await AesGcm.getKey({ password: 'qwerty' })
+ * const secret = Hex.fromString('i am a secret message')
+ *
+ * const encrypted = await AesGcm.encrypt(secret, key) // [!code focus]
+ * // @log: '0x5e257b25bcf53d5431e54e5a68ca0138306d31bb6154f35a97bb8ea18111e7d82bcf619d3c76c4650688bc5310eed80b8fc86d1e3e'
+ * ```
+ *
+ * @example
+ * ### Decrypting Data
+ *
+ * Data can be decrypted using {@link ox#AesGcm.(decrypt:function)}:
+ *
+ * ```ts twoslash
+ * import { AesGcm, Hex } from 'ox'
+ *
+ * const key = await AesGcm.getKey({ password: 'qwerty' })
+ * const encrypted = await AesGcm.encrypt(
+ *   Hex.fromString('i am a secret message'),
+ *   key
+ * )
+ *
+ * const decrypted = await AesGcm.decrypt(encrypted, key) // [!code focus]
+ * // @log: Hex.fromString('i am a secret message')
+ * ```
+ *
+ * @category Crypto
+ */
+export * as AesGcm from './core/AesGcm.js';
+/**
+ * Utility functions for working with [EIP-7702](https://eips.ethereum.org/EIPS/eip-7702) Authorization lists & tuples.
+ *
+ * @example
+ * ### Instantiating Authorizations
+ *
+ * An Authorization can be instantiated using {@link ox#Authorization.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { Authorization } from 'ox'
+ *
+ * const authorization = Authorization.from({
+ *   address: '0x1234567890abcdef1234567890abcdef12345678',
+ *   chainId: 1,
+ *   nonce: 69n
+ * })
+ * ```
+ *
+ * @example
+ * ### Computing Sign Payload
+ *
+ * A signing payload can be computed using {@link ox#Authorization.(getSignPayload:function)}. The result can then be passed to signing functions like {@link ox#Secp256k1.(sign:function)}.
+ *
+ * ```ts twoslash
+ * import { Authorization, Secp256k1 } from 'ox'
+ *
+ * const authorization = Authorization.from({
+ *   address: '0x1234567890abcdef1234567890abcdef12345678',
+ *   chainId: 1,
+ *   nonce: 69n
+ * })
+ *
+ * const payload = Authorization.getSignPayload(authorization) // [!code focus]
+ *
+ * const signature = Secp256k1.sign({
+ *   payload,
+ *   privateKey: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * ### Attaching Signatures to Authorizations
+ *
+ * A signature can be attached to an Authorization using {@link ox#Authorization.(from:function)}:
+ *
+ * ```ts twoslash
+ * import {
+ *   Authorization,
+ *   Secp256k1,
+ *   TxEnvelopeEip7702,
+ *   Value
+ * } from 'ox'
+ *
+ * const authorization = Authorization.from({
+ *   address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+ *   chainId: 1,
+ *   nonce: 40n
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: Authorization.getSignPayload(authorization),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const authorization_signed = Authorization.from(
+ *   authorization,
+ *   { signature }
+ * ) // [!code focus]
+ *
+ * const envelope = TxEnvelopeEip7702.from({
+ *   authorizationList: [authorization_signed],
+ *   chainId: 1,
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1')
+ * })
+ * ```
+ *
+ * @category Authorization (EIP-7702)
+ */
+export * as Authorization from './core/Authorization.js';
+/**
+ * Utility functions for working with Base32 values using the [BIP-173](https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki) bech32 alphabet.
+ *
+ * @example
+ * ### Encoding to Base32
+ *
+ * ```ts twoslash
+ * import { Base32 } from 'ox'
+ *
+ * const value = Base32.fromHex('0x00ff00')
+ * ```
+ *
+ * @example
+ * ### Decoding Base32
+ *
+ * ```ts twoslash
+ * import { Base32 } from 'ox'
+ *
+ * const value = Base32.toBytes('qrlsq')
+ * ```
+ *
+ * @category Data
+ */
+export * as Base32 from './core/Base32.js';
+/**
+ * Utility functions for working with [Base58](https://digitalbazaar.github.io/base58-spec/) values.
+ *
+ * @example
+ * ### Encoding to Base58
+ *
+ * Values can be encoded to Base58 with:
+ *
+ * - {@link ox#Base58.(fromString:function)}, or
+ *
+ * - {@link ox#Base58.(fromBytes:function)}, or
+ *
+ * - {@link ox#Base58.(fromHex:function)}
+ *
+ * ```ts twoslash
+ * import { Base58 } from 'ox'
+ *
+ * const value_string = Base58.fromString('Hello World!')
+ * // @log: '2NEpo7TZRRrLZSi2U'
+ *
+ * const value_bytes = Base58.fromBytes(
+ *   new Uint8Array([
+ *     72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33
+ *   ])
+ * )
+ * // @log: '2NEpo7TZRRrLZSi2U'
+ *
+ * const value_hex = Base58.fromHex(
+ *   '0x48656c6c6f20576f726c6421'
+ * )
+ * // @log: '2NEpo7TZRRrLZSi2U'
+ * ```
+ *
+ * @example
+ * ### Decoding Base58
+ *
+ * Values can be decoded from Base58 with:
+ *
+ * - {@link ox#Base58.(toString:function)}, or
+ *
+ * - {@link ox#Base58.(toBytes:function)}, or
+ *
+ * - {@link ox#Base58.(toHex:function)}
+ *
+ * ```ts twoslash
+ * import { Base58 } from 'ox'
+ *
+ * const value_string = Base58.toString('2NEpo7TZRRrLZSi2U')
+ * // @log: 'Hello World!'
+ *
+ * const value_bytes = Base58.toBytes('2NEpo7TZRRrLZSi2U')
+ * // @log: Uint8Array [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]
+ *
+ * const value_hex = Base58.toHex('2NEpo7TZRRrLZSi2U')
+ * // @log: '0x48656c6c6f20576f726c6421'
+ * ```
+ *
+ * @category Data
+ */
+export * as Base58 from './core/Base58.js';
+/**
+ * Utility functions for working with [RFC-4648](https://datatracker.ietf.org/doc/html/rfc4648) Base64.
+ *
+ * @example
+ * ### Encoding to Base64
+ *
+ * Values can be encoded to Base64 with:
+ *
+ * - {@link ox#Base64.(fromString:function)}, or
+ *
+ * - {@link ox#Base64.(fromBytes:function)}, or
+ *
+ * - {@link ox#Base64.(fromHex:function)}
+ *
+ * ```ts twoslash
+ * import { Base64 } from 'ox'
+ *
+ * const value_string = Base64.fromString('Hello World!')
+ * // @log: 'SGVsbG8gV29ybGQh=='
+ *
+ * const value_bytes = Base64.fromBytes(
+ *   new Uint8Array([
+ *     72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33
+ *   ])
+ * )
+ * // @log: 'SGVsbG8gV29ybGQh=='
+ *
+ * const value_hex = Base64.fromHex(
+ *   '0x48656c6c6f20576f726c6421'
+ * )
+ * // @log: 'SGVsbG8gV29ybGQh=='
+ * ```
+ *
+ * ### Decoding Base64
+ *
+ * Values can be decoded from Base64 with:
+ *
+ * - {@link ox#Base64.(toString:function)}, or
+ *
+ * - {@link ox#Base64.(toBytes:function)}, or
+ *
+ * - {@link ox#Base64.(toHex:function)}
+ *
+ * ```ts twoslash
+ * import { Base64 } from 'ox'
+ *
+ * const value_string = Base64.toString('SGVsbG8gV29ybGQh==')
+ * // @log: 'Hello World!'
+ *
+ * const value_bytes = Base64.toBytes('SGVsbG8gV29ybGQh==')
+ * // @log: Uint8Array [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]
+ *
+ * const value_hex = Base64.toHex('SGVsbG8gV29ybGQh==')
+ * // @log: '0x48656c6c6f20576f726c6421'
+ * ```
+ *
+ * @category Data
+ */
+export * as Base64 from './core/Base64.js';
+/**
+ * Utility functions for [BIP-350](https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki) bech32m encoding and decoding.
+ *
+ * @example
+ * ### Encoding
+ *
+ * ```ts twoslash
+ * import { Bech32m } from 'ox'
+ *
+ * const encoded = Bech32m.encode('tempo', new Uint8Array(20))
+ * ```
+ *
+ * @example
+ * ### Decoding
+ *
+ * ```ts twoslash
+ * import { Bech32m } from 'ox'
+ *
+ * const { hrp, data } = Bech32m.decode(
+ *   'tempo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq7w9gdx'
+ * )
+ * ```
+ *
+ * @category Data
+ */
+export * as Bech32m from './core/Bech32m.js';
+/**
+ * Utility functions for working with [EIP-7864](https://eips.ethereum.org/EIPS/eip-7864) Binary State Trees.
+ *
+ * @category Binary State Tree (EIP-7864)
+ */
+export * as BinaryStateTree from './core/BinaryStateTree.js';
+/**
+ * Cell-level helpers for [PeerDAS (EIP-7594)](https://eips.ethereum.org/EIPS/eip-7594):
+ * deriving the 128 cells and cell KZG proofs of an extended blob, and verifying
+ * cell proofs against blob commitments.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { BlobCells, Blobs } from 'ox'
+ * import { kzg } from './kzg'
+ *
+ * const [blob] = Blobs.from('0xdeadbeef')
+ * const { cells, proofs } = BlobCells.fromBlob(blob, { kzg })
+ * ```
+ *
+ * @category Blobs (EIP-7594)
+ */
+export * as BlobCells from './core/BlobCells.js';
+/**
+ * Utility functions for working with [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) Blobs.
+ *
+ * @category Blobs (EIP-4844)
+ */
+export * as Blobs from './core/Blobs.js';
+/**
+ * Utilities & types for working with Blocks as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/block.yaml)
+ *
+ * @example
+ * ### Converting from RPC Format
+ *
+ * Blocks can be converted from RPC format to internal format using {@link ox#Block.(fromRpc:function)}:
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { Block } from 'ox'
+ *
+ * const block = await window
+ *   .ethereum!.request({
+ *     method: 'eth_getBlockByNumber',
+ *     params: ['latest', false]
+ *   })
+ *   .then(Block.fromRpc) // [!code hl]
+ * // @log: {
+ * // @log:   // ...
+ * // @log:   hash: '0xebc3644804e4040c0a74c5a5bbbc6b46a71a5d4010fe0c92ebb2fdf4a43ea5dd',
+ * // @log:   number: 19868020n,
+ * // @log:   size: 520n,
+ * // @log:   timestamp: 1662222222n,
+ * // @log:   // ...
+ * // @log: }
+ * ```
+ *
+ * @category Execution Spec
+ */
+export * as Block from './core/Block.js';
+/**
+ * Utilities & types for working with **Block Overrides**.
+ *
+ * @category Execution Spec
+ */
+export * as BlockOverrides from './core/BlockOverrides.js';
+/**
+ * Utility functions for working with Bloom Filters as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/block.yaml)
+ *
+ * @category Execution Spec
+ */
+export * as Bloom from './core/Bloom.js';
+/**
+ * Utility functions for [BLS12-381](https://hackmd.io/\@benjaminion/bls12-381) cryptography.
+ *
+ * :::info
+ *
+ * The `Bls` module is a friendly wrapper over [`@noble/curves/bls12-381`](https://github.com/paulmillr/noble-curves), an **audited** implementation of BLS12-381.
+ *
+ * :::
+ *
+ * @example
+ * ### Computing a Random Private Key
+ *
+ * A random private key can be computed using {@link ox#Bls.(randomPrivateKey:function)}:
+ *
+ * ```ts twoslash
+ * import { Bls } from 'ox'
+ *
+ * const privateKey = Bls.randomPrivateKey()
+ * // @log: '0x...'
+ * ```
+ *
+ * @example
+ * ### Getting a Public Key
+ *
+ * A public key can be derived from a private key using {@link ox#Bls.(getPublicKey:function)}:
+ *
+ * ```ts twoslash
+ * import { Bls } from 'ox'
+ *
+ * const privateKey = Bls.randomPrivateKey()
+ * const publicKey = Bls.getPublicKey({ privateKey })
+ * // @log: { x: 3251...5152n, y: 1251...5152n, z: 1n }
+ * ```
+ *
+ * @example
+ * ### Signing a Payload
+ *
+ * A payload can be signed using {@link ox#Bls.(sign:function)}:
+ *
+ * ```ts twoslash
+ * import { Bls } from 'ox'
+ *
+ * const privateKey = Bls.randomPrivateKey()
+ * const signature = Bls.sign({
+ *   payload: '0xdeadbeef',
+ *   privateKey
+ * })
+ * // @log: { x: 1251...5152n, y: 1251...5152n, z: 1n }
+ * ```
+ *
+ * @example
+ * ### Verifying a Signature
+ *
+ * A signature can be verified using {@link ox#Secp256k1.(verify:function)}:
+ *
+ * ```ts twoslash
+ * import { Bls } from 'ox'
+ *
+ * const privateKey = Bls.randomPrivateKey()
+ * const publicKey = Bls.getPublicKey({ privateKey })
+ * const signature = Bls.sign({
+ *   payload: '0xdeadbeef',
+ *   privateKey
+ * })
+ *
+ * const isValid = Bls.verify({
+ *   // [!code focus]
+ *   payload: '0xdeadbeef', // [!code focus]
+ *   publicKey, // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ * // @log: true
+ * ```
+ *
+ * @example
+ * ### Aggregating Public Keys & Signatures
+ *
+ * Public keys and signatures can be aggregated using {@link ox#Bls.(aggregate:function)}:
+ *
+ * ```ts twoslash
+ * import { Bls } from 'ox'
+ *
+ * const publicKeys = [
+ *   Bls.getPublicKey({ privateKey: '0x...' }),
+ *   Bls.getPublicKey({ privateKey: '0x...' })
+ * ]
+ * const publicKey = Bls.aggregate(publicKeys)
+ *
+ * const signatures = [
+ *   Bls.sign({ payload: '0x...', privateKey: '0x...' }),
+ *   Bls.sign({ payload: '0x...', privateKey: '0x...' })
+ * ]
+ * const signature = Bls.aggregate(signatures)
+ * ```
+ *
+ * @example
+ * ### Verify Aggregated Signatures
+ *
+ * We can also pass a public key and signature that was aggregated with {@link ox#Bls.(aggregate:function)} to `Bls.verify`.
+ *
+ * ```ts twoslash
+ * import { Bls, Hex } from 'ox'
+ *
+ * const payload = Hex.random(32)
+ * const privateKeys = Array.from({ length: 100 }, () =>
+ *   Bls.randomPrivateKey()
+ * )
+ *
+ * const publicKeys = privateKeys.map((privateKey) =>
+ *   Bls.getPublicKey({ privateKey })
+ * )
+ * const signatures = privateKeys.map((privateKey) =>
+ *   Bls.sign({ payload, privateKey })
+ * )
+ *
+ * const publicKey = Bls.aggregate(publicKeys) // [!code focus]
+ * const signature = Bls.aggregate(signatures) // [!code focus]
+ *
+ * const valid = Bls.verify({ payload, publicKey, signature }) // [!code focus]
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Bls from './core/Bls.js';
+/**
+ * Utility functions for working with BLS12-381 points.
+ *
+ * :::info
+ *
+ * The `BlsPoint` module is a friendly wrapper over [`@noble/curves/bls12-381`](https://github.com/paulmillr/noble-curves), an **audited** implementation of BLS12-381.
+ *
+ * :::
+ *
+ * @example
+ * ### Public Keys or Signatures to Hex
+ *
+ * BLS points can be converted to hex using {@link ox#BlsPoint.(toHex:function)}:
+ *
+ * ```ts twoslash
+ * import { Bls, BlsPoint } from 'ox'
+ *
+ * const publicKey = Bls.getPublicKey({ privateKey: '0x...' })
+ * const publicKeyHex = BlsPoint.toHex(publicKey)
+ * // @log: '0xacafff52270773ad1728df2807c0f1b0b271fa6b37dfb8b2f75448573c76c81bcd6790328a60e40ef5a13343b32d9e66'
+ *
+ * const signature = Bls.sign({
+ *   payload: '0xdeadbeef',
+ *   privateKey: '0x...'
+ * })
+ * const signatureHex = BlsPoint.toHex(signature)
+ * // @log: '0xb4698f7611999fba87033b9cf72312c76c683bbc48175e2d4cb275907d6a267ab9840a66e3051e5ed36fd13aa712f9a9024f9fa9b67f716dfb74ae4efb7d9f1b7b43b4679abed6644cf476c12e79f309351ea8452487cd93f66e29e04ebe427c'
+ * ```
+ *
+ * @example
+ * ### Hex to Public Keys or Signatures
+ *
+ * BLS points can be converted from hex using {@link ox#BlsPoint.(fromHex:function)}:
+ *
+ * ```ts twoslash
+ * import { Bls, BlsPoint } from 'ox'
+ *
+ * const publicKey = BlsPoint.fromHex(
+ *   '0xacafff52270773ad1728df2807c0f1b0b271fa6b37dfb8b2f75448573c76c81bcd6790328a60e40ef5a13343b32d9e66',
+ *   'G1'
+ * )
+ * // @log: { x: 172...514n, y: 175...235n, z: 1n }
+ *
+ * const signature = BlsPoint.fromHex(
+ *   '0xb4698f7611999fba87033b9cf72312c76c683bbc48175e2d4cb275907d6a267ab9840a66e3051e5ed36fd13aa712f9a9024f9fa9b67f716dfb74ae4efb7d9f1b7b43b4679abed6644cf476c12e79f309351ea8452487cd93f66e29e04ebe427c',
+ *   'G2'
+ * )
+ * // @log: { x: 1251...5152n, y: 1251...5152n, z: 1n }
+ * ```
+ *
+ * @category Crypto
+ */
+export * as BlsPoint from './core/BlsPoint.js';
+/**
+ * A set of Ethereum-related utility functions for working with [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) instances.
+ *
+ * @example
+ * ### Instantiating Bytes
+ *
+ * Values can be instantiated as {@link ox#Bytes.Bytes} using:
+ *
+ * - {@link ox#Bytes.(fromArray:function)}
+ *
+ * - {@link ox#Bytes.(fromBoolean:function)}
+ *
+ * - {@link ox#Bytes.(fromHex:function)}
+ *
+ * - {@link ox#Bytes.(fromNumber:function)}
+ *
+ * - {@link ox#Bytes.(fromString:function)}
+ *
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const value_array = Bytes.from([1, 2, 3, 4, 5])
+ * // @log: Uint8Array [1, 2, 3, 4, 5]
+ *
+ * const value_boolean = Bytes.fromBoolean(true)
+ * // @log: Uint8Array [1]
+ *
+ * const value_hex = Bytes.fromHex('0x1234567890abcdef')
+ * // @log: Uint8Array [18, 52, 86, 120, 144, 175, 207, 15]
+ *
+ * const value_number = Bytes.fromNumber(1234567890)
+ * // @log: Uint8Array [4, 160, 216]
+ *
+ * const value_string = Bytes.fromString('Hello World!')
+ * // @log: Uint8Array [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]
+ * ```
+ *
+ * @example
+ * ### Converting from Bytes
+ *
+ * Values can be converted from {@link ox#Bytes.Bytes} using:
+ *
+ * - {@link ox#Bytes.(toBigInt:function)}
+ *
+ * - {@link ox#Bytes.(toBoolean:function)}
+ *
+ * - {@link ox#Bytes.(toHex:function)}
+ *
+ * - {@link ox#Bytes.(toNumber:function)}
+ *
+ * - {@link ox#Bytes.(toString:function)}
+ *
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const value_bigint = Bytes.toBigInt(
+ *   Bytes.from([4, 160, 216])
+ * )
+ * // @log: 1234567890n
+ *
+ * const value_boolean = Bytes.toBoolean(Bytes.from([1]))
+ * // @log: true
+ *
+ * const value_hex = Bytes.toHex(
+ *   Bytes.from([222, 173, 190, 239])
+ * )
+ * // @log: '0xdeadbeef'
+ *
+ * const value_number = Bytes.toNumber(
+ *   Bytes.from([4, 160, 216])
+ * )
+ * // @log: 1234567890
+ *
+ * const value_string = Bytes.toString(
+ *   Bytes.from([
+ *     72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33
+ *   ])
+ * )
+ * // @log: 'Hello World!'
+ * ```
+ *
+ * @example
+ * ### Concatenating Bytes
+ *
+ * Values can be concatenated using {@link ox#Bytes.(concat:function)}:
+ *
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const a = Bytes.from([1, 2, 3])
+ * const b = Bytes.from([4, 5, 6])
+ * const c = Bytes.concat(a, b)
+ * // @log: Uint8Array [1, 2, 3, 4, 5, 6]
+ * ```
+ *
+ * @example
+ * ### Slicing Bytes
+ *
+ * Values can be sliced using {@link ox#Bytes.(slice:function)}:
+ *
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const value = Bytes.slice(
+ *   Bytes.from([1, 2, 3, 4, 5, 6]),
+ *   2,
+ *   4
+ * )
+ * // @log: Uint8Array [3, 4]
+ * ```
+ *
+ * @example
+ * ### Padding Bytes
+ *
+ * Values can be padded with zeroes using {@link ox#Bytes.(padLeft:function)} or {@link ox#Bytes.(padRight:function)}:
+ *
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const value_1 = Bytes.padLeft(Bytes.from([1, 2, 3]), 5)
+ * // @log: Uint8Array [0, 0, 1, 2, 3]
+ *
+ * const value_2 = Bytes.padRight(Bytes.from([1, 2, 3]), 5)
+ * // @log: Uint8Array [1, 2, 3, 0, 0]
+ * ```
+ *
+ * @example
+ * ### Trimming Bytes
+ *
+ * Zeroes in values can be trimmed using {@link ox#Bytes.(trimLeft:function)} or {@link ox#Bytes.(trimRight:function)}:
+ *
+ * ```ts twoslash
+ * import { Bytes } from 'ox'
+ *
+ * const value = Bytes.trimLeft(Bytes.from([0, 0, 1, 2, 3]))
+ * // @log: Uint8Array [1, 2, 3]
+ * ```
+ *
+ * @category Data
+ */
+export * as Bytes from './core/Bytes.js';
+export * as Caches from './core/Caches.js';
+/**
+ * Functions for encoding and decoding CBOR (Concise Binary Object Representation) data.
+ *
+ * CBOR is a binary data format designed for compact data representation and efficient parsing.
+ * It supports all JSON data types plus additional types like byte strings, tags, and simple values.
+ *
+ * @example
+ * ### Encoding Values to CBOR
+ *
+ * Values can be encoded to CBOR using {@link ox#Cbor.(encode:function)}:
+ *
+ * ```ts twoslash
+ * import { Cbor } from 'ox'
+ *
+ * Cbor.encode({ foo: 'bar', baz: [1, 2, 3] })
+ * // @log: '0xa263666f6f636261726362617a83010203'
+ * ```
+ *
+ * ### Decoding CBOR to Values
+ *
+ * Values can be decoded from CBOR using {@link ox#Cbor.(decode:function)}:
+ *
+ * ```ts twoslash
+ * import { Cbor } from 'ox'
+ *
+ * Cbor.decode('0xa263666f6f636261726362617a83010203')
+ * // @log: { foo: 'bar', baz: [1, 2, 3] }
+ * ```
+ *
+ * @category Data
+ */
+export * as Cbor from './core/Cbor.js';
+/**
+ * Utility functions for [Bitcoin's CompactSize](https://en.bitcoin.it/wiki/Protocol_documentation#Variable_length_integer) variable-length integer encoding.
+ *
+ * @example
+ * ### Encoding
+ *
+ * ```ts twoslash
+ * import { CompactSize } from 'ox'
+ *
+ * const bytes = CompactSize.toBytes(65535)
+ * ```
+ *
+ * @example
+ * ### Decoding
+ *
+ * ```ts twoslash
+ * import { CompactSize } from 'ox'
+ *
+ * const { value, size } = CompactSize.fromBytes(
+ *   new Uint8Array([0xfd, 0xff, 0xff])
+ * )
+ * ```
+ *
+ * @category Data
+ */
+export * as CompactSize from './core/CompactSize.js';
+/**
+ * Utility functions for computing Contract Addresses.
+ *
+ * @example
+ * ### Computing Contract Addresses (CREATE)
+ *
+ * A Contract Address that was instantiated using the `CREATE` opcode can be computed using {@link ox#ContractAddress.(fromCreate:function)}:
+ *
+ * ```ts twoslash
+ * import { ContractAddress } from 'ox'
+ *
+ * ContractAddress.fromCreate({
+ *   from: '0x1a1e021a302c237453d3d45c7b82b19ceeb7e2e6',
+ *   nonce: 0n
+ * })
+ * // @log: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2'
+ * ```
+ *
+ * @example
+ * ### Computing Contract Addresses (CREATE2)
+ *
+ * A Contract Address that was instantiated using the `CREATE2` opcode can be computed using {@link ox#ContractAddress.(fromCreate2:function)}:
+ *
+ * ```ts twoslash
+ * import { Bytes, ContractAddress, Hex } from 'ox'
+ *
+ * ContractAddress.fromCreate2({
+ *   from: '0x1a1e021a302c237453d3d45c7b82b19ceeb7e2e6',
+ *   bytecode: Bytes.from(
+ *     '0x6394198df16000526103ff60206004601c335afa6040516060f3'
+ *   ),
+ *   salt: Hex.fromString('hello world')
+ * })
+ * // @log: '0x59fbB593ABe27Cb193b6ee5C5DC7bbde312290aB'
+ * ```
+ *
+ * @category Addresses
+ */
+export * as ContractAddress from './core/ContractAddress.js';
+/**
+ * Utility functions for converting between COSE_Key and P256 public keys.
+ *
+ * COSE_Key is the key format used in WebAuthn attestation objects, as defined in
+ * [RFC 9053](https://datatracker.ietf.org/doc/html/rfc9053).
+ *
+ * @example
+ * ### Encoding a Public Key to COSE_Key
+ *
+ * ```ts twoslash
+ * import { CoseKey, P256 } from 'ox'
+ *
+ * const { publicKey } = P256.createKeyPair()
+ *
+ * const coseKey = CoseKey.fromPublicKey(publicKey)
+ * ```
+ *
+ * @example
+ * ### Decoding a COSE_Key to Public Key
+ *
+ * ```ts twoslash
+ * import { CoseKey, P256 } from 'ox'
+ *
+ * const { publicKey } = P256.createKeyPair()
+ * const coseKey = CoseKey.fromPublicKey(publicKey)
+ *
+ * const publicKey2 = CoseKey.toPublicKey(coseKey)
+ * ```
+ *
+ * @category Crypto
+ */
+export * as CoseKey from './core/CoseKey.js';
+/**
+ * Utilities for working with Ed25519 signatures and key pairs.
+ *
+ * Ed25519 is a modern elliptic curve signature scheme that provides strong security
+ * guarantees and high performance. It is widely used in various cryptographic applications.
+ *
+ * @example
+ * ### Creating Key Pairs
+ *
+ * ```ts twoslash
+ * import { Ed25519 } from 'ox'
+ *
+ * const { privateKey, publicKey } = Ed25519.createKeyPair()
+ * ```
+ *
+ * @example
+ * ### Signing & Verifying
+ *
+ * ```ts twoslash
+ * import { Ed25519 } from 'ox'
+ *
+ * const { privateKey, publicKey } = Ed25519.createKeyPair()
+ * const payload = '0xdeadbeef'
+ *
+ * const signature = Ed25519.sign({ payload, privateKey })
+ * const isValid = Ed25519.verify({
+ *   payload,
+ *   publicKey,
+ *   signature
+ * })
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Ed25519 from './core/Ed25519.js';
+/**
+ * Utility functions for working with ENS names.
+ *
+ * @example
+ * ### Normalizing ENS Names
+ *
+ * ENS names can be normalized using {@link ox#Ens.(normalize:function)}:
+ *
+ * ```ts twoslash
+ * import { Ens } from 'ox'
+ *
+ * const name = Ens.normalize('w𝝣vm.eth')
+ * // @log: 'wξvm.eth'
+ * ```
+ *
+ * @example
+ * ### Namehashing ENS Names
+ *
+ * ENS names can be namehashed using {@link ox#Ens.(namehash:function)}:
+ *
+ * ```ts twoslash
+ * import { Ens } from 'ox'
+ *
+ * const name = Ens.namehash('alice.eth')
+ * // @log: '0x787192fc5378cc32aa956ddfdedbf26b24e8d78e40109add0eea2c1a012c3dec'
+ * ```
+ *
+ * @category ENS
+ */
+export * as Ens from './core/Ens.js';
+export * as Errors from './core/Errors.js';
+/**
+ * @category Execution Spec
+ */
+export * as Fee from './core/Fee.js';
+/**
+ * Utilities & types for working with Filters as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/filter.yaml)
+ *
+ * @category Execution Spec
+ */
+export * as Filter from './core/Filter.js';
+/**
+ * Utility functions for hashing (keccak256, sha256, etc).
+ *
+ * @example
+ * ```ts twoslash
+ * import { Hash } from 'ox'
+ *
+ * const value = Hash.keccak256('0xdeadbeef')
+ * // '0xd4fd4e189132273036449fc9e11198c739161b4c0116a9a2dccdfa1c492006f1'
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Hash from './core/Hash.js';
+/**
+ * Utility functions for generating and working with [BIP-32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) HD Wallets.
+ *
+ * :::info
+ *
+ * The `HdKey` module is a friendly wrapper over [`@scure/bip32`](https://github.com/paulmillr/scure-bip32), an **audited** implementation of [BIP-32](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki) HD Wallets.
+ *
+ * :::
+ *
+ *
+ * @category Crypto
+ */
+export * as HdKey from './core/HdKey.js';
+/**
+ * A set of Ethereum-related utility functions for working with hexadecimal string values (e.g. `"0xdeadbeef"`).
+ *
+ * @example
+ * ### Instantiating Hex
+ *
+ * Values can be instantiated as {@link ox#Hex.Hex} using:
+ *
+ * - {@link ox#Hex.(fromBoolean:function)}
+ *
+ * - {@link ox#Hex.(fromBytes:function)}
+ *
+ * - {@link ox#Hex.(fromNumber:function)}
+ *
+ * - {@link ox#Hex.(fromString:function)}
+ *
+ * ```ts twoslash
+ * import { Bytes, Hex } from 'ox'
+ *
+ * const value_boolean = Hex.fromBoolean(true)
+ * // @log: '0x1'
+ *
+ * const value_bytes = Hex.fromBytes(Bytes.from([1, 2, 3]))
+ * // @log: '0x010203'
+ *
+ * const value_number = Hex.fromNumber(1234567890)
+ * // @log: '0x499602d2'
+ *
+ * const value_string = Hex.fromString('Hello World!')
+ * // @log: '0x48656c6c6f20576f726c6421'
+ * ```
+ *
+ * @example
+ * ### Converting from Hex
+ *
+ * Values can be converted from {@link ox#Hex.Hex} using:
+ *
+ * - {@link ox#Hex.(toBoolean:function)}
+ *
+ * - {@link ox#Hex.(toBytes:function)}
+ *
+ * - {@link ox#Hex.(toNumber:function)}
+ *
+ * - {@link ox#Hex.(toString:function)}
+ *
+ * ```ts twoslash
+ * import { Hex } from 'ox'
+ *
+ * const value_boolean = Hex.toBoolean('0x1')
+ * // @log: true
+ *
+ * const value_bytes = Hex.toBytes('0x010203')
+ * // @log: Uint8Array [1, 2, 3]
+ *
+ * const value_number = Hex.toNumber('0x499602d2')
+ * // @log: 1234567890
+ *
+ * const value_string = Hex.toString(
+ *   '0x48656c6c6f20576f726c6421'
+ * )
+ * // @log: 'Hello World!'
+ * ```
+ *
+ * @example
+ * ### Concatenating Hex
+ *
+ * Hex values can be concatenated using {@link ox#Hex.(concat:function)}:
+ *
+ * ```ts twoslash
+ * import { Hex } from 'ox'
+ *
+ * const a = Hex.fromString('0x1234567890abcdef')
+ * const b = Hex.fromString('0xdeadbeef')
+ * const c = Hex.concat(a, b)
+ * // @log: '0x1234567890abcdefdeadbeef'
+ * ```
+ *
+ * @example
+ * ### Slicing Hex
+ *
+ * Hex values can be sliced using {@link ox#Hex.(slice:function)}:
+ *
+ * ```ts twoslash
+ * import { Hex } from 'ox'
+ *
+ * const value = Hex.slice('0x1234567890abcdefdeadbeef', 2, 8)
+ * // @log: '0x34567890'
+ * ```
+ *
+ * @example
+ * ### Padding Hex
+ *
+ * Hex values can be padded with zeroes using {@link ox#Hex.(padLeft:function)} or {@link ox#Hex.(padRight:function)}:
+ *
+ * ```ts twoslash
+ * import { Hex } from 'ox'
+ *
+ * const value = Hex.padLeft('0x1234567890abcdef', 16)
+ * // @log: '0x00000000000000001234567890abcdef'
+ * ```
+ *
+ * @example
+ * ### Trimming Hex
+ *
+ * Hex values can be trimmed of zeroes using {@link ox#Hex.(trimLeft:function)} or {@link ox#Hex.(trimRight:function)}:
+ *
+ * ```ts twoslash
+ * import { Hex } from 'ox'
+ *
+ * const value = Hex.trimLeft(
+ *   '0x00000000000000001234567890abcdef'
+ * )
+ * // @log: '0x1234567890abcdef'
+ * ```
+ *
+ * @category Data
+ */
+export * as Hex from './core/Hex.js';
+/**
+ * Utility functions for working with JSON (with support for `bigint`).
+ *
+ * @example
+ * ### Stringifying JSON
+ *
+ * JSON values can be stringified (with `bigint` support) using {@link ox#Json.(stringify:function)}:
+ *
+ * ```ts twoslash
+ * import { Json } from 'ox'
+ *
+ * const json = Json.stringify({
+ *   foo: 'bar',
+ *   baz: 69420694206942069420694206942069420694206942069420n
+ * })
+ * // @log: '{"foo":"bar","baz":69420694206942069420694206942069420694206942069420}'
+ * ```
+ *
+ * @example
+ * ### Parsing JSON
+ *
+ * JSON values can be parsed (with `bigint` support) using {@link ox#Json.(parse:function)}:
+ *
+ * ```ts twoslash
+ * import { Json } from 'ox'
+ *
+ * const value = Json.parse(
+ *   '{"foo":"bar","baz":69420694206942069420694206942069420694206942069420}'
+ * )
+ * // @log: { foo: 'bar', baz: 69420694206942069420694206942069420694206942069420n }
+ * ```
+ *
+ * @category JSON
+ */
+export * as Json from './core/Json.js';
+/**
+ * Utilities & types for working with [Keystores](https://ethereum.org/en/developers/docs/data-structures-and-encoding/web3-secret-storage).
+ *
+ * @example
+ * ### Encrypting Private Keys
+ *
+ * Private keys can be encrypted into a JSON keystore using {@link ox#Keystore.(encrypt:function)}:
+ *
+ * ```ts twoslash
+ * import { Keystore, Secp256k1 } from 'ox'
+ *
+ * // Generate a random private key.
+ * const privateKey = Secp256k1.randomPrivateKey()
+ *
+ * // Derive a key from a password.
+ * const [key, opts] = Keystore.pbkdf2({
+ *   password: 'testpassword'
+ * })
+ *
+ * // Encrypt the private key.
+ * const keystore = Keystore.encrypt(privateKey, key, opts)
+ * // @log: {
+ * // @log:   "crypto": {
+ * // @log:     "cipher": "aes-128-ctr",
+ * // @log:     "ciphertext": "...",
+ * // @log:     "cipherparams": {
+ * // @log:       "iv": "...",
+ * // @log:     },
+ * // @log:     "kdf": "pbkdf2",
+ * // @log:     "kdfparams": {
+ * // @log:       "salt": "...",
+ * // @log:       "dklen": 32,
+ * // @log:       "prf": "hmac-sha256",
+ * // @log:       "c": 262144,
+ * // @log:     },
+ * // @log:     "mac": "...",
+ * // @log:   },
+ * // @log:   "id": "...",
+ * // @log:   "version": 3,
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### Decrypting Private Keys
+ *
+ * Private keys can be decrypted from a JSON keystore using {@link ox#Keystore.(decrypt:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Keystore, Secp256k1 } from 'ox'
+ *
+ * const keystore = { crypto: { ... }, id: '...', version: 3 }
+ *
+ * // Derive the key.
+ * const key = Keystore.toKey(keystore, { password: 'testpassword' })
+ *
+ * // Decrypt the private key.
+ * const decrypted = Keystore.decrypt(keystore, key)
+ * // @log: "0x..."
+ *
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Keystore from './core/Keystore.js';
+/**
+ * Utility functions for working with KZG Commitments.
+ *
+ * Mainly for [EIP-4844](https://eips.ethereum.org/EIPS/eip-4844) Blobs.
+ *
+ * @category Blobs (EIP-4844)
+ */
+export * as Kzg from './core/Kzg.js';
+/**
+ * Utilities & types for working with Logs as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/receipt.yaml)
+ *
+ * :::tip
+ *
+ * Utilities for Log encoding & decoding can be found on the {@link ox#AbiEvent} module.
+ *
+ * :::
+ *
+ * @example
+ * ### Converting from RPC Format
+ *
+ * Logs can be converted from their RPC format using {@link ox#Log.(fromRpc:function)}:
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { AbiEvent, Hex, Log } from 'ox'
+ *
+ * const transfer = AbiEvent.from(
+ *   'event Transfer(address indexed from, address indexed to, uint256 indexed value)'
+ * )
+ *
+ * const { topics } = AbiEvent.encode(transfer)
+ *
+ * const logs = await window.ethereum!.request({
+ *   method: 'eth_getLogs',
+ *   params: [
+ *     {
+ *       address: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',
+ *       fromBlock: Hex.fromNumber(19760235n),
+ *       toBlock: Hex.fromNumber(19760240n),
+ *       topics
+ *     }
+ *   ]
+ * })
+ *
+ * const log = Log.fromRpc(logs[0]) // [!code focus]
+ * // @log: {
+ * // @log:   address: '0xfba3912ca04dd458c843e2ee08967fc04f3579c2',
+ * // @log:   blockHash: '0xabe69134e80a12f6a93d0aa18215b5b86c2fb338bae911790ca374a8716e01a4',
+ * // @log:   blockNumber: 19760236n,
+ * // @log:   data: '0x',
+ * // @log:   logIndex: 271,
+ * // @log:   removed: false,
+ * // @log:   topics: [
+ * // @log:     "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+ * // @log:     "0x0000000000000000000000000000000000000000000000000000000000000000",
+ * // @log:     "0x0000000000000000000000000c04d9e9278ec5e4d424476d3ebec70cb5d648d1",
+ * // @log:     "0x000000000000000000000000000000000000000000000000000000000000025b",
+ * // @log:   transactionHash:
+ * // @log:     '0xcfa52db0bc2cb5bdcb2c5bd8816df7a2f018a0e3964ab1ef4d794cf327966e93',
+ * // @log:   transactionIndex: 145,
+ * // @log: }
+ * ```
+ *
+ * @category Execution Spec
+ */
+export * as Log from './core/Log.js';
+/**
+ * Utility functions for generating and working with [BIP-39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki) mnemonics.
+ *
+ * :::info
+ *
+ * The `Mnemonic` module is a friendly wrapper over [`@scure/bip39`](https://github.com/paulmillr/scure-bip39), an **audited** implementation of [BIP-39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki)
+ *
+ * :::
+ *
+ * @example
+ * ### Generating a Random Mnemonic
+ *
+ * Random mnemonics can be generated using {@link ox#Mnemonic.(random:function)}:
+ *
+ * ```ts twoslash
+ * import { Mnemonic } from 'ox'
+ *
+ * const mnemonic = Mnemonic.random(Mnemonic.english)
+ * // @log: 'buyer zoo end danger ice capable shrug naive twist relief mass bonus'
+ * ```
+ *
+ * @example
+ * ### Converting to Private Key
+ *
+ * Mnemonics can be converted to a private key using {@link ox#Mnemonic.(toPrivateKey:function)}:
+ *
+ * ```ts twoslash
+ * import { Mnemonic } from 'ox'
+ *
+ * const privateKey = Mnemonic.toPrivateKey(
+ *   'buyer zoo end danger ice capable shrug naive twist relief mass bonus'
+ * )
+ * // @log: '0x...'
+ * ```
+ *
+ * @example
+ * ### Converting to HD Key
+ *
+ * Mnemonics can be converted to a HD Key using {@link ox#Mnemonic.(toHdKey:function)}:
+ *
+ * ```ts twoslash
+ * import { Mnemonic } from 'ox'
+ *
+ * const hdKey = Mnemonic.toHdKey(
+ *   'buyer zoo end danger ice capable shrug naive twist relief mass bonus'
+ * )
+ * ```
+ *
+ * @example
+ * ### Converting to Seed
+ *
+ * Mnemonics can be converted to a master seed using {@link ox#Mnemonic.(toSeed:function)}:
+ *
+ * ```ts twoslash
+ * import { Mnemonic } from 'ox'
+ *
+ * const mnemonic =
+ *   'buyer zoo end danger ice capable shrug naive twist relief mass bonus'
+ * const seed = Mnemonic.toSeed(mnemonic)
+ * // @log: Uint8Array [...64 bytes]
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Mnemonic from './core/Mnemonic.js';
+/**
+ * Utility functions for [NIST P256](https://csrc.nist.gov/csrc/media/events/workshop-on-elliptic-curve-cryptography-standards/documents/papers/session6-adalier-mehmet.pdf) ECDSA cryptography.
+ *
+ * :::info
+ *
+ * The `P256` module is a friendly wrapper over [`@noble/curves/p256`](https://github.com/paulmillr/noble-curves), an **audited** implementation of [P256](https://www.secg.org/sec2-v2.pdf)
+ *
+ * :::
+ *
+ * @example
+ * ### Computing a Random Private Key
+ *
+ * A random private key can be computed using {@link ox#P256.(randomPrivateKey:function)}:
+ *
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ *
+ * const privateKey = P256.randomPrivateKey()
+ * // @log: '0x...'
+ * ```
+ *
+ * @example
+ * ### Getting a Public Key
+ *
+ * A public key can be derived from a private key using {@link ox#P256.(getPublicKey:function)}:
+ *
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ *
+ * const privateKey = P256.randomPrivateKey()
+ *
+ * const publicKey = P256.getPublicKey({ privateKey }) // [!code focus]
+ * // @log: { x: 3251...5152n, y: 1251...5152n }
+ * ```
+ *
+ * @example
+ * ### Signing a Payload
+ *
+ * A payload can be signed using {@link ox#P256.(sign:function)}:
+ *
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ *
+ * const privateKey = P256.randomPrivateKey()
+ *
+ * const signature = P256.sign({
+ *   payload: '0xdeadbeef',
+ *   privateKey
+ * }) // [!code focus]
+ * // @log: { r: 1251...5152n, s: 1251...5152n, yParity: 1 }
+ * ```
+ *
+ * @example
+ * ### Verifying a Signature
+ *
+ * A signature can be verified using {@link ox#P256.(verify:function)}:
+ *
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ *
+ * const privateKey = P256.randomPrivateKey()
+ * const publicKey = P256.getPublicKey({ privateKey })
+ * const signature = P256.sign({
+ *   payload: '0xdeadbeef',
+ *   privateKey
+ * })
+ *
+ * const isValid = P256.verify({
+ *   // [!code focus]
+ *   payload: '0xdeadbeef', // [!code focus]
+ *   publicKey, // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ * // @log: true
+ * ```
+ *
+ * @category Crypto
+ */
+export * as P256 from './core/P256.js';
+/**
+ * Utilities & types for working with [EIP-191 Personal Messages](https://eips.ethereum.org/EIPS/eip-191#version-0x45-e)
+ *
+ * @example
+ * ### Computing Sign Payload
+ *
+ * An EIP-191 personal sign payload can be computed using {@link ox#PersonalMessage.(getSignPayload:function)}:
+ *
+ * ```ts twoslash
+ * import { Hex, PersonalMessage, Secp256k1 } from 'ox'
+ *
+ * const payload = PersonalMessage.getSignPayload(
+ *   Hex.fromString('hello world')
+ * ) // [!code focus]
+ *
+ * const signature = Secp256k1.sign({
+ *   payload,
+ *   privateKey: '0x...'
+ * })
+ * ```
+ *
+ * @category Signed & Typed Data
+ */
+export * as PersonalMessage from './core/PersonalMessage.js';
+/**
+ * Utilities & types for working with [EIP-1193 Providers](https://eips.ethereum.org/EIPS/eip-1193)
+ *
+ * @example
+ * ### Instantiating External Providers
+ *
+ * External EIP-1193 Providers can be instantiated with {@link ox#Provider.(from:function)}:
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { Provider } from 'ox'
+ *
+ * const provider = Provider.from(window.ethereum)
+ *
+ * const blockNumber = await provider.request({
+ *   method: 'eth_blockNumber'
+ * })
+ * ```
+ *
+ * :::tip
+ *
+ * There are also libraries that distribute EIP-1193 Provider objects that you can use with `Provider.from`:
+ *
+ * - [`@walletconnect/ethereum-provider`](https://www.npmjs.com/package/\@walletconnect/ethereum-provider)
+ *
+ * - [`@coinbase/wallet-sdk`](https://www.npmjs.com/package/\@coinbase/wallet-sdk)
+ *
+ * - [`@metamask/detect-provider`](https://www.npmjs.com/package/\@metamask/detect-provider)
+ *
+ * - [`@safe-global/safe-apps-provider`](https://github.com/safe-global/safe-apps-sdk/tree/main/packages/safe-apps-provider)
+ *
+ * - [`mipd`](https://github.com/wevm/mipd): EIP-6963 Multi Injected Providers
+ *
+ * :::
+ *
+ * @example
+ * ### Instantiating with an RPC Transport
+ *
+ * Ox's {@link ox#RpcTransport} is also EIP-1193 compliant, and can be used to instantiate an EIP-1193 Provider. This means you can use any HTTP RPC endpoint as an EIP-1193 Provider.
+ *
+ * ```ts twoslash
+ * import { Provider, RpcTransport } from 'ox'
+ *
+ * const transport = RpcTransport.fromHttp(
+ *   'https://1.rpc.thirdweb.com'
+ * )
+ * const provider = Provider.from(transport)
+ * ```
+ *
+ * @example
+ * ### Instantiating a Provider with Events
+ *
+ * Event emitters for EIP-1193 Providers can be created using {@link ox#Provider.(createEmitter:function)}:
+ *
+ * Useful for Wallets that distribute an EIP-1193 Provider (e.g. webpage injection via `window.ethereum`).
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Provider, RpcRequest, RpcResponse } from 'ox'
+ *
+ * // 1. Instantiate a Provider Emitter.
+ * const emitter = Provider.createEmitter() // [!code ++]
+ *
+ * const store = RpcRequest.createStore()
+ *
+ * const provider = Provider.from({
+ *   // 2. Pass the Emitter to the Provider.
+ *   ...emitter, // [!code ++]
+ *   async request(args) {
+ *     return await fetch('https://1.rpc.thirdweb.com', {
+ *       body: JSON.stringify(store.prepare(args)),
+ *       method: 'POST',
+ *       headers: {
+ *         'Content-Type': 'application/json'
+ *       }
+ *     })
+ *       .then((res) => res.json())
+ *       .then(RpcResponse.parse)
+ *   }
+ * })
+ *
+ * // 3. Emit Provider Events.
+ * emitter.emit('accountsChanged', ['0x...']) // [!code ++]
+ * ```
+ *
+ * @category Providers (EIP-1193)
+ */
+export * as Provider from './core/Provider.js';
+/**
+ * Utility functions for working with ECDSA public keys.
+ *
+ * @example
+ * ### Serializing Public Keys
+ *
+ * Public Keys can be serialized to Hex or Bytes using {@link ox#PublicKey.(toHex:function)}:
+ *
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.from({
+ *   prefix: 4,
+ *   x: '0x8318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed75',
+ *   y: '0x3547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5'
+ * })
+ *
+ * const serialized = PublicKey.toHex(publicKey) // [!code focus]
+ * // @log: '0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5'
+ * ```
+ *
+ * @example
+ * ### Deserializing Public Keys
+ *
+ * Public Keys can be deserialized from Hex or Bytes using {@link ox#PublicKey.(fromHex:function)}:
+ *
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.fromHex(
+ *   '0x8318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5'
+ * )
+ * // @log: {
+ * // @log:   prefix: 4,
+ * // @log:   x: '0x8318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed75',
+ * // @log:   y: '0x3547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5',
+ * // @log: }
+ * ```
+ *
+ * @category Crypto
+ */
+export * as PublicKey from './core/PublicKey.js';
+/**
+ * Utility functions for encoding and decoding [Recursive Length Prefix](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/) structures.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Hex, Rlp } from 'ox'
+ *
+ * const data = Rlp.fromHex([
+ *   Hex.fromString('hello'),
+ *   Hex.fromString('world')
+ * ])
+ * // @log: '0xcc8568656c6c6f85776f726c64'
+ *
+ * const values = Rlp.toHex(data)
+ * // @log: [Hex.fromString('hello'), Hex.fromString('world')]
+ * ```
+ *
+ * @category Data
+ */
+export * as Rlp from './core/Rlp.js';
+/**
+ * Utility types & functions for working with [JSON-RPC 2.0 Requests](https://www.jsonrpc.org/specification#request_object) and Ethereum JSON-RPC methods as
+ * defined on the [Ethereum API specification](https://github.com/ethereum/execution-apis)
+ *
+ * @example
+ * ### Instantiating a Request Store
+ *
+ * A Request Store can be instantiated using {@link ox#RpcRequest.(createStore:function)}:
+ *
+ * ```ts twoslash
+ * import { RpcRequest } from 'ox'
+ *
+ * const store = RpcRequest.createStore()
+ *
+ * const request_1 = store.prepare({
+ *   method: 'eth_blockNumber'
+ * })
+ * // @log: { id: 0, jsonrpc: '2.0', method: 'eth_blockNumber' }
+ *
+ * const request_2 = store.prepare({
+ *   method: 'eth_call',
+ *   params: [
+ *     {
+ *       to: '0x0000000000000000000000000000000000000000',
+ *       data: '0xdeadbeef'
+ *     }
+ *   ]
+ * })
+ * // @log: { id: 1, jsonrpc: '2.0', method: 'eth_call', params: [{ to: '0x0000000000000000000000000000000000000000', data: '0xdeadbeef' }] }
+ * ```
+ *
+ * @category JSON-RPC
+ */
+export * as RpcRequest from './core/RpcRequest.js';
+/**
+ * Utility types & functions for working with [JSON-RPC 2.0 Responses](https://www.jsonrpc.org/specification#response_object)
+ *
+ * @example
+ * ### Instantiating an RPC Response
+ *
+ * RPC Responses can be instantiated using {@link ox#RpcResponse.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { RpcResponse } from 'ox'
+ *
+ * const response = RpcResponse.from({
+ *   id: 0,
+ *   jsonrpc: '2.0',
+ *   result: '0x69420'
+ * })
+ * ```
+ *
+ * :::note
+ *
+ * Type-safe instantiation from a `request` object is also supported. If a `request` is provided, then the `id` and `jsonrpc` properties will be overridden with the values from the request.
+ *
+ * ```ts twoslash
+ * import { RpcRequest, RpcResponse } from 'ox'
+ *
+ * const request = RpcRequest.from({
+ *   id: 0,
+ *   method: 'eth_blockNumber'
+ * })
+ *
+ * const response = RpcResponse.from(
+ *   { result: '0x69420' },
+ *   { request }
+ * )
+ * ```
+ *
+ * :::
+ *
+ * @example
+ * ### Parsing an RPC Response
+ *
+ * RPC Responses can be parsed using {@link ox#RpcResponse.(parse:function)}:
+ *
+ * ```ts twoslash
+ * import { RpcRequest, RpcResponse } from 'ox'
+ *
+ * // 1. Create a request store.
+ * const store = RpcRequest.createStore()
+ *
+ * // 2. Get a request object.
+ * const request = store.prepare({
+ *   method: 'eth_getBlockByNumber',
+ *   params: ['0x1', false]
+ * })
+ *
+ * // 3. Send the JSON-RPC request via HTTP.
+ * const block = await fetch('https://1.rpc.thirdweb.com', {
+ *   body: JSON.stringify(request),
+ *   headers: {
+ *     'Content-Type': 'application/json'
+ *   },
+ *   method: 'POST'
+ * })
+ *   .then((response) => response.json())
+ *   // 4. Parse the JSON-RPC response into a type-safe result. // [!code focus]
+ *   .then((response) =>
+ *     RpcResponse.parse(response, { request })
+ *   ) // [!code focus]
+ *
+ * block // [!code focus]
+ * // ^?
+ * ```
+ *
+ * @category JSON-RPC
+ */
+export * as RpcResponse from './core/RpcResponse.js';
+/**
+ * Utility types for working with Ethereum JSON-RPC namespaces & schemas.
+ *
+ * @category JSON-RPC
+ */
+export * as RpcSchema from './core/RpcSchema.js';
+/**
+ * Utility functions for working with JSON-RPC Transports.
+ *
+ * :::note
+ * This is a convenience module distributed for experimenting with network connectivity on Ox.
+ *
+ * Consider using networking functionality from a higher-level library such as [Viem's Transports](https://viem.sh/docs/clients/transports/http)
+ * if you need more features such as: retry logic, WebSockets/IPC, middleware, batch JSON-RPC, etc.
+ * :::
+ *
+ * @example
+ * ### HTTP Instantiation
+ *
+ * ```ts twoslash
+ * import { RpcTransport } from 'ox'
+ *
+ * const transport = RpcTransport.fromHttp(
+ *   'https://1.rpc.thirdweb.com'
+ * )
+ *
+ * const blockNumber = await transport.request({
+ *   method: 'eth_blockNumber'
+ * })
+ * // @log: '0x1a2b3c'
+ * ```
+ *
+ * @category JSON-RPC
+ */
+export * as RpcTransport from './core/RpcTransport.js';
+/**
+ * Utility functions for [secp256k1](https://www.secg.org/sec2-v2.pdf) ECDSA cryptography.
+ *
+ * :::info
+ *
+ * The `Secp256k1` module is a friendly wrapper over [`@noble/curves/secp256k1`](https://github.com/paulmillr/noble-curves), an **audited** implementation of [secp256k1](https://www.secg.org/sec2-v2.pdf)
+ *
+ * :::
+ *
+ * @example
+ * ### Computing a Random Private Key
+ *
+ * A random private key can be computed using {@link ox#Secp256k1.(randomPrivateKey:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox'
+ *
+ * const privateKey = Secp256k1.randomPrivateKey()
+ * // @log: '0x...'
+ * ```
+ *
+ * @example
+ * ### Getting a Public Key
+ *
+ * A public key can be derived from a private key using {@link ox#Secp256k1.(getPublicKey:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox'
+ *
+ * const privateKey = Secp256k1.randomPrivateKey()
+ *
+ * const publicKey = Secp256k1.getPublicKey({ privateKey }) // [!code focus]
+ * // @log: { x: 3251...5152n, y: 1251...5152n }
+ * ```
+ *
+ * @example
+ * ### Signing a Payload
+ *
+ * A payload can be signed using {@link ox#Secp256k1.(sign:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox'
+ *
+ * const privateKey = Secp256k1.randomPrivateKey()
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: '0xdeadbeef',
+ *   privateKey
+ * }) // [!code focus]
+ * // @log: { r: 1251...5152n, s: 1251...5152n, yParity: 1 }
+ * ```
+ *
+ * @example
+ * ### Verifying a Signature
+ *
+ * A signature can be verified using {@link ox#Secp256k1.(verify:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox'
+ *
+ * const privateKey = Secp256k1.randomPrivateKey()
+ * const publicKey = Secp256k1.getPublicKey({ privateKey })
+ * const signature = Secp256k1.sign({
+ *   payload: '0xdeadbeef',
+ *   privateKey
+ * })
+ *
+ * const isValid = Secp256k1.verify({
+ *   // [!code focus]
+ *   payload: '0xdeadbeef', // [!code focus]
+ *   publicKey, // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ * // @log: true
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Secp256k1 from './core/Secp256k1.js';
+/**
+ * Utility functions for working with ECDSA signatures.
+ *
+ * @example
+ * ### Serializing a Signature
+ *
+ * Signatures can be serialized to Hex or Bytes using {@link ox#Signature.(toHex:function)}:
+ *
+ * ```ts twoslash
+ * import { Signature } from 'ox'
+ *
+ * const signature = Signature.toHex({
+ *   r: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf',
+ *   s: '0x4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db8',
+ *   yParity: 1
+ * })
+ * // @log: '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c'
+ * ```
+ *
+ * @example
+ * ### Deserializing a Signature
+ *
+ * Signatures can be deserialized from Hex or Bytes using {@link ox#Signature.(fromHex:function)}:
+ *
+ * ```ts twoslash
+ * import { Signature } from 'ox'
+ *
+ * Signature.fromHex(
+ *   '0x6e100a352ec6ad1b70802290e18aeed190704973570f3b8ed42cb9808e2ea6bf4a90a229a244495b41890987806fcbd2d5d23fc0dbe5f5256c2613c039d76db81c'
+ * )
+ * // @log: { r: 5231...n, s: 3522...n, yParity: 0 }
+ * ```
+ *
+ * @category Crypto
+ */
+export * as Signature from './core/Signature.js';
+/**
+ * Utility functions for working with
+ * [EIP-4361: Sign-In with Ethereum](https://eips.ethereum.org/EIPS/eip-4361)
+ *
+ * @example
+ * ### Creating a SIWE Message
+ *
+ * SIWE messages can be created using {@link ox#Siwe.(createMessage:function)}:
+ *
+ * ```ts twoslash
+ * import { Siwe } from 'ox'
+ *
+ * Siwe.createMessage({
+ *   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   chainId: 1n,
+ *   domain: 'example.com',
+ *   nonce: 'foobarbaz',
+ *   uri: 'https://example.com/path',
+ *   version: '1'
+ * })
+ * // @log: "example.com wants you to sign in with your Ethereum account:
+ * // @log: 0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+ * // @log:
+ * // @log:
+ * // @log: URI: https://example.com/path
+ * // @log: Version: 1
+ * // @log: Chain ID: 1
+ * // @log: Nonce: foobarbaz
+ * // @log: Issued At: 2023-02-01T00:00:00.000Z"
+ * ```
+ *
+ * @example
+ * ### Generating SIWE Nonces
+ *
+ * SIWE nonces can be generated using {@link ox#Siwe.(generateNonce:function)}:
+ *
+ * ```ts twoslash
+ * import { Siwe } from 'ox'
+ *
+ * Siwe.generateNonce()
+ * // @log: '65ed4681d4efe0270b923ff5f4b097b1c95974dc33aeebecd5724c42fd86dfd25dc70b27ef836b2aa22e68f19ebcccc1'
+ * ```
+ *
+ * @example
+ * ### Parsing a SIWE Message
+ *
+ * SIWE messages can be parsed using {@link ox#Siwe.(parseMessage:function)}:
+ *
+ * ```ts twoslash
+ * import { Siwe } from 'ox'
+ *
+ * Siwe.parseMessage(`example.com wants you to sign in with your Ethereum account:
+ * 0xA0Cf798816D4b9b9866b5330EEa46a18382f251e
+ *
+ * I accept the ExampleOrg Terms of Service: https://example.com/tos
+ *
+ * URI: https://example.com/path
+ * Version: 1
+ * Chain ID: 1
+ * Nonce: foobarbaz
+ * Issued At: 2023-02-01T00:00:00.000Z`)
+ * // @log: {
+ * // @log:   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * // @log:   chainId: 1,
+ * // @log:   domain: 'example.com',
+ * // @log:   issuedAt: '2023-02-01T00:00:00.000Z',
+ * // @log:   nonce: 'foobarbaz',
+ * // @log:   statement: 'I accept the ExampleOrg Terms of Service: https://example.com/tos',
+ * // @log:   uri: 'https://example.com/path',
+ * // @log:   version: '1',
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### Validating a SIWE Message
+ *
+ * SIWE messages can be validated using {@link ox#Siwe.(validateMessage:function)}:
+ *
+ * ```ts twoslash
+ * import { Siwe } from 'ox'
+ *
+ * Siwe.validateMessage({
+ *   address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   domain: 'example.com',
+ *   message: {
+ *     address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *     chainId: 1n,
+ *     domain: 'example.com',
+ *     nonce: 'foobarbaz',
+ *     uri: 'https://example.com/path',
+ *     version: '1'
+ *   },
+ *   nonce: 'foobarbaz'
+ * })
+ * // @log: true
+ * ```
+ *
+ * @category Sign-In with Ethereum (EIP-4361)
+ */
+export * as Siwe from './core/Siwe.js';
+export * as Solidity from './core/Solidity.js';
+/**
+ * Utilities & types for working with **State Overrides**.
+ *
+ * @category Execution Spec
+ */
+export * as StateOverrides from './core/StateOverrides.js';
+/**
+ * Utilities & types for working with **Transactions** as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/transaction.yaml)
+ *
+ * @example
+ * ### Converting from RPC Format
+ *
+ * Transactions can be converted from RPC format using {@link ox#Transaction.(fromRpc:function)}:
+ *
+ * ```ts twoslash
+ * import { Transaction } from 'ox'
+ *
+ * const transaction = Transaction.fromRpc({
+ *   hash: '0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0',
+ *   nonce: '0x357',
+ *   blockHash:
+ *     '0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b',
+ *   blockNumber: '0x12f296f',
+ *   transactionIndex: '0x2',
+ *   from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+ *   to: '0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad',
+ *   value: '0x9b6e64a8ec60000',
+ *   gas: '0x43f5d',
+ *   maxFeePerGas: '0x2ca6ae494',
+ *   maxPriorityFeePerGas: '0x41cc3c0',
+ *   input:
+ *     '0x3593564c000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000006643504700000000000000000000000000000000000000000000000000000000000000040b080604000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002800000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000009b6e64a8ec600000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000009b6e64a8ec60000000000000000000000000000000000000000000000000000019124bb5ae978c000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000c56c7a0eaa804f854b536a5f3d5f49d2ec4b12b80000000000000000000000000000000000000000000000000000000000000060000000000000000000000000c56c7a0eaa804f854b536a5f3d5f49d2ec4b12b8000000000000000000000000000000fee13a103a10d593b9ae06b3e05f2e7e1c00000000000000000000000000000000000000000000000000000000000000190000000000000000000000000000000000000000000000000000000000000060000000000000000000000000c56c7a0eaa804f854b536a5f3d5f49d2ec4b12b800000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000190240001b9872b',
+ *   r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+ *   s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+ *   yParity: '0x0',
+ *   chainId: '0x1',
+ *   accessList: [],
+ *   type: '0x2'
+ * })
+ * ```
+ *
+ * @category Execution Spec
+ */
+export * as Transaction from './core/Transaction.js';
+/**
+ * Utilities & types for working with **Transaction Receipts** as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/receipt.yaml)
+ *
+ * @example
+ * ### Converting from RPC Format
+ *
+ * Receipts can be converted from RPC format using {@link ox#TransactionReceipt.(fromRpc:function)}:
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { TransactionReceipt } from 'ox'
+ *
+ * const receipt = await window
+ *   .ethereum!.request({
+ *     method: 'eth_getTransactionReceipt',
+ *     params: [
+ *       '0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0'
+ *     ]
+ *   })
+ *   .then(TransactionReceipt.fromRpc) // [!code hl]
+ * // @log: {
+ * // @log:   blobGasPrice: 270441n,
+ * // @log:   blobGasUsed: 4919n,
+ * // @log:   blockHash: "0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b",
+ * // @log:   blockNumber: 19868015n,
+ * // @log:   contractAddress: null,
+ * // @log:   cumulativeGasUsed: 533781n,
+ * // @log:   effectiveGasPrice: 9062804489n,
+ * // @log:   from: "0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6",
+ * // @log:   gasUsed: 175034n,
+ * // @log:   logs: [],
+ * // @log:   logsBloom: "0x00200000000000000000008080000000000000000040000000000000000000000000000000000000000000000000000022000000080000000000000000000000000000080000000000000008000000200000000000000000000200008020400000000000000000280000000000100000000000000000000000000010000000000000000000020000000000000020000000000001000000080000004000000000000000000000000000000000000000000000400000000000001000000000000000000002000000000000000020000000000000000000001000000000000000000000200000000000000000000000000000001000000000c00000000000000000",
+ * // @log:   root: undefined,
+ * // @log:   status: "success",
+ * // @log:   to: "0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad",
+ * // @log:   transactionHash: "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
+ * // @log:   transactionIndex: 2,
+ * // @log:   type: "eip1559",
+ * // @log: }
+ * ```
+ *
+ * @category Execution Spec
+ */
+export * as TransactionReceipt from './core/TransactionReceipt.js';
+/**
+ * Utilities & types for working with **Transaction Requests** as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/4aca1d7a3e5aab24c8f6437131289ad386944eaa/src/schemas/transaction.yaml#L358-L423)
+ *
+ * @example
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { Provider, TransactionRequest, Value } from 'ox'
+ *
+ * const provider = Provider.from(window.ethereum!)
+ *
+ * const request = TransactionRequest.toRpc({
+ *   // [!code focus]
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8', // [!code focus]
+ *   value: Value.fromEther('0.01') // [!code focus]
+ * }) // [!code focus]
+ *
+ * const hash = await provider.request({
+ *   method: 'eth_sendTransaction',
+ *   params: [request]
+ * })
+ * ```
+ *
+ * @category Execution Spec
+ */
+export * as TransactionRequest from './core/TransactionRequest.js';
+/**
+ * Errors & Types for working with Transaction Envelopes.
+ *
+ * :::note
+ * Refer to the following modules for specific Transaction Envelope types:
+ * - [`TxEnvelopeLegacy`](/api/TxEnvelopeLegacy)
+ * - [`TxEnvelopeEip1559`](/api/TxEnvelopeEip1559)
+ * - [`TxEnvelopeEip2930`](/api/TxEnvelopeEip2930)
+ * - [`TxEnvelopeEip4844`](/api/TxEnvelopeEip4844)
+ * - [`TxEnvelopeEip7702`](/api/TxEnvelopeEip7702)
+ * :::
+ *
+ * @category Transaction Envelopes
+ */
+export * as TransactionEnvelope from './core/TxEnvelope.js';
+/**
+ * Utility functions for working with [EIP-1559 Typed Transaction Envelopes](https://eips.ethereum.org/EIPS/eip-1559)
+ *
+ *  @example
+ * ### Instantiating
+ *
+ * Transaction Envelopes can be instantiated using {@link ox#TxEnvelopeEip1559.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { TxEnvelopeEip1559, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip1559.from({
+ *   chainId: 1,
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1')
+ * })
+ * // @log: {
+ * // @log:   chainId: 1,
+ * // @log:   maxFeePerGas: 10000000000n,
+ * // @log:   maxPriorityFeePerGas: 1000000000n,
+ * // @log:   to: '0x0000000000000000000000000000000000000000',
+ * // @log:   type: 'eip1559',
+ * // @log:   value: 1000000000000000000n,
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### Signing
+ *
+ * Transaction Envelopes can be signed using {@link ox#TxEnvelopeEip1559.(getSignPayload:function)} and a signing function such as {@link ox#Secp256k1.(sign:function)} or {@link ox#P256.(sign:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1, TxEnvelopeEip1559 } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip1559.from({
+ *   chainId: 1,
+ *   nonce: 0n,
+ *   gasPrice: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   // [!code focus]
+ *   payload: TxEnvelopeEip1559.getSignPayload(envelope), // [!code focus]
+ *   privateKey: '0x...' // [!code focus]
+ * }) // [!code focus]
+ *
+ * const envelope_signed = TxEnvelopeEip1559.from(envelope, {
+ *   signature
+ * })
+ * ```
+ *
+ * @example
+ * ### Serializing
+ *
+ * Transaction Envelopes can be serialized using {@link ox#TxEnvelopeEip1559.(serialize:function)}:
+ *
+ * ```ts twoslash
+ * import { TxEnvelopeEip1559, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip1559.from({
+ *   chainId: 1,
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1')
+ * })
+ *
+ * const serialized = TxEnvelopeEip1559.serialize(envelope) // [!code focus]
+ * ```
+ *
+ * @example
+ * ### Sending
+ *
+ * We can send a Transaction Envelope to the network by serializing the signed envelope with `.serialize`, and then broadcasting it over JSON-RPC with `eth_sendRawTransaction`.
+ *
+ * In this example, we will use {@link ox#RpcTransport.(fromHttp:function)} to broadcast a `eth_sendRawTransaction` request over HTTP JSON-RPC.
+ *
+ * ```ts twoslash
+ * import {
+ *   RpcTransport,
+ *   TxEnvelopeEip1559,
+ *   Secp256k1,
+ *   Value
+ * } from 'ox'
+ *
+ * // Construct the Envelope.
+ * const envelope = TxEnvelopeEip1559.from({
+ *   chainId: 1,
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   nonce: 69n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1.5')
+ * })
+ *
+ * // Sign over the Envelope.
+ * const signature = Secp256k1.sign({
+ *   payload: TxEnvelopeEip1559.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * // Serialize the Envelope with the Signature. // [!code focus]
+ * const serialized = TxEnvelopeEip1559.serialize(envelope, {
+ *   // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ *
+ * // Broadcast the Envelope with `eth_sendRawTransaction`. // [!code focus]
+ * const transport = RpcTransport.fromHttp(
+ *   'https://1.rpc.thirdweb.com'
+ * ) // [!code focus]
+ * const hash = await transport.request({
+ *   // [!code focus]
+ *   method: 'eth_sendRawTransaction', // [!code focus]
+ *   params: [serialized] // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * If you are interfacing with an RPC that supports `eth_sendTransaction`, you can also use
+ * {@link ox#TxEnvelopeEip1559.(toRpc:function)} to convert an Envelope to an RPC-compatible format.
+ * This means you can skip the ceremony of manually filling & signing the Transaction.
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { Provider, TxEnvelopeEip1559, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip1559.from({
+ *   chainId: 1,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1.5')
+ * })
+ *
+ * const envelope_rpc = TxEnvelopeEip1559.toRpc(envelope)
+ *
+ * const provider = Provider.from(window.ethereum)
+ * const hash = await provider.request({
+ *   method: 'eth_sendTransaction',
+ *   params: [envelope_rpc]
+ * })
+ * ```
+ *
+ * @example
+ * ### Computing Hashes
+ *
+ * Transaction Hashes can be computed using {@link ox#TxEnvelopeEip1559.(hash:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1, TxEnvelopeEip1559, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip1559.from({
+ *   chainId: 1,
+ *   nonce: 0n,
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ *   data: '0x'
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TxEnvelopeEip1559.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const envelope_signed = TxEnvelopeEip1559.from(envelope, {
+ *   signature
+ * })
+ *
+ * const hash = TxEnvelopeEip1559.hash(envelope_signed) // [!code focus]
+ * ```
+ *
+ * @category Transaction Envelopes
+ */
+export * as TxEnvelopeEip1559 from './core/TxEnvelopeEip1559.js';
+/**
+ * Utility functions for working with [EIP-2930 Typed Transaction Envelopes](https://eips.ethereum.org/EIPS/eip-2930)
+ *
+ * @example
+ * ### Instantiating
+ *
+ * Transaction Envelopes can be instantiated using {@link ox#TxEnvelopeEip2930.(from:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { TxEnvelopeEip2930, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip2930.from({
+ *   chainId: 1,
+ *   accessList: [...],
+ *   gasPrice: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1'),
+ * })
+ * ```
+ *
+ * @example
+ * ### Signing
+ *
+ * Transaction Envelopes can be signed using {@link ox#TxEnvelopeEip2930.(getSignPayload:function)} and a signing function such as {@link ox#Secp256k1.(sign:function)} or {@link ox#P256.(sign:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1, TxEnvelopeEip2930 } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip2930.from({
+ *   chainId: 1,
+ *   nonce: 0n,
+ *   gasPrice: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n
+ * })
+ *
+ * const payload = TxEnvelopeEip2930.getSignPayload(envelope) // [!code focus]
+ * // @log: '0x...'
+ *
+ * const signature = Secp256k1.sign({
+ *   payload,
+ *   privateKey: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * ### Serializing
+ *
+ * Transaction Envelopes can be serialized using {@link ox#TxEnvelopeEip2930.(serialize:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1, TxEnvelopeEip2930, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip2930.from({
+ *   chainId: 1,
+ *   nonce: 0n,
+ *   gasPrice: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n
+ * })
+ *
+ * const serialized = TxEnvelopeEip2930.serialize(envelope) // [!code focus]
+ * ```
+ *
+ * @example
+ * ### Sending
+ *
+ * We can send a Transaction Envelope to the network by serializing the signed envelope with `.serialize`, and then broadcasting it over JSON-RPC with `eth_sendRawTransaction`.
+ *
+ * In this example, we will use {@link ox#RpcTransport.(fromHttp:function)} to broadcast a `eth_sendRawTransaction` request over HTTP JSON-RPC.
+ *
+ * ```ts twoslash
+ * import {
+ *   RpcTransport,
+ *   TxEnvelopeEip2930,
+ *   Secp256k1,
+ *   Value
+ * } from 'ox'
+ *
+ * // Construct the Envelope.
+ * const envelope = TxEnvelopeEip2930.from({
+ *   accessList: [],
+ *   chainId: 1,
+ *   gasPrice: Value.fromGwei('10'),
+ *   nonce: 69n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1.5')
+ * })
+ *
+ * // Sign over the Envelope.
+ * const signature = Secp256k1.sign({
+ *   payload: TxEnvelopeEip2930.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * // Serialize the Envelope with the Signature. // [!code focus]
+ * const serialized = TxEnvelopeEip2930.serialize(envelope, {
+ *   // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ *
+ * // Broadcast the Envelope with `eth_sendRawTransaction`. // [!code focus]
+ * const transport = RpcTransport.fromHttp(
+ *   'https://1.rpc.thirdweb.com'
+ * ) // [!code focus]
+ * const hash = await transport.request({
+ *   // [!code focus]
+ *   method: 'eth_sendRawTransaction', // [!code focus]
+ *   params: [serialized] // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * If you are interfacing with an RPC that supports `eth_sendTransaction`, you can also use
+ * {@link ox#TxEnvelopeEip2930.(toRpc:function)} to convert an Envelope to an RPC-compatible format.
+ * This means you can skip the ceremony of manually filling & signing the Transaction.
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { Provider, TxEnvelopeEip2930, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip2930.from({
+ *   accessList: [],
+ *   chainId: 1,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1.5')
+ * })
+ *
+ * const envelope_rpc = TxEnvelopeEip2930.toRpc(envelope)
+ *
+ * const provider = Provider.from(window.ethereum)
+ * const hash = await provider.request({
+ *   method: 'eth_sendTransaction',
+ *   params: [envelope_rpc]
+ * })
+ * ```
+ *
+ * @example
+ * ### Computing Hashes
+ *
+ * Transaction Hashes can be computed using {@link ox#TxEnvelopeEip2930.(hash:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1, TxEnvelopeEip2930 } from 'ox'
+ *
+ * const envelope = TxEnvelopeEip2930.from({
+ *   chainId: 1,
+ *   nonce: 0n,
+ *   gasPrice: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ *   data: '0x'
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TxEnvelopeEip2930.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const envelope_signed = TxEnvelopeEip2930.from(envelope, {
+ *   signature
+ * })
+ *
+ * const hash = TxEnvelopeEip2930.hash(envelope_signed) // [!code focus]
+ * ```
+ *
+ * @category Transaction Envelopes
+ */
+export * as TxEnvelopeEip2930 from './core/TxEnvelopeEip2930.js';
+/**
+ * Utility functions for working with [EIP-4844 Typed Transaction Envelopes](https://eips.ethereum.org/EIPS/eip-4844)
+ *
+ * @example
+ * ### Instantiating Blobs
+ *
+ * Blobs can be instantiated using {@link ox#Blobs.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { Blobs, Hex } from 'ox'
+ *
+ * const blobs = Blobs.from(Hex.fromString('Hello World!'))
+ * ```
+ *
+ * @example
+ * ### Instantiating
+ *
+ * Transaction Envelopes can be instantiated using {@link ox#TxEnvelopeEip4844.(from:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Blobs, Hex, TxEnvelopeEip4844, Value } from 'ox'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = Blobs.from(Hex.fromString('Hello World!'))
+ * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, {
+ *   kzg
+ * })
+ *
+ * const envelope = TxEnvelopeEip4844.from({
+ *   chainId: 1,
+ *   blobVersionedHashes,
+ *   maxFeePerBlobGas: Value.fromGwei('3'),
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1')
+ * })
+ * ```
+ *
+ * @example
+ * ### Signing
+ *
+ * Transaction Envelopes can be signed using {@link ox#TxEnvelopeEip4844.(getSignPayload:function)} and a signing function such as {@link ox#Secp256k1.(sign:function)} or {@link ox#P256.(sign:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Blobs, Secp256k1, TxEnvelopeEip4844 } from 'ox'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = Blobs.from('0xdeadbeef')
+ * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, {
+ *   kzg
+ * })
+ *
+ * const envelope = TxEnvelopeEip4844.from({
+ *   blobVersionedHashes,
+ *   chainId: 1,
+ *   nonce: 0n,
+ *   maxFeePerBlobGas: Value.fromGwei('3'),
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1')
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   // [!code focus]
+ *   payload: TxEnvelopeEip4844.getSignPayload(envelope), // [!code focus]
+ *   privateKey: '0x...' // [!code focus]
+ * }) // [!code focus]
+ *
+ * const envelope_signed = TxEnvelopeEip4844.from(envelope, {
+ *   signature
+ * })
+ * ```
+ *
+ * @example
+ * ### Serializing
+ *
+ * Transaction Envelopes can be serialized using {@link ox#TxEnvelopeEip4844.(serialize:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Blobs, TxEnvelopeEip4844 } from 'ox'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = Blobs.from('0xdeadbeef')
+ * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, {
+ *   kzg
+ * })
+ *
+ * const envelope = TxEnvelopeEip4844.from({
+ *   blobVersionedHashes,
+ *   chainId: 1,
+ *   maxFeePerBlobGas: Value.fromGwei('3'),
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1')
+ * })
+ *
+ * const serialized = TxEnvelopeEip4844.serialize(envelope) // [!code focus]
+ * ```
+ *
+ * @example
+ * ### Sending
+ *
+ * We can send a Transaction Envelope to the network by serializing the signed envelope with `.serialize`, and then broadcasting it over JSON-RPC with `eth_sendRawTransaction`.
+ *
+ * In this example, we will use {@link ox#RpcTransport.(fromHttp:function)} to broadcast a `eth_sendRawTransaction` request over HTTP JSON-RPC.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import {
+ *   Blobs,
+ *   RpcTransport,
+ *   TxEnvelopeEip4844,
+ *   Secp256k1,
+ *   Value
+ * } from 'ox'
+ * import { kzg } from './kzg'
+ *
+ * // Compute the Blob Versioned Hashes.
+ * const blobs = Blobs.from('0xdeadbeef')
+ * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, {
+ *   kzg
+ * })
+ *
+ * // Construct the Envelope.
+ * const envelope = TxEnvelopeEip4844.from({
+ *   chainId: 1,
+ *   blobVersionedHashes,
+ *   maxFeePerBlobGas: Value.fromGwei('3'),
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   nonce: 0n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1.5')
+ * })
+ *
+ * // Sign over the Envelope.
+ * const signature = Secp256k1.sign({
+ *   payload: TxEnvelopeEip4844.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * // Serialize the Envelope with the Signature. // [!code focus]
+ * const serialized = TxEnvelopeEip4844.serialize(envelope, {
+ *   // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ *
+ * // Broadcast the Envelope with `eth_sendRawTransaction`. // [!code focus]
+ * const transport = RpcTransport.fromHttp(
+ *   'https://1.rpc.thirdweb.com'
+ * ) // [!code focus]
+ * const hash = await transport.request({
+ *   // [!code focus]
+ *   method: 'eth_sendRawTransaction', // [!code focus]
+ *   params: [serialized] // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @example
+ * ### Computing Hashes
+ *
+ * Transaction Hashes can be computed using {@link ox#TxEnvelopeEip4844.(hash:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import {
+ *   Blobs,
+ *   Secp256k1,
+ *   TxEnvelopeEip4844,
+ *   Value
+ * } from 'ox'
+ * import { kzg } from './kzg'
+ *
+ * const blobs = Blobs.from('0xdeadbeef')
+ * const blobVersionedHashes = Blobs.toVersionedHashes(blobs, {
+ *   kzg
+ * })
+ *
+ * const envelope = TxEnvelopeEip4844.from({
+ *   blobVersionedHashes,
+ *   chainId: 1,
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1')
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TxEnvelopeEip4844.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const envelope_signed = TxEnvelopeEip4844.from(envelope, {
+ *   signature
+ * })
+ *
+ * const hash = TxEnvelopeEip4844.hash(envelope_signed) // [!code focus]
+ * ```
+ *
+ * @category Transaction Envelopes
+ */
+export * as TxEnvelopeEip4844 from './core/TxEnvelopeEip4844.js';
+/**
+ * Utility functions for working with [EIP-7702 Typed Transaction Envelopes](https://eips.ethereum.org/EIPS/eip-7702)
+ *
+ * @example
+ * ### Instantiating
+ *
+ * Transaction Envelopes can be instantiated using {@link ox#TxEnvelopeEip7702.(from:function)}:
+ *
+ * ```ts twoslash
+ * import {
+ *   Authorization,
+ *   Secp256k1,
+ *   TxEnvelopeEip7702,
+ *   Value
+ * } from 'ox'
+ *
+ * const authorization = Authorization.from({
+ *   address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   chainId: 1,
+ *   nonce: 0n
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: Authorization.getSignPayload(authorization),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const authorizationList = [
+ *   Authorization.from(authorization, { signature })
+ * ]
+ *
+ * const envelope = TxEnvelopeEip7702.from({
+ *   // [!code focus]
+ *   authorizationList, // [!code focus]
+ *   chainId: 1, // [!code focus]
+ *   maxFeePerGas: Value.fromGwei('10'), // [!code focus]
+ *   maxPriorityFeePerGas: Value.fromGwei('1'), // [!code focus]
+ *   to: '0x0000000000000000000000000000000000000000', // [!code focus]
+ *   value: Value.fromEther('1') // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * :::tip
+ *
+ * See {@link ox#Authorization} for more details on instantiating and signing EIP-7702 Authorizations.
+ *
+ * :::
+ *
+ * @example
+ * ### Signing
+ *
+ * Transaction Envelopes can be signed using {@link ox#TxEnvelopeEip7702.(getSignPayload:function)} and a signing function such as {@link ox#Secp256k1.(sign:function)} or {@link ox#P256.(sign:function)}:
+ *
+ * ```ts twoslash
+ * import {
+ *   Authorization,
+ *   Secp256k1,
+ *   TxEnvelopeEip7702,
+ *   Value
+ * } from 'ox'
+ *
+ * const authorization = Authorization.from({
+ *   address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   chainId: 1,
+ *   nonce: 0n
+ * })
+ *
+ * const signature_auth = Secp256k1.sign({
+ *   payload: Authorization.getSignPayload(authorization),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const authorizationList = [
+ *   Authorization.from(authorization, {
+ *     signature: signature_auth
+ *   })
+ * ]
+ *
+ * const envelope = TxEnvelopeEip7702.from({
+ *   authorizationList,
+ *   chainId: 1,
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1')
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   // [!code focus]
+ *   payload: TxEnvelopeEip7702.getSignPayload(envelope), // [!code focus]
+ *   privateKey: '0x...' // [!code focus]
+ * })
+ *
+ * const envelope_signed = TxEnvelopeEip7702.from(envelope, {
+ *   signature
+ * })
+ * ```
+ *
+ * @example
+ * ### Sending
+ *
+ * We can send a Transaction Envelope to the network by serializing the signed envelope with `.serialize`, and then broadcasting it over JSON-RPC with `eth_sendRawTransaction`.
+ *
+ * In this example, we will use {@link ox#RpcTransport.(fromHttp:function)} to broadcast a `eth_sendRawTransaction` request over HTTP JSON-RPC.
+ *
+ * ```ts twoslash
+ * import {
+ *   Authorization,
+ *   RpcTransport,
+ *   TxEnvelopeEip7702,
+ *   Secp256k1,
+ *   Value
+ * } from 'ox'
+ *
+ * const authorization = Authorization.from({
+ *   address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   chainId: 1,
+ *   nonce: 0n
+ * })
+ *
+ * const signature_auth = Secp256k1.sign({
+ *   payload: Authorization.getSignPayload(authorization),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const authorizationList = [
+ *   Authorization.from(authorization, {
+ *     signature: signature_auth
+ *   })
+ * ]
+ *
+ * const envelope = TxEnvelopeEip7702.from({
+ *   authorizationList,
+ *   chainId: 1,
+ *   maxFeePerGas: Value.fromGwei('10'),
+ *   maxPriorityFeePerGas: Value.fromGwei('1'),
+ *   nonce: 69n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1.5')
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TxEnvelopeEip7702.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * // Serialize the Envelope with the Signature. // [!code focus]
+ * const serialized = TxEnvelopeEip7702.serialize(envelope, {
+ *   // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ *
+ * // Broadcast the Envelope with `eth_sendRawTransaction`. // [!code focus]
+ * const transport = RpcTransport.fromHttp(
+ *   'https://1.rpc.thirdweb.com'
+ * ) // [!code focus]
+ * const hash = await transport.request({
+ *   // [!code focus]
+ *   method: 'eth_sendRawTransaction', // [!code focus]
+ *   params: [serialized] // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @category Transaction Envelopes
+ */
+export * as TxEnvelopeEip7702 from './core/TxEnvelopeEip7702.js';
+/**
+ * Utility functions for working
+ * with **Legacy Transaction Envelopes**.
+ *
+ * @example
+ * ### Instantiating
+ *
+ * Transaction Envelopes can be instantiated using {@link ox#TxEnvelopeLegacy.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { TxEnvelopeLegacy, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeLegacy.from({
+ *   gasPrice: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1')
+ * })
+ * ```
+ *
+ * * @example
+ * ### Signing
+ *
+ * Transaction Envelopes can be signed using {@link ox#TxEnvelopeLegacy.(getSignPayload:function)} and a signing function such as {@link ox#Secp256k1.(sign:function)} or {@link ox#P256.(sign:function)}:
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { Secp256k1, TxEnvelopeLegacy } from 'ox'
+ *
+ * const envelope = TxEnvelopeLegacy.from({
+ *   nonce: 0n,
+ *   gasPrice: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   // [!code focus]
+ *   payload: TxEnvelopeLegacy.getSignPayload(envelope), // [!code focus]
+ *   privateKey: '0x...' // [!code focus]
+ * }) // [!code focus]
+ *
+ * const envelope_signed = TxEnvelopeLegacy.from(envelope, {
+ *   signature
+ * })
+ * ```
+ *
+ * @example
+ * ### Serializing
+ *
+ * Transaction Envelopes can be serialized using {@link ox#TxEnvelopeLegacy.(serialize:function)}:
+ *
+ * ```ts twoslash
+ * import { TxEnvelopeLegacy, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeLegacy.from({
+ *   chainId: 1,
+ *   gasPrice: Value.fromGwei('10'),
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: Value.fromEther('1')
+ * })
+ *
+ * const serialized = TxEnvelopeLegacy.serialize(envelope) // [!code focus]
+ * ```
+ *
+ * @example
+ * ### Sending
+ *
+ * We can send a Transaction Envelope to the network by serializing the signed envelope with `.serialize`, and then broadcasting it over JSON-RPC with `eth_sendRawTransaction`.
+ *
+ * In this example, we will use {@link ox#RpcTransport.(fromHttp:function)} to broadcast a `eth_sendRawTransaction` request over HTTP JSON-RPC.
+ *
+ * ```ts twoslash
+ * import {
+ *   RpcTransport,
+ *   TxEnvelopeLegacy,
+ *   Secp256k1,
+ *   Value
+ * } from 'ox'
+ *
+ * // Construct the Envelope.
+ * const envelope = TxEnvelopeLegacy.from({
+ *   chainId: 1,
+ *   gasPrice: Value.fromGwei('10'),
+ *   nonce: 69n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1.5')
+ * })
+ *
+ * // Sign over the Envelope.
+ * const signature = Secp256k1.sign({
+ *   payload: TxEnvelopeLegacy.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * // Serialize the Envelope with the Signature. // [!code focus]
+ * const serialized = TxEnvelopeLegacy.serialize(envelope, {
+ *   // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ *
+ * // Broadcast the Envelope with `eth_sendRawTransaction`. // [!code focus]
+ * const transport = RpcTransport.fromHttp(
+ *   'https://1.rpc.thirdweb.com'
+ * ) // [!code focus]
+ * const hash = await transport.request({
+ *   // [!code focus]
+ *   method: 'eth_sendRawTransaction', // [!code focus]
+ *   params: [serialized] // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * If you are interfacing with an RPC that supports `eth_sendTransaction`, you can also use
+ * {@link ox#TxEnvelopeLegacy.(toRpc:function)} to convert an Envelope to an RPC-compatible format.
+ * This means you can skip the ceremony of manually filling & signing the Transaction.
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { Provider, TxEnvelopeLegacy, Value } from 'ox'
+ *
+ * const envelope = TxEnvelopeLegacy.from({
+ *   chainId: 1,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: Value.fromEther('1.5')
+ * })
+ *
+ * const envelope_rpc = TxEnvelopeLegacy.toRpc(envelope)
+ *
+ * const provider = Provider.from(window.ethereum)
+ * const hash = await provider.request({
+ *   method: 'eth_sendTransaction',
+ *   params: [envelope_rpc]
+ * })
+ * ```
+ *
+ * @example
+ * ### Computing Hashes
+ *
+ * Transaction Hashes can be computed using {@link ox#TxEnvelopeLegacy.(hash:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1, TxEnvelopeLegacy } from 'ox'
+ *
+ * const envelope = TxEnvelopeLegacy.from({
+ *   chainId: 1,
+ *   nonce: 0n,
+ *   gasPrice: 1000000000n,
+ *   gas: 21000n,
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ *   data: '0x'
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: TxEnvelopeLegacy.getSignPayload(envelope),
+ *   privateKey: '0x...'
+ * })
+ *
+ * const envelope_signed = TxEnvelopeLegacy.from(envelope, {
+ *   signature
+ * })
+ *
+ * const hash = TxEnvelopeLegacy.hash(envelope_signed) // [!code focus]
+ * ```
+ *
+ * @category Transaction Envelopes
+ */
+export * as TxEnvelopeLegacy from './core/TxEnvelopeLegacy.js';
+/**
+ * Utility functions for working with [EIP-712 Typed Data](https://eips.ethereum.org/EIPS/eip-712)
+ *
+ * @example
+ * ### Getting Sign Payloads
+ *
+ * Typed Data can be converted to a sign payload using {@link ox#TypedData.(getSignPayload:function)}:
+ *
+ * ```ts twoslash
+ * import { Secp256k1, TypedData, Hash } from 'ox'
+ *
+ * const payload = TypedData.getSignPayload({
+ *   // [!code focus:99]
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract:
+ *       '0x0000000000000000000000000000000000000000'
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' }
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' }
+ *     ]
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826'
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB'
+ *     },
+ *     contents: 'Hello, Bob!'
+ *   }
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload,
+ *   privateKey: '0x...'
+ * })
+ * ```
+ *
+ * @category Signed & Typed Data
+ */
+export * as TypedData from './core/TypedData.js';
+/**
+ * Utilities & types for working with [EIP-191 Validator Data](https://eips.ethereum.org/EIPS/eip-191#0x00)
+ *
+ * @category Signed & Typed Data
+ */
+export * as ValidatorData from './core/ValidatorData.js';
+/**
+ * Utility functions for displaying and parsing Ethereum Values as defined under **2.1. Value** in the [Ethereum Yellow Paper](https://ethereum.github.io/yellowpaper/paper.pdf)
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { Value } from 'ox'
+ *
+ * const value = Value.fromEther('1')
+ * // @log: 1_000_000_000_000_000_000n
+ *
+ * const formattedValue = Value.formatEther(value)
+ * // @log: '1'
+ *
+ * const value = Value.fromEther('1', 'szabo')
+ * // @log: 1_000_000n
+ * ```
+ *
+ * @category Data
+ */
+export * as Value from './core/Value.js';
+/**
+ * Utility functions for [NIST P256](https://csrc.nist.gov/csrc/media/events/workshop-on-elliptic-curve-cryptography-standards/documents/papers/session6-adalier-mehmet.pdf) ECDSA cryptography using the [Web Authentication API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API)
+ *
+ * @example
+ * ### Creating Credentials
+ *
+ * Credentials can be created using {@link ox#WebAuthnP256.(createCredential:function)}:
+ *
+ * ```ts twoslash
+ * import { WebAuthnP256 } from 'ox'
+ *
+ * const credential = await WebAuthnP256.createCredential({
+ *   name: 'Example'
+ * }) // [!code focus]
+ * // @log: {
+ * // @log:   id: 'oZ48...',
+ * // @log:   publicKey: { x: 51421...5123n, y: 12345...6789n },
+ * // @log:   raw: PublicKeyCredential {},
+ * // @log: }
+ *
+ * const { metadata, signature } = await WebAuthnP256.sign({
+ *   credentialId: credential.id,
+ *   challenge: '0xdeadbeef'
+ * })
+ * ```
+ *
+ * @example
+ * ### Signing Payloads
+ *
+ * Payloads can be signed using {@link ox#WebAuthnP256.(sign:function)}:
+ *
+ * ```ts twoslash
+ * import { WebAuthnP256 } from 'ox'
+ *
+ * const credential = await WebAuthnP256.createCredential({
+ *   name: 'Example'
+ * })
+ *
+ * const { metadata, signature } = await WebAuthnP256.sign({
+ *   // [!code focus]
+ *   credentialId: credential.id, // [!code focus]
+ *   challenge: '0xdeadbeef' // [!code focus]
+ * }) // [!code focus]
+ * // @log: {
+ * // @log:   metadata: {
+ * // @log:     authenticatorData: '0x49960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d97630500000000',
+ * // @log:     clientDataJSON: '{"type":"webauthn.get","challenge":"9jEFijuhEWrM4SOW-tChJbUEHEP44VcjcJ-Bqo1fTM8","origin":"http://localhost:5173","crossOrigin":false}',
+ * // @log:     challengeIndex: 23,
+ * // @log:     typeIndex: 1,
+ * // @log:     userVerificationRequired: true,
+ * // @log:   },
+ * // @log:   signature: { r: 51231...4215n, s: 12345...6789n },
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### Verifying Signatures
+ *
+ * Signatures can be verified using {@link ox#WebAuthnP256.(verify:function)}:
+ *
+ * ```ts twoslash
+ * import { WebAuthnP256 } from 'ox'
+ *
+ * const credential = await WebAuthnP256.createCredential({
+ *   name: 'Example'
+ * })
+ *
+ * const { metadata, signature } = await WebAuthnP256.sign({
+ *   credentialId: credential.id,
+ *   challenge: '0xdeadbeef'
+ * })
+ *
+ * const result = await WebAuthnP256.verify({
+ *   // [!code focus]
+ *   metadata, // [!code focus]
+ *   challenge: '0xdeadbeef', // [!code focus]
+ *   publicKey: credential.publicKey, // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ * // @log: true
+ * ```
+ *
+ * @category Crypto
+ */
+export * as WebAuthnP256 from './core/WebAuthnP256.js';
+/**
+ * Utility functions for [NIST P256](https://csrc.nist.gov/csrc/media/events/workshop-on-elliptic-curve-cryptography-standards/documents/papers/session6-adalier-mehmet.pdf) ECDSA cryptography using the [Web Crypto API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
+ *
+ * @example
+ * ### Creating Key Pairs
+ *
+ * Key pairs can be created using {@link ox#WebCryptoP256.(createKeyPair:function)}:
+ *
+ * ```ts twoslash
+ * import { WebCryptoP256 } from 'ox'
+ *
+ * const { publicKey, privateKey } =
+ *   await WebCryptoP256.createKeyPair()
+ * // @log: {
+ * // @log:   privateKey: CryptoKey {},
+ * // @log:   publicKey: {
+ * // @log:     x: '0x8318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed75',
+ * // @log:     y: '0x3547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5',
+ * // @log:     prefix: 4,
+ * // @log:   },
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### Signing Payloads
+ *
+ * Payloads can be signed using {@link ox#WebCryptoP256.(sign:function)}:
+ *
+ * ```ts twoslash
+ * import { WebCryptoP256 } from 'ox'
+ *
+ * const { privateKey } = await WebCryptoP256.createKeyPair()
+ *
+ * const signature = await WebCryptoP256.sign({
+ *   // [!code focus]
+ *   payload: '0xdeadbeef', // [!code focus]
+ *   privateKey // [!code focus]
+ * }) // [!code focus]
+ * // @log: {
+ * // @log:   r: 151231...4423n,
+ * // @log:   s: 516123...5512n,
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### Verifying Signatures
+ *
+ * Signatures can be verified using {@link ox#WebCryptoP256.(verify:function)}:
+ *
+ * ```ts twoslash
+ * import { WebCryptoP256 } from 'ox'
+ *
+ * const { privateKey, publicKey } =
+ *   await WebCryptoP256.createKeyPair()
+ * const signature = await WebCryptoP256.sign({
+ *   payload: '0xdeadbeef',
+ *   privateKey
+ * })
+ *
+ * const verified = await WebCryptoP256.verify({
+ *   // [!code focus]
+ *   payload: '0xdeadbeef', // [!code focus]
+ *   publicKey, // [!code focus]
+ *   signature // [!code focus]
+ * }) // [!code focus]
+ * // @log: true
+ * ```
+ *
+ * @category Crypto
+ */
+export * as WebCryptoP256 from './core/WebCryptoP256.js';
+/**
+ * Utilities & types for working with Withdrawals as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/withdrawal.yaml)
+ *
+ * @category Execution Spec
+ */
+export * as Withdrawal from './core/Withdrawal.js';
+/**
+ * Utilities for working with X25519 elliptic curve Diffie-Hellman key agreement.
+ *
+ * X25519 is a high-performance elliptic curve that can be used to perform
+ * Diffie-Hellman key agreement to derive shared secrets between parties.
+ * It is designed for use with the elliptic curve Diffie-Hellman (ECDH) key agreement scheme.
+ *
+ * @example
+ * ### Creating Key Pairs
+ *
+ * ```ts twoslash
+ * import { X25519 } from 'ox'
+ *
+ * const { privateKey, publicKey } = X25519.createKeyPair()
+ * ```
+ *
+ * @example
+ * ### Deriving Shared Secrets
+ *
+ * ```ts twoslash
+ * import { X25519 } from 'ox'
+ *
+ * const { privateKey: privateKeyA } = X25519.createKeyPair()
+ * const { publicKey: publicKeyB } = X25519.createKeyPair()
+ *
+ * const sharedSecret = X25519.getSharedSecret({
+ *   privateKey: privateKeyA,
+ *   publicKey: publicKeyB
+ * })
+ * ```
+ *
+ * @category Crypto
+ */
+export * as X25519 from './core/X25519.js';
+//# sourceMappingURL=index.js.map