ox 0.14.16 → 0.14.18

package/_esm/tempo/VirtualMaster.js

@@ -0,0 +1,200 @@
+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';
+import * as VirtualAddress from './VirtualAddress.js';
+const tip20Prefix = '0x20c000000000000000000000';
+const zeroAddress = '0x0000000000000000000000000000000000000000';
+/**
+ * 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 { VirtualMaster } from 'ox/tempo'
+ *
+ * const hash = VirtualMaster.getRegistrationHash({
+ *   address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *   salt: '0x00000000000000000000000000000000000000000000000000000000abf52baf',
+ * })
+ *
+ * hash
+ * // @log: '0x0000000058e21090d8f4bee424b90cddc2378aefa1bbbfa1443631a929ae966d'
+ * ```
+ *
+ * @param value - Master address and salt.
+ * @returns The registration hash.
+ */
+export function getRegistrationHash(value) {
+    return Hash.keccak256(Hex.concat(resolveAddress(value.address), toFixedHex(value.salt, 32)));
+}
+/**
+ * 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 { VirtualMaster } from 'ox/tempo'
+ *
+ * const masterId = VirtualMaster.getMasterId({
+ *   address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *   salt: '0x00000000000000000000000000000000000000000000000000000000abf52baf',
+ * })
+ *
+ * masterId
+ * // @log: '0x58e21090'
+ * ```
+ *
+ * @param value - Master address and salt.
+ * @returns The derived master identifier.
+ */
+export function getMasterId(value) {
+    return Hex.slice(getRegistrationHash(value), 4, 8);
+}
+/**
+ * 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 { VirtualMaster } from 'ox/tempo'
+ *
+ * const valid = VirtualMaster.validateSalt({
+ *   address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *   salt: '0x00000000000000000000000000000000000000000000000000000000abf52baf',
+ * })
+ *
+ * valid
+ * // @log: true
+ * ```
+ *
+ * @param value - Master address and salt.
+ * @returns `true` if the first 4 bytes of the registration hash are zero.
+ */
+export function validateSalt(value) {
+    try {
+        return hasProofOfWork(Hash.keccak256(Hex.concat(resolveAddress(value.address), toFixedHex(value.salt, 32)), { as: 'Bytes' }));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Searches a bounded range of salts for the first value that satisfies TIP-1022 PoW.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-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.
+ *
+ * @example
+ * ```ts twoslash
+ * import { VirtualMaster } from 'ox/tempo'
+ *
+ * const result = VirtualMaster.mineSalt({
+ *   address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *   start: 0xabf52ba0n,
+ *   count: 16,
+ * })
+ *
+ * result?.salt
+ * // @log: '0x00000000000000000000000000000000000000000000000000000000abf52baf'
+ * ```
+ *
+ * @param value - Search range parameters.
+ * @returns The first matching salt in the range, if any.
+ */
+export function mineSalt(value) {
+    assertCount(value.count);
+    const address = resolveAddress(value.address);
+    const addressBytes = Bytes.fromHex(address);
+    const saltBytes = toFixedBytes(value.start ?? 0n, 32);
+    const input = new Uint8Array(addressBytes.length + saltBytes.length);
+    input.set(addressBytes);
+    for (let i = 0; i < value.count; i++) {
+        input.set(saltBytes, addressBytes.length);
+        const registrationHash = Hash.keccak256(input, { as: 'Bytes' });
+        if (hasProofOfWork(registrationHash)) {
+            return {
+                masterId: Hex.fromBytes(registrationHash.subarray(4, 8)),
+                registrationHash: Hex.fromBytes(registrationHash),
+                salt: Hex.fromBytes(saltBytes),
+            };
+        }
+        if (i < value.count - 1 && !increment(saltBytes))
+            break;
+    }
+    return undefined;
+}
+function hasProofOfWork(hash) {
+    return hash[0] === 0 && hash[1] === 0 && hash[2] === 0 && hash[3] === 0;
+}
+function assertCount(count) {
+    if (Number.isSafeInteger(count) && count > 0)
+        return;
+    throw new Errors.BaseError(`Count "${count}" is invalid. Expected a positive safe integer.`);
+}
+function increment(bytes) {
+    for (let i = bytes.length - 1; i >= 0; i--) {
+        const value = bytes[i];
+        if (value === 0xff) {
+            bytes[i] = 0;
+            continue;
+        }
+        bytes[i] = value + 1;
+        return true;
+    }
+    return false;
+}
+function resolveAddress(address) {
+    const resolved = TempoAddress.resolve(address);
+    Address.assert(resolved, { strict: false });
+    assertValidMasterAddress(resolved);
+    return resolved;
+}
+function assertValidMasterAddress(address) {
+    const normalized = address.toLowerCase();
+    if (normalized === zeroAddress)
+        throw new Errors.BaseError('Virtual master address cannot be the zero address.');
+    if (VirtualAddress.isVirtual(address))
+        throw new Errors.BaseError('Virtual master address cannot itself be a virtual address.');
+    if (normalized.startsWith(tip20Prefix))
+        throw new Errors.BaseError('Virtual master address cannot be a TIP-20 token address.');
+}
+function toFixedBytes(value, size) {
+    return Bytes.fromHex(toFixedHex(value, size));
+}
+function toFixedHex(value, size) {
+    if (typeof value === 'number' || typeof value === 'bigint')
+        return Hex.fromNumber(value, { size });
+    if (typeof value === 'string') {
+        Hex.assert(value, { strict: true });
+        return Hex.padLeft(value, size);
+    }
+    return Hex.fromBytes(Bytes.padLeft(value, size));
+}
+//# sourceMappingURL=VirtualMaster.js.map

package/_esm/tempo/VirtualMaster.js.map

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

package/_esm/tempo/ZoneId.js

@@ -0,0 +1,47 @@
+/**
+ * Base offset for deriving zone chain IDs.
+ *
+ * Zone chain IDs are computed as `chainIdBase + zoneId`.
+ */
+export const chainIdBase = 4_217_000_000;
+/**
+ * Derives a zone ID from a zone chain ID.
+ *
+ * Zone chain IDs follow the formula `4_217_000_000 + zoneId`, so a chain ID
+ * of `4217000006` corresponds to zone ID `6`.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ZoneId } from 'ox/tempo'
+ *
+ * const zoneId = ZoneId.fromChainId(4_217_000_006)
+ * // @log: 6
+ * ```
+ *
+ * @param chainId - The zone chain ID.
+ * @returns The zone ID.
+ */
+export function fromChainId(chainId) {
+    return chainId - chainIdBase;
+}
+/**
+ * Derives a zone chain ID from a zone ID.
+ *
+ * Zone chain IDs follow the formula `4_217_000_000 + zoneId`, so zone ID
+ * `6` corresponds to chain ID `4217000006`.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ZoneId } from 'ox/tempo'
+ *
+ * const chainId = ZoneId.toChainId(6)
+ * // @log: 4217000006
+ * ```
+ *
+ * @param zoneId - The zone ID.
+ * @returns The zone chain ID.
+ */
+export function toChainId(zoneId) {
+    return chainIdBase + zoneId;
+}
+//# sourceMappingURL=ZoneId.js.map

package/_esm/tempo/ZoneId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ZoneId.js","sourceRoot":"","sources":["../../tempo/ZoneId.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,aAAsB,CAAA;AAEjD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,OAAO,OAAO,GAAG,WAAW,CAAA;AAC9B,CAAC;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,SAAS,CAAC,MAAc;IACtC,OAAO,WAAW,GAAG,MAAM,CAAA;AAC7B,CAAC"}

package/_esm/tempo/ZoneRpcAuthentication.js

@@ -0,0 +1,256 @@
+import * as Errors from '../core/Errors.js';
+import * as Hash from '../core/Hash.js';
+import * as Hex from '../core/Hex.js';
+import * as SignatureEnvelope from './SignatureEnvelope.js';
+import * as TempoAddress from './TempoAddress.js';
+/**
+ * Header name used to transport Zone RPC authentication tokens.
+ */
+export const headerName = 'X-Authorization-Token';
+/**
+ * 32-byte domain separator used when hashing Zone RPC authentication tokens.
+ */
+export const magicBytes = '0x54656d706f5a6f6e655250430000000000000000000000000000000000000000';
+/**
+ * Size, in bytes, of the fixed Zone RPC authentication fields.
+ */
+export const fieldsSize = 29;
+/** Current Zone RPC authentication version. */
+export const version = 0;
+/**
+ * Instantiates a typed Zone RPC authentication token.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ZoneRpcAuthentication } from 'ox/tempo'
+ *
+ * const authentication = ZoneRpcAuthentication.from({
+ *   chainId: 4217000026,
+ *   expiresAt: 1711235160,
+ *   issuedAt: 1711234560,
+ *   zoneId: 26,
+ * })
+ * ```
+ *
+ * @example
+ * ### Attaching Signatures
+ *
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox'
+ * import { ZoneRpcAuthentication } from 'ox/tempo'
+ *
+ * const authentication = ZoneRpcAuthentication.from({
+ *   chainId: 4217000026,
+ *   expiresAt: 1711235160,
+ *   issuedAt: 1711234560,
+ *   zoneId: 26,
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: ZoneRpcAuthentication.getSignPayload(authentication),
+ *   privateKey: '0x...',
+ * })
+ *
+ * const authentication_signed = ZoneRpcAuthentication.from(authentication, {
+ *   signature,
+ * })
+ * ```
+ *
+ * @param authentication - Zone RPC authentication token fields.
+ * @param options - Zone RPC authentication options.
+ * @returns The instantiated Zone RPC authentication token.
+ */
+export function from(authentication, options = {}) {
+    const auth = authentication;
+    const resolved = {
+        ...auth,
+        version,
+    };
+    if (options.signature)
+        return {
+            ...resolved,
+            signature: SignatureEnvelope.from(options.signature),
+        };
+    return resolved;
+}
+/**
+ * Parses a serialized Zone RPC authentication token.
+ *
+ * The serialized format is `<signature><29-byte fields>`. The signature is parsed
+ * from the prefix and the fixed-length fields are parsed from the suffix.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ZoneRpcAuthentication } from 'ox/tempo'
+ *
+ * const authentication = ZoneRpcAuthentication.deserialize('0x...')
+ * ```
+ *
+ * @param serialized - The serialized Zone RPC authentication token.
+ * @returns The parsed Zone RPC authentication token.
+ */
+export function deserialize(serialized) {
+    const size = Hex.size(serialized);
+    if (size <= fieldsSize)
+        throw new InvalidSerializedError({
+            reason: `Serialized authentication must be longer than ${fieldsSize} bytes.`,
+            serialized,
+        });
+    const fieldsOffset = size - fieldsSize;
+    const signature = Hex.slice(serialized, 0, fieldsOffset);
+    const fields = Hex.slice(serialized, fieldsOffset);
+    const parsedVersion = Hex.toNumber(Hex.slice(fields, 0, 1), { size: 1 });
+    if (parsedVersion !== version)
+        throw new InvalidSerializedError({
+            reason: `Unsupported authentication version "${parsedVersion}". Expected "${version}".`,
+            serialized,
+        });
+    return {
+        chainId: Hex.toNumber(Hex.slice(fields, 5, 13), { size: 8 }),
+        expiresAt: Hex.toNumber(Hex.slice(fields, 21, 29), { size: 8 }),
+        issuedAt: Hex.toNumber(Hex.slice(fields, 13, 21), { size: 8 }),
+        signature: SignatureEnvelope.deserialize(signature),
+        version,
+        zoneId: Hex.toNumber(Hex.slice(fields, 1, 5), { size: 4 }),
+    };
+}
+/**
+ * Returns the 29-byte fixed field suffix for a Zone RPC authentication token.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ZoneRpcAuthentication } from 'ox/tempo'
+ *
+ * const fields = ZoneRpcAuthentication.getFields({
+ *   chainId: 4217000026,
+ *   expiresAt: 1711235160,
+ *   issuedAt: 1711234560,
+ *   zoneId: 26,
+ * })
+ * ```
+ *
+ * @param authentication - The Zone RPC authentication token.
+ * @returns The fixed 29-byte field suffix.
+ */
+export function getFields(authentication) {
+    return Hex.concat(Hex.fromNumber(version, { size: 1 }), Hex.fromNumber(authentication.zoneId, { size: 4 }), Hex.fromNumber(authentication.chainId, { size: 8 }), Hex.fromNumber(authentication.issuedAt, { size: 8 }), Hex.fromNumber(authentication.expiresAt, { size: 8 }));
+}
+/**
+ * Computes the sign payload for a Zone RPC authentication token.
+ *
+ * When `userAddress` is provided, the payload is wrapped as
+ * `keccak256(0x04 || authHash || userAddress)` to match V2 keychain signing.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ZoneRpcAuthentication } from 'ox/tempo'
+ *
+ * const authentication = ZoneRpcAuthentication.from({
+ *   chainId: 4217000026,
+ *   expiresAt: 1711235160,
+ *   issuedAt: 1711234560,
+ *   zoneId: 26,
+ * })
+ *
+ * const payload = ZoneRpcAuthentication.getSignPayload(authentication)
+ * ```
+ *
+ * @param authentication - The Zone RPC authentication token.
+ * @param options - Options.
+ * @returns The sign payload.
+ */
+export function getSignPayload(authentication, options = {}) {
+    const authHash = hash(authentication);
+    if (options.userAddress)
+        return Hash.keccak256(Hex.concat('0x04', authHash, TempoAddress.resolve(options.userAddress)));
+    return authHash;
+}
+/**
+ * Computes the raw authorization hash for a Zone RPC authentication token.
+ *
+ * The hash is `keccak256(magicBytes || fields)`.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ZoneRpcAuthentication } from 'ox/tempo'
+ *
+ * const authentication = ZoneRpcAuthentication.from({
+ *   chainId: 4217000026,
+ *   expiresAt: 1711235160,
+ *   issuedAt: 1711234560,
+ *   zoneId: 26,
+ * })
+ *
+ * const hash = ZoneRpcAuthentication.hash(authentication)
+ * ```
+ *
+ * @param authentication - The Zone RPC authentication token.
+ * @returns The authorization hash.
+ */
+export function hash(authentication) {
+    return Hash.keccak256(Hex.concat(magicBytes, getFields(authentication)));
+}
+/**
+ * Serializes a Zone RPC authentication token to hex.
+ *
+ * The serialized format is `<signature><29-byte fields>`.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox'
+ * import { ZoneRpcAuthentication } from 'ox/tempo'
+ *
+ * const authentication = ZoneRpcAuthentication.from({
+ *   chainId: 4217000026,
+ *   expiresAt: 1711235160,
+ *   issuedAt: 1711234560,
+ *   zoneId: 26,
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: ZoneRpcAuthentication.getSignPayload(authentication),
+ *   privateKey: '0x...',
+ * })
+ *
+ * const serialized = ZoneRpcAuthentication.serialize(authentication, {
+ *   signature,
+ * })
+ * ```
+ *
+ * @param authentication - The Zone RPC authentication token.
+ * @param options - Serialization options.
+ * @returns The serialized authentication token.
+ */
+export function serialize(authentication, options = {}) {
+    const signature = options.signature || authentication.signature;
+    if (!signature)
+        throw new MissingSignatureError();
+    return Hex.concat(SignatureEnvelope.serialize(SignatureEnvelope.from(signature)), getFields(authentication));
+}
+/** Error thrown when a serialized authentication token cannot be deserialized. */
+export class InvalidSerializedError extends Errors.BaseError {
+    constructor({ reason, serialized }) {
+        super(`Unable to deserialize Zone RPC authentication: ${reason}`, {
+            metaMessages: [`Serialized: ${serialized}`],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'ZoneRpcAuthentication.InvalidSerializedError'
+        });
+    }
+}
+/** Error thrown when serializing an authentication token without a signature. */
+export class MissingSignatureError extends Errors.BaseError {
+    constructor() {
+        super('Zone RPC authentication is missing a signature.');
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'ZoneRpcAuthentication.MissingSignatureError'
+        });
+    }
+}
+//# sourceMappingURL=ZoneRpcAuthentication.js.map

package/_esm/tempo/ZoneRpcAuthentication.js.map

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

package/_esm/tempo/index.js

@@ -363,4 +363,111 @@ 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 { VirtualMaster } from 'ox/tempo'
+ *
+ * const registration = {
+ *   address: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+ *   salt: '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.
+ *
+ * Zone chain IDs are deterministically derived from zone IDs using the formula
+ * `421_700_000 + zoneId`. This module provides helpers to convert between them.
+ *
+ * @example
+ * ```ts twoslash
+ * import { ZoneId } from 'ox/tempo'
+ *
+ * const zoneId = ZoneId.fromChainId(421_700_026)
+ * // @log: 26
+ *
+ * const chainId = ZoneId.toChainId(26)
+ * // @log: 421700026
+ * ```
+ *
+ * @category Reference
+ */
+export * as ZoneId from './ZoneId.js';
+/**
+ * Zone RPC authentication token utilities for private zone RPC access.
+ *
+ * Zone RPC authentication tokens are short-lived, read-only credentials used in
+ * the `X-Authorization-Token` header when talking to private zone RPC endpoints.
+ * They reuse Tempo's multi-signature model, so secp256k1, P256, WebAuthn, and
+ * keychain access-key signatures all share the same wire format as Tempo
+ * transaction signatures.
+ *
+ * [Zone RPC Specification](https://docs.tempo.xyz/protocol/privacy/rpc#authorization-tokens)
+ *
+ * @example
+ * ```ts twoslash
+ * import { Secp256k1 } from 'ox'
+ * import { ZoneRpcAuthentication } from 'ox/tempo'
+ *
+ * const authentication = ZoneRpcAuthentication.from({
+ *   chainId: 4217000026,
+ *   expiresAt: 1711235160,
+ *   issuedAt: 1711234560,
+ *   zoneId: 26,
+ *   zonePortal: 'tempox0x0f1b0cedd7e8226e39ecb161f522c8b1ac45e9c8',
+ * })
+ *
+ * const signature = Secp256k1.sign({
+ *   payload: ZoneRpcAuthentication.getSignPayload(authentication),
+ *   privateKey: '0x...',
+ * })
+ *
+ * const token = ZoneRpcAuthentication.serialize(authentication, { signature })
+ * ```
+ *
+ * @category Reference
+ */
+export * as ZoneRpcAuthentication from './ZoneRpcAuthentication.js';
 //# sourceMappingURL=index.js.map

package/_esm/tempo/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../tempo/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AACnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,qBAAqB,MAAM,4BAA4B,CAAA"}

package/_esm/version.js

@@ -1,3 +1,3 @@
 /** @internal */
-export const version = '0.14.16';
+export const version = '0.14.18';
 //# sourceMappingURL=version.js.map

package/_types/core/RpcSchema.d.ts

@@ -263,7 +263,6 @@ export type MethodNameGeneric<schema extends Generic = Generic> = schema['Reques
  *       ReturnType: `0x${string}`
  *     }
  * >
- * // ^? [{ Method: 'eth_blockNumber'; Parameters?: undefined; ReturnType: `0x${string}` }, ...]
  * ```
  */
 export type ToViem<schema extends Generic> = UnionToTuple<schema extends schema ? {
@@ -285,7 +284,6 @@ export type ToViem<schema extends Generic> = UnionToTuple<schema extends schema
  *   { 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[]> = {