ox 0.14.16 → 0.14.18

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

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

package/_types/tempo/index.d.ts

@@ -365,4 +365,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.d.ts.map

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;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.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;;;;;;;;;;;;;;;;;;;;;;;;;;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/_types/version.d.ts

@@ -1,3 +1,3 @@
 /** @internal */
-export declare const version = "0.14.16";
+export declare const version = "0.14.18";
 //# 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.16",
+  "version": "0.14.18",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -569,6 +569,26 @@
       "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",
+      "default": "./_cjs/tempo/ZoneId.js"
+    },
+    "./tempo/ZoneRpcAuthentication": {
+      "types": "./_types/tempo/ZoneRpcAuthentication.d.ts",
+      "import": "./_esm/tempo/ZoneRpcAuthentication.js",
+      "default": "./_cjs/tempo/ZoneRpcAuthentication.js"
+    },
     "./tempo": {
       "types": "./_types/tempo/index.d.ts",
       "import": "./_esm/tempo/index.js",

package/tempo/TransactionRequest.test.ts

@@ -21,7 +21,7 @@ describe('fromRpc', () => {
             "to": "0xcafebabecafebabecafebabecafebabecafebabe",
           },
         ],
-        "feeToken": 0n,
+        "feeToken": "0x20c0000000000000000000000000000000000000",
         "type": "tempo",
       }
     `)
@@ -100,6 +100,28 @@ describe('toRpc', () => {
       }
     `)
   })
+
+  test('behavior: to/data/value folded into calls', () => {
+    const request = TransactionRequest.toRpc({
+      to: '0xcafebabecafebabecafebabecafebabecafebabe',
+      data: '0xdeadbeef',
+      value: 1000n,
+      feeToken: '0x20c0000000000000000000000000000000000000',
+    })
+    expect(request).toMatchInlineSnapshot(`
+      {
+        "calls": [
+          {
+            "data": "0xdeadbeef",
+            "to": "0xcafebabecafebabecafebabecafebabecafebabe",
+            "value": "0x3e8",
+          },
+        ],
+        "feeToken": "0x20c0000000000000000000000000000000000000",
+        "type": "0x76",
+      }
+    `)
+  })
 })
 
 describe('roundtrip', () => {
@@ -134,7 +156,9 @@ describe('roundtrip', () => {
         value: call.value,
       })),
     )
-    expect(converted.feeToken).toEqual(1n)
+    expect(converted.feeToken).toEqual(
+      '0x20c0000000000000000000000000000000000001',
+    )
     expect(converted.validBefore).toBe(original.validBefore)
     expect(converted.validAfter).toBe(original.validAfter)
     expect(converted.nonceKey).toBe(original.nonceKey)

package/tempo/TransactionRequest.ts

@@ -23,6 +23,7 @@ export type TransactionRequest<
   bigintType = bigint,
   numberType = number,
   type extends string = string,
+  addressType = TempoAddress.Address,
 > = Compute<
   Omit<
     ox_TransactionRequest.TransactionRequest<bigintType, numberType, type>,
@@ -31,11 +32,12 @@ export type TransactionRequest<
     authorizationList?:
       | AuthorizationTempo.ListSigned<bigintType, numberType>
       | undefined
-    calls?: readonly Call<bigintType, TempoAddress.Address>[] | undefined
+    calls?: readonly Call<bigintType, addressType>[] | undefined
     keyAuthorization?: KeyAuthorization.KeyAuthorization<true> | undefined
     keyData?: Hex.Hex | undefined
     keyType?: KeyType | undefined
-    feeToken?: TokenId.TokenIdOrAddress<TempoAddress.Address> | undefined
+    feePayer?: boolean | undefined
+    feeToken?: TokenId.TokenIdOrAddress<addressType> | undefined
     nonceKey?: 'random' | bigintType | undefined
     validBefore?: numberType | undefined
     validAfter?: numberType | undefined
@@ -44,10 +46,11 @@ export type TransactionRequest<
 
 /** RPC representation of a {@link ox#TransactionRequest.TransactionRequest}. */
 export type Rpc = Omit<
-  TransactionRequest<Hex.Hex, Hex.Hex, string>,
-  'authorizationList' | 'keyAuthorization'
+  TransactionRequest<Hex.Hex, Hex.Hex, string, Hex.Hex>,
+  'authorizationList' | 'feeToken' | 'keyAuthorization'
 > & {
   authorizationList?: AuthorizationTempo.ListRpc | undefined
+  feeToken?: Hex.Hex | undefined
   keyAuthorization?: KeyAuthorization.Rpc | undefined
   nonceKey?: Hex.Hex | undefined
 }
@@ -99,9 +102,7 @@ export function fromRpc(request: Rpc): TransactionRequest {
       return mapped
     })
   if (typeof request.feeToken !== 'undefined')
-    request_.feeToken = TokenId.fromAddress(
-      request.feeToken as TempoAddress.Address,
-    )
+    request_.feeToken = request.feeToken
   if (request.keyAuthorization)
     request_.keyAuthorization = KeyAuthorization.fromRpc(
       request.keyAuthorization,
@@ -189,6 +190,14 @@ export function toRpc(request: TransactionRequest): Rpc {
       value: call.value ? Hex.fromNumber(call.value) : '0x',
       data: call.data ?? '0x',
     }))
+  else if (request.to || request.data || request.value)
+    request_rpc.calls = [
+      {
+        to: request.to ? TempoAddress.resolve(request.to) : undefined,
+        value: request.value ? Hex.fromNumber(request.value) : '0x',
+        data: request.data ?? '0x',
+      },
+    ]
   if (typeof request.feeToken !== 'undefined')
     request_rpc.feeToken = TokenId.toAddress(request.feeToken)
   if (request.keyAuthorization)
@@ -210,6 +219,7 @@ export function toRpc(request: TransactionRequest): Rpc {
 
   if (
     typeof request.calls !== 'undefined' ||
+    typeof request.feePayer !== 'undefined' ||
     typeof request.feeToken !== 'undefined' ||
     typeof request.keyAuthorization !== 'undefined' ||
     typeof request.nonceKey !== 'undefined' ||

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",
+    ]
+  `)
+})

package/tempo/VirtualAddress.ts

@@ -0,0 +1,201 @@
+import * as Address from '../core/Address.js'
+import * as Bytes from '../core/Bytes.js'
+import * as Errors from '../core/Errors.js'
+import * as Hex from '../core/Hex.js'
+import * as TempoAddress from './TempoAddress.js'
+
+/** Fixed 10-byte marker used by TIP-1022 virtual addresses. */
+export const magic = '0xfdfdfdfdfdfdfdfdfdfd' as const
+
+/** A fixed-width virtual address component. */
+export type Part = Hex.Hex | Bytes.Bytes | number | bigint
+
+/**
+ * Builds a TIP-1022 virtual address from a `masterId` and `userTag`.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-1022)
+ *
+ * TIP-1022 encodes virtual addresses as:
+ * `[4-byte masterId][10-byte VIRTUAL_MAGIC][6-byte userTag]`
+ *
+ * @example
+ * ```ts twoslash
+ * import { VirtualAddress } from 'ox/tempo'
+ *
+ * const address = VirtualAddress.from({
+ *   masterId: '0x58e21090',
+ *   userTag: '0x010203040506',
+ * })
+ *
+ * address
+ * // @log: '0x58e21090fdfdfdfdfdfdfdfdfdfd010203040506'
+ * ```
+ *
+ * @param value - The virtual address parts.
+ * @returns The virtual address.
+ */
+export function from(value: from.Value): Address.Address {
+  return Address.from(
+    Hex.concat(
+      toFixedHex(value.masterId, 4),
+      magic,
+      toFixedHex(value.userTag, 6),
+    ),
+  )
+}
+
+export declare namespace from {
+  type Value = {
+    /** 4-byte master identifier. */
+    masterId: Part
+    /** 6-byte opaque user tag. */
+    userTag: Part
+  }
+
+  type ErrorType =
+    | Address.from.ErrorType
+    | Bytes.padLeft.ErrorType
+    | Hex.assert.ErrorType
+    | Hex.fromBytes.ErrorType
+    | Hex.fromNumber.ErrorType
+    | Hex.padLeft.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/**
+ * Checks whether an address matches the TIP-1022 virtual address format.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-1022)
+ *
+ * This only checks the reserved byte layout, not whether the `masterId`
+ * is registered onchain.
+ *
+ * @example
+ * ```ts twoslash
+ * import { VirtualAddress } from 'ox/tempo'
+ *
+ * const isVirtual = VirtualAddress.isVirtual(
+ *   '0x58e21090fdfdfdfdfdfdfdfdfdfd010203040506',
+ * )
+ *
+ * isVirtual
+ * // @log: true
+ * ```
+ *
+ * @param address - Address to check.
+ * @returns `true` if the address matches the virtual-address layout.
+ */
+export function isVirtual(address: string): boolean {
+  try {
+    const resolved = resolveAddress(address)
+    return Hex.slice(resolved, 4, 14).toLowerCase() === magic
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Parses a TIP-1022 virtual address into its `masterId` and `userTag` parts.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-1022)
+ *
+ * @example
+ * ```ts twoslash
+ * import { VirtualAddress } from 'ox/tempo'
+ *
+ * const parsed = VirtualAddress.parse(
+ *   '0x58e21090fdfdfdfdfdfdfdfdfdfd010203040506',
+ * )
+ *
+ * parsed
+ * // @log: { masterId: '0x58e21090', userTag: '0x010203040506' }
+ * ```
+ *
+ * @param address - The virtual address to parse.
+ * @returns The decoded virtual address components.
+ */
+export function parse(address: string): parse.ReturnType {
+  const resolved = resolveAddress(address)
+
+  if (Hex.slice(resolved, 4, 14).toLowerCase() !== magic)
+    throw new InvalidMagicError({ address: resolved })
+
+  return {
+    masterId: Hex.slice(resolved, 0, 4),
+    userTag: Hex.slice(resolved, 14, 20),
+  }
+}
+
+export declare namespace parse {
+  type ReturnType = {
+    /** 4-byte master identifier. */
+    masterId: Hex.Hex
+    /** 6-byte opaque user tag. */
+    userTag: Hex.Hex
+  }
+
+  type ErrorType =
+    | Address.assert.ErrorType
+    | InvalidMagicError
+    | TempoAddress.parse.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/**
+ * Validates that an address matches the TIP-1022 virtual address format.
+ *
+ * [TIP-1022](https://docs.tempo.xyz/protocol/tips/tip-1022)
+ *
+ * This only validates the reserved byte layout, not whether the `masterId`
+ * resolves to a registered master onchain.
+ *
+ * @example
+ * ```ts twoslash
+ * import { VirtualAddress } from 'ox/tempo'
+ *
+ * const valid = VirtualAddress.validate(
+ *   '0x58e21090fdfdfdfdfdfdfdfdfdfd010203040506',
+ * )
+ *
+ * valid
+ * // @log: true
+ * ```
+ *
+ * @param address - Address to validate.
+ * @returns `true` if the address has a valid virtual-address layout.
+ */
+export function validate(address: string): boolean {
+  try {
+    parse(address)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Thrown when an address does not contain the TIP-1022 virtual marker. */
+export class InvalidMagicError extends Errors.BaseError {
+  override readonly name = 'VirtualAddress.InvalidMagicError'
+
+  constructor({ address }: { address: string }) {
+    super(
+      `Address "${address}" does not contain the TIP-1022 virtual address marker.`,
+    )
+  }
+}
+
+function resolveAddress(address: string): Address.Address {
+  const resolved = TempoAddress.resolve(address as TempoAddress.Address)
+  Address.assert(resolved, { strict: false })
+  return resolved
+}
+
+function toFixedHex(value: Part, size: number): Hex.Hex {
+  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))
+}

package/tempo/VirtualMaster/package.json

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