ox 0.14.17 → 0.14.19

package/_types/tempo/VirtualMaster.d.ts

@@ -0,0 +1,237 @@
+import * as Address from '../core/Address.js';
+import * as Bytes from '../core/Bytes.js';
+import * as Errors from '../core/Errors.js';
+import * as Hash from '../core/Hash.js';
+import * as Hex from '../core/Hex.js';
+import * as TempoAddress from './TempoAddress.js';
+/** A valid salt input for TIP-1022 master registration. */
+export type Salt = Hex.Hex | Bytes.Bytes | number | bigint;
+/**
+ * Computes the TIP-1022 registration hash for a master address and salt.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-1022)
+ *
+ * The registration hash is `keccak256(masterAddress || salt)` where `salt`
+ * is encoded as a 32-byte value.
+ *
+ * Master addresses must satisfy TIP-1022 registration constraints: they cannot
+ * be the zero address, another virtual address, or a TIP-20 token address.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address, Hex } from 'ox'
+ * import { VirtualMaster } from 'ox/tempo'
+ *
+ * const hash = VirtualMaster.getRegistrationHash({
+ *   address: Address.from('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'),
+ *   salt: Hex.from('0x00000000000000000000000000000000000000000000000000000000abf52baf'),
+ * })
+ *
+ * hash
+ * // @log: '0x0000000058e21090d8f4bee424b90cddc2378aefa1bbbfa1443631a929ae966d'
+ * ```
+ *
+ * @param value - Master address and salt.
+ * @returns The registration hash.
+ */
+export declare function getRegistrationHash(value: getRegistrationHash.Value): Hex.Hex;
+export declare namespace getRegistrationHash {
+    type Value = {
+        /** Master address. Accepts both hex and Tempo addresses. */
+        address: TempoAddress.Address;
+        /** 32-byte salt used for registration. */
+        salt: Salt;
+    };
+    type ErrorType = Address.assert.ErrorType | Bytes.padLeft.ErrorType | Errors.BaseError | Hash.keccak256.ErrorType | Hex.assert.ErrorType | Hex.fromBytes.ErrorType | Hex.fromNumber.ErrorType | Hex.padLeft.ErrorType | TempoAddress.parse.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Derives the 4-byte TIP-1022 `masterId` from a master address and salt.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-1022)
+ *
+ * This returns bytes `[4:8]` of the registration hash, regardless of whether the
+ * salt satisfies the proof-of-work requirement.
+ *
+ * Master addresses must satisfy TIP-1022 registration constraints: they cannot
+ * be the zero address, another virtual address, or a TIP-20 token address.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address, Hex } from 'ox'
+ * import { VirtualMaster } from 'ox/tempo'
+ *
+ * const masterId = VirtualMaster.getMasterId({
+ *   address: Address.from('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'),
+ *   salt: Hex.from('0x00000000000000000000000000000000000000000000000000000000abf52baf'),
+ * })
+ *
+ * masterId
+ * // @log: '0x58e21090'
+ * ```
+ *
+ * @param value - Master address and salt.
+ * @returns The derived master identifier.
+ */
+export declare function getMasterId(value: getMasterId.Value): Hex.Hex;
+export declare namespace getMasterId {
+    type Value = getRegistrationHash.Value;
+    type ErrorType = getRegistrationHash.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Validates that a salt satisfies the TIP-1022 32-bit proof-of-work requirement.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-1022)
+ *
+ * Returns `false` for invalid master addresses, including the zero address,
+ * virtual addresses, and TIP-20 token addresses.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address, Hex } from 'ox'
+ * import { VirtualMaster } from 'ox/tempo'
+ *
+ * const valid = VirtualMaster.validateSalt({
+ *   address: Address.from('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'),
+ *   salt: Hex.from('0x00000000000000000000000000000000000000000000000000000000abf52baf'),
+ * })
+ *
+ * valid
+ * // @log: true
+ * ```
+ *
+ * @param value - Master address and salt.
+ * @returns `true` if the first 4 bytes of the registration hash are zero.
+ */
+export declare function validateSalt(value: validateSalt.Value): boolean;
+export declare namespace validateSalt {
+    type Value = getRegistrationHash.Value;
+}
+/**
+ * Searches a bounded range of salts for the first value that satisfies TIP-1022 PoW.
+ *
+ * [TIP-1022](https://tips.sh/1022)
+ *
+ * This is intentionally a small, deterministic primitive. It does not coordinate
+ * workers or async execution. Callers that need large searches can shard ranges
+ * externally.
+ *
+ * Master addresses must satisfy TIP-1022 registration constraints: they cannot
+ * be the zero address, another virtual address, or a TIP-20 token address.
+ *
+ * :::warning
+ *
+ * It is strongly recommended to use {@link ox#VirtualMaster.(mineSaltAsync:function)} instead of this
+ * function. `mineSaltAsync` uses WASM-accelerated keccak256 with parallel
+ * workers and is a lot faster than the pure JS implementation used here.
+ *
+ * :::
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ * import { VirtualMaster } from 'ox/tempo'
+ *
+ * const result = VirtualMaster.mineSalt({
+ *   address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ * })
+ *
+ * result?.salt
+ * // @log: '0x00000000000000000000000000000000000000000000000000000000abf52baf'
+ * ```
+ *
+ * @param value - Search range parameters.
+ * @returns The first matching salt in the range, if any.
+ */
+export declare function mineSalt(value: mineSalt.Value): mineSalt.ReturnType | undefined;
+export declare namespace mineSalt {
+    type Value = {
+        /** Master address. Accepts both hex and Tempo addresses. */
+        address: TempoAddress.Address;
+        /** Number of consecutive salts to try. */
+        count?: number | undefined;
+        /** Starting salt value. @default 0n */
+        start?: Salt | undefined;
+    };
+    type ReturnType = {
+        /** The 4-byte master identifier derived from the matching salt. */
+        masterId: Hex.Hex;
+        /** The matching registration hash. */
+        registrationHash: Hex.Hex;
+        /** The discovered 32-byte salt. */
+        salt: Hex.Hex;
+    };
+    type ErrorType = Address.assert.ErrorType | Bytes.fromHex.ErrorType | Bytes.padLeft.ErrorType | Errors.BaseError | Hash.keccak256.ErrorType | Hex.assert.ErrorType | Hex.fromBytes.ErrorType | Hex.fromNumber.ErrorType | Hex.padLeft.ErrorType | TempoAddress.parse.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Searches for a salt that satisfies TIP-1022 PoW using parallel workers and
+ * WASM-accelerated keccak256.
+ *
+ * [TIP-1022](https://tips.sh/1022)
+ *
+ * Uses WASM-accelerated keccak256 with parallel
+ * workers when available. Falls back to chunked single-threaded mining in
+ * environments without worker support.
+ *
+ * - **Node.js / Bun / Deno**: Spawns `worker_threads` with inline WASM keccak256.
+ * - **Browsers**: Spawns Web Workers via Blob URLs with inline WASM keccak256.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address } from 'ox'
+ * import { VirtualMaster } from 'ox/tempo'
+ *
+ * const result = await VirtualMaster.mineSaltAsync({
+ *   address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ * })
+ * ```
+ *
+ * @param parameters - Search parameters.
+ * @returns The first matching salt, if any.
+ */
+export declare function mineSaltAsync(parameters: mineSaltAsync.Parameters): Promise<mineSalt.ReturnType | undefined>;
+export declare namespace mineSaltAsync {
+    type Parameters = {
+        /** Master address. Accepts both hex and Tempo addresses. */
+        address: TempoAddress.Address;
+        /**
+         * Number of salts each worker processes before sending a progress update.
+         *
+         * @default 100_000
+         */
+        chunkSize?: number | undefined;
+        /** Number of consecutive salts to try. @default 2 ** 32 */
+        count?: number | undefined;
+        /** Progress callback invoked after each completed chunk. */
+        onProgress?: ((progress: Progress) => void) | undefined;
+        /** AbortSignal for cancellation. */
+        signal?: AbortSignal | undefined;
+        /** Starting salt value. @default 0n */
+        start?: Salt | undefined;
+        /**
+         * Number of workers to use.
+         *
+         * Set to `0` or `1` to disable worker parallelism.
+         *
+         * @default os.availableParallelism() - 1
+         */
+        workers?: number | undefined;
+    };
+    type Progress = {
+        /** Total attempts so far. */
+        attempts: number;
+        /** Configured chunk size. */
+        chunkSize: number;
+        /** Total count requested. */
+        count: number;
+        /** Elapsed time in milliseconds. */
+        elapsed: number;
+        /** Fraction complete (0–1). */
+        progress: number;
+        /** Hashes per second. */
+        rate: number;
+        /** Number of workers in use. */
+        workers: number;
+    };
+    type ErrorType = mineSalt.ErrorType | Errors.BaseError | Errors.GlobalErrorType;
+}
+//# sourceMappingURL=VirtualMaster.d.ts.map

package/_types/tempo/VirtualMaster.d.ts.map

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

package/_types/tempo/index.d.ts

@@ -128,6 +128,7 @@ export * as PoolId from './PoolId.js';
  *
  * @example
  * ```ts twoslash
+ * import 'ox/window'
  * import { Provider, RpcSchema } from 'ox'
  * import { RpcSchemaTempo } from 'ox/tempo'
  *
@@ -365,6 +366,59 @@ export * as TransactionRequest from './TransactionRequest.js';
  * @category Reference
  */
 export * as TxEnvelopeTempo from './TxEnvelopeTempo.js';
+/**
+ * TIP-1022 virtual address encoding and parsing utilities.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-1022)
+ *
+ * Virtual addresses reserve the following 20-byte layout:
+ * `[4-byte masterId][10-byte VIRTUAL_MAGIC][6-byte userTag]`.
+ * These helpers only operate on the reserved byte layout and do not query
+ * onchain registration state.
+ *
+ * @example
+ * ```ts twoslash
+ * import { TempoAddress, VirtualAddress } from 'ox/tempo'
+ *
+ * const masterId = '0x58e21090' // derived when the master registers
+ * const userTag = '0x010203040506' // operator-defined deposit identifier
+ *
+ * const address = VirtualAddress.from({
+ *   masterId,
+ *   userTag,
+ * })
+ *
+ * const tempoAddress = TempoAddress.format(address) // optional display format
+ * ```
+ *
+ * @category Reference
+ */
+export * as VirtualAddress from './VirtualAddress.js';
+/**
+ * TIP-1022 master registration utilities.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-1022)
+ *
+ * These utilities expose deterministic hashing and bounded salt mining helpers for
+ * `registerVirtualMaster(bytes32 salt)` without introducing any extra hashing dependency.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Address, Hex } from 'ox'
+ * import { VirtualMaster } from 'ox/tempo'
+ *
+ * const registration = {
+ *   address: Address.from('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'),
+ *   salt: Hex.from('0x00000000000000000000000000000000000000000000000000000000abf52baf'),
+ * }
+ *
+ * const registrationHash = VirtualMaster.getRegistrationHash(registration) // keccak256(address || salt)
+ * const masterId = VirtualMaster.getMasterId(registration) // bytes [4:8] of the hash
+ * ```
+ *
+ * @category Reference
+ */
+export * as VirtualMaster from './VirtualMaster.js';
 /**
  * Zone ID utilities for converting between zone IDs and zone chain IDs.
  *

package/_types/tempo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAEhC,YAAY,EAAE,CAAA;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAAA,gCAAgC;AAEhC,YAAY,EAAE,CAAA;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AACzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAC3D;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AACjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAC/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAC7D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}

package/_types/tempo/internal/mine.wasm.d.ts

@@ -0,0 +1,5 @@
+/** Base64-encoded WASM binary for the TIP-1022 salt miner. */
+export declare const wasmBase64 = "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";
+/** Byte offset in WASM linear memory where mining I/O begins. */
+export declare const dataOffset = 1024;
+//# sourceMappingURL=mine.wasm.d.ts.map

package/_types/tempo/internal/mine.wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mine.wasm.d.ts","sourceRoot":"","sources":["../../../tempo/internal/mine.wasm.ts"],"names":[],"mappings":"AAWA,8DAA8D;AAC9D,eAAO,MAAM,UAAU,iuGACysG,CAAA;AAEhuG,iEAAiE;AACjE,eAAO,MAAM,UAAU,OAAO,CAAA"}

package/_types/tempo/internal/virtualMasterPool.d.ts

@@ -0,0 +1,46 @@
+/** Message sent from a mining worker to the main thread. */
+export type Message = {
+    type: 'done';
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'found';
+    result: {
+        /** The 4-byte master identifier. */
+        masterId: string;
+        /** The full 32-byte registration hash. */
+        registrationHash: string;
+        /** The discovered 32-byte salt. */
+        salt: string;
+    };
+} | {
+    type: 'progress';
+    attempts: number;
+};
+/** A platform-agnostic worker pool for parallel salt mining. */
+export type Pool = {
+    spawn(index: number, onMessage: (msg: Message) => void, onError: (err: unknown) => void): {
+        postMessage(data: unknown): void;
+        terminate(): void;
+    };
+};
+/**
+ * Resolves the best available worker pool for the current runtime.
+ *
+ * @internal
+ */
+export declare function resolve(): Promise<Pool | undefined>;
+/**
+ * Creates a worker pool backed by Node.js `worker_threads`.
+ *
+ * @internal
+ */
+export declare function resolveNode(): Promise<Pool | undefined>;
+/**
+ * Creates a worker pool backed by browser `Worker` with Blob URLs.
+ *
+ * @internal
+ */
+export declare function resolveBrowser(): Promise<Pool | undefined>;
+//# sourceMappingURL=virtualMasterPool.d.ts.map

package/_types/tempo/internal/virtualMasterPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"virtualMasterPool.d.ts","sourceRoot":"","sources":["../../../tempo/internal/virtualMasterPool.ts"],"names":[],"mappings":"AAEA,4DAA4D;AAC5D,MAAM,MAAM,OAAO,GACf;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAClC;IACE,IAAI,EAAE,OAAO,CAAA;IACb,MAAM,EAAE;QACN,oCAAoC;QACpC,QAAQ,EAAE,MAAM,CAAA;QAChB,0CAA0C;QAC1C,gBAAgB,EAAE,MAAM,CAAA;QACxB,mCAAmC;QACnC,IAAI,EAAE,MAAM,CAAA;KACb,CAAA;CACF,GACD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1C,gEAAgE;AAChE,MAAM,MAAM,IAAI,GAAG;IACjB,KAAK,CACH,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,EACjC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,GAC9B;QAAE,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;QAAC,SAAS,IAAI,IAAI,CAAA;KAAE,CAAA;CAC3D,CAAA;AAaD;;;;GAIG;AACH,wBAAsB,OAAO,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAIzD;AAED;;;;GAIG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAkC7D;AAED;;;;GAIG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAwBhE"}

package/_types/version.d.ts

@@ -1,3 +1,3 @@
 /** @internal */
-export declare const version = "0.14.17";
+export declare const version = "0.14.19";
 //# sourceMappingURL=version.d.ts.map

package/core/RpcSchema.ts

@@ -290,7 +290,6 @@ export type MethodNameGeneric<schema extends Generic = Generic> =
  *       ReturnType: `0x${string}`
  *     }
  * >
- * // ^? [{ Method: 'eth_blockNumber'; Parameters?: undefined; ReturnType: `0x${string}` }, ...]
  * ```
  */
 export type ToViem<schema extends Generic> = UnionToTuple<
@@ -315,7 +314,6 @@ export type ToViem<schema extends Generic> = UnionToTuple<
  *   { Method: 'eth_blockNumber'; Parameters?: undefined; ReturnType: `0x${string}` },
  *   { Method: 'eth_chainId'; Parameters?: undefined; ReturnType: `0x${string}` },
  * ]>
- * // ^? { Request: { method: 'eth_blockNumber'; params?: undefined }; ReturnType: `0x${string}` } | ...
  * ```
  */
 export type FromViem<schema extends readonly ViemSchemaItem[]> = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.14.17",
+  "version": "0.14.19",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -569,6 +569,16 @@
       "import": "./_esm/tempo/TxEnvelopeTempo.js",
       "default": "./_cjs/tempo/TxEnvelopeTempo.js"
     },
+    "./tempo/VirtualAddress": {
+      "types": "./_types/tempo/VirtualAddress.d.ts",
+      "import": "./_esm/tempo/VirtualAddress.js",
+      "default": "./_cjs/tempo/VirtualAddress.js"
+    },
+    "./tempo/VirtualMaster": {
+      "types": "./_types/tempo/VirtualMaster.d.ts",
+      "import": "./_esm/tempo/VirtualMaster.js",
+      "default": "./_cjs/tempo/VirtualMaster.js"
+    },
     "./tempo/ZoneId": {
       "types": "./_types/tempo/ZoneId.d.ts",
       "import": "./_esm/tempo/ZoneId.js",

package/tempo/TxEnvelopeTempo.ts

@@ -162,10 +162,11 @@ export type Type = typeof type
  *
  * @example
  * ```ts twoslash
+ * import { Address } from 'ox'
  * import { TxEnvelopeTempo } from 'ox/tempo'
  *
  * TxEnvelopeTempo.assert({
- *   calls: [{ to: 'tempox0x0000000000000000000000000000000000000000', value: 0n }],
+ *   calls: [{ to: Address.from('0x0000000000000000000000000000000000000000'), value: 0n }],
  *   chainId: 1,
  *   maxFeePerGas: 1000000000n,
  * })
@@ -1023,12 +1024,13 @@ export declare namespace getFeePayerSignPayload {
  *
  * @example
  * ```ts twoslash
+ * import { Address } from 'ox'
  * import { TxEnvelopeTempo } from 'ox/tempo'
  *
  * const valid = TxEnvelopeTempo.validate({
  *   calls: [{
  *     data: '0xdeadbeef',
- *     to: 'tempox0x0000000000000000000000000000000000000000',
+ *     to: Address.from('0x0000000000000000000000000000000000000000'),
  *   }],
  *   chainId: 1,
  *   maxFeePerGas: 1000000000n,
@@ -1077,10 +1079,11 @@ export class CallsEmptyError extends Errors.BaseError {
  *
  * @example
  * ```ts twoslash
+ * import { Address } from 'ox'
  * import { TxEnvelopeTempo } from 'ox/tempo'
  *
  * TxEnvelopeTempo.assert({
- *   calls: [{ to: 'tempox0x0000000000000000000000000000000000000000' }],
+ *   calls: [{ to: Address.from('0x0000000000000000000000000000000000000000') }],
  *   chainId: 1,
  *   validBefore: 100,
  *   validAfter: 200,

package/tempo/VirtualAddress/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/VirtualAddress.d.ts",
+  "main": "../../_cjs/tempo/VirtualAddress.js",
+  "module": "../../_esm/tempo/VirtualAddress.js"
+}

package/tempo/VirtualAddress.test.ts

@@ -0,0 +1,88 @@
+import { TempoAddress, VirtualAddress } from 'ox/tempo'
+import { describe, expect, test } from 'vitest'
+
+const address = '0x58e21090fdfdfdfdfdfdfdfdfdfd010203040506'
+const tempoAddress = TempoAddress.format(address)
+
+describe('from', () => {
+  test('default', () => {
+    expect(
+      VirtualAddress.from({
+        masterId: '0x58e21090',
+        userTag: '0x010203040506',
+      }),
+    ).toMatchInlineSnapshot(`"0x58e21090fdfdfdfdfdfdfdfdfdfd010203040506"`)
+  })
+
+  test('pads number inputs', () => {
+    expect(
+      VirtualAddress.from({
+        masterId: 1,
+        userTag: 2,
+      }),
+    ).toMatchInlineSnapshot(`"0x00000001fdfdfdfdfdfdfdfdfdfd000000000002"`)
+  })
+})
+
+describe('parse', () => {
+  test('raw address', () => {
+    expect(VirtualAddress.parse(address)).toMatchInlineSnapshot(`
+      {
+        "masterId": "0x58e21090",
+        "userTag": "0x010203040506",
+      }
+    `)
+  })
+
+  test('tempo address', () => {
+    expect(VirtualAddress.parse(tempoAddress)).toMatchInlineSnapshot(`
+      {
+        "masterId": "0x58e21090",
+        "userTag": "0x010203040506",
+      }
+    `)
+  })
+
+  test('error: not virtual', () => {
+    expect(() =>
+      VirtualAddress.parse('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[VirtualAddress.InvalidMagicError: Address "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" does not contain the TIP-1022 virtual address marker.]`,
+    )
+  })
+})
+
+describe('isVirtual', () => {
+  test('returns true for virtual address', () => {
+    expect(VirtualAddress.isVirtual(address)).toBe(true)
+  })
+
+  test('returns false for non-virtual address', () => {
+    expect(
+      VirtualAddress.isVirtual('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266'),
+    ).toBe(false)
+  })
+})
+
+describe('validate', () => {
+  test('returns true for virtual address', () => {
+    expect(VirtualAddress.validate(tempoAddress)).toBe(true)
+  })
+
+  test('returns false for invalid value', () => {
+    expect(VirtualAddress.validate('invalid')).toBe(false)
+  })
+})
+
+test('exports', () => {
+  expect(Object.keys(VirtualAddress)).toMatchInlineSnapshot(`
+    [
+      "magic",
+      "from",
+      "isVirtual",
+      "parse",
+      "validate",
+      "InvalidMagicError",
+    ]
+  `)
+})