ox 0.14.29 → 1.0.0-beta.0

package/src/zod/tempo/_test/RpcSchemaTempo.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_RpcSchema from '../../RpcSchema.js'
+import * as z_RpcSchemaTempo from '../RpcSchemaTempo.js'
+import * as z from 'zod/mini'
+
+describe('tempo_simulateV1', () => {
+  test('decodes params', () => {
+    const params = z_RpcSchema.parseParams(
+      z_RpcSchemaTempo.Tempo,
+      'tempo_simulateV1',
+      [
+        {
+          blockStateCalls: [
+            {
+              calls: [
+                {
+                  calls: [
+                    {
+                      data: '0xdeadbeef',
+                      to: '0xcafebabecafebabecafebabecafebabecafebabe',
+                    },
+                  ],
+                  chainId: '0x1',
+                  type: '0x76',
+                },
+              ],
+            },
+          ],
+        },
+        'latest',
+      ],
+    )
+    expect(params[0].blockStateCalls[0]!.calls?.[0]).toMatchObject({
+      chainId: 1,
+      type: 'tempo',
+    })
+    expect(params[1]).toBe('latest')
+  })
+
+  test('rejects invalid params', () => {
+    expect(
+      z.safeDecode(z_RpcSchemaTempo.tempo_simulateV1.params, [{}] as never)
+        .success,
+    ).toBe(false)
+  })
+
+  test('exposes a method and request schema', () => {
+    expect(z_RpcSchemaTempo.tempo_simulateV1.method).toBe('tempo_simulateV1')
+    expect(
+      z.safeDecode(z_RpcSchemaTempo.tempo_simulateV1.request, {
+        method: 'tempo_simulateV1',
+        params: [{ blockStateCalls: [] }, 'latest'],
+      } as never).success,
+    ).toBe(true)
+  })
+})

package/src/zod/tempo/_test/SignatureEnvelope.test-d.ts

@@ -0,0 +1,19 @@
+import type * as core_SignatureEnvelope from '../../../tempo/SignatureEnvelope.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_SignatureEnvelope from '../SignatureEnvelope.js'
+
+test('SignatureEnvelope decodes RPC into a signature envelope', () => {
+  expectTypeOf<core_SignatureEnvelope.SignatureEnvelopeRpc>().toExtend<
+    z.input<typeof z_SignatureEnvelope.SignatureEnvelope>
+  >()
+  expectTypeOf<core_SignatureEnvelope.SignatureEnvelope>().toExtend<
+    z.output<typeof z_SignatureEnvelope.SignatureEnvelope>
+  >()
+})
+
+test('Type preserves the key type union', () => {
+  expectTypeOf<
+    z.output<typeof z_SignatureEnvelope.Type>
+  >().toEqualTypeOf<core_SignatureEnvelope.Type>()
+})

package/src/zod/tempo/_test/SignatureEnvelope.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from 'vp/test'
+import * as core_SignatureEnvelope from '../../../tempo/SignatureEnvelope.js'
+import * as z_SignatureEnvelope from '../SignatureEnvelope.js'
+import * as z from 'zod/mini'
+
+const secp256k1 = {
+  r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+  s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+  type: 'secp256k1',
+  yParity: '0x0',
+} as const
+
+const p256 = {
+  preHash: false,
+  pubKeyX: '0x1ccbe91c075fc7f4f033bfa248db8fccd3565de94bbfb12f3c59ff46c271bf83',
+  pubKeyY: '0xce4014c68811f9a21a1fdb2c0e6113e06db7ca93b7404e78dc7ccd5ca89a4ca9',
+  r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+  s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+  type: 'p256',
+} as const
+
+describe('SignatureEnvelope', () => {
+  test('decodes a secp256k1 envelope', () => {
+    expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, secp256k1)).toEqual(
+      core_SignatureEnvelope.fromRpc(secp256k1),
+    )
+  })
+
+  test('decodes a p256 envelope', () => {
+    expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, p256)).toEqual(
+      core_SignatureEnvelope.fromRpc(p256),
+    )
+  })
+
+  test('decodes a recursive keychain envelope', () => {
+    const keychain = {
+      signature: secp256k1,
+      type: 'keychain',
+      userAddress: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+    } as const
+    expect(z.decode(z_SignatureEnvelope.SignatureEnvelope, keychain)).toEqual(
+      core_SignatureEnvelope.fromRpc(keychain),
+    )
+  })
+
+  test('round-trips secp256k1 via encode', () => {
+    const decoded = z.decode(z_SignatureEnvelope.SignatureEnvelope, secp256k1)
+    expect(z.encode(z_SignatureEnvelope.SignatureEnvelope, decoded)).toEqual(
+      core_SignatureEnvelope.toRpc(decoded),
+    )
+  })
+
+  test('rejects an invalid envelope', () => {
+    expect(
+      z.safeDecode(z_SignatureEnvelope.SignatureEnvelope, {
+        type: 'secp256k1',
+      } as never).success,
+    ).toBe(false)
+  })
+})

package/src/zod/tempo/_test/Tick.test-d.ts

@@ -0,0 +1,8 @@
+import type * as core_Tick from '../../../tempo/Tick.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_Tick from '../Tick.js'
+
+test('Tick schema preserves the tick type', () => {
+  expectTypeOf<z.output<typeof z_Tick.Tick>>().toEqualTypeOf<core_Tick.Tick>()
+})

package/src/zod/tempo/_test/Tick.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_Tick from '../Tick.js'
+import * as z from 'zod/mini'
+
+describe('Tick', () => {
+  test('accepts integers within bounds', () => {
+    expect(z.safeDecode(z_Tick.Tick, 0).success).toBe(true)
+    expect(z.safeDecode(z_Tick.Tick, 2000).success).toBe(true)
+    expect(z.safeDecode(z_Tick.Tick, -2000).success).toBe(true)
+  })
+
+  test('rejects out-of-bounds or non-integer ticks', () => {
+    expect(z.safeDecode(z_Tick.Tick, 2001).success).toMatchInlineSnapshot(
+      `false`,
+    )
+    expect(z.safeDecode(z_Tick.Tick, 1.5).success).toMatchInlineSnapshot(
+      `false`,
+    )
+  })
+})

package/src/zod/tempo/_test/TokenId.test-d.ts

@@ -0,0 +1,17 @@
+import type * as core_Address from '../../../core/Address.js'
+import type * as core_TokenId from '../../../tempo/TokenId.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_TokenId from '../TokenId.js'
+
+test('TokenId schemas preserve decoded and encoded types', () => {
+  expectTypeOf<
+    z.output<typeof z_TokenId.TokenId>
+  >().toEqualTypeOf<core_TokenId.TokenId>()
+  expectTypeOf<
+    z.output<typeof z_TokenId.address>
+  >().toEqualTypeOf<core_TokenId.TokenId>()
+  expectTypeOf<
+    z.input<typeof z_TokenId.address>
+  >().toEqualTypeOf<core_Address.Address>()
+})

package/src/zod/tempo/_test/TokenId.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_TokenId from '../TokenId.js'
+import * as z from 'zod/mini'
+
+describe('TokenId', () => {
+  test('accepts non-negative bigints', () => {
+    expect(z.safeDecode(z_TokenId.TokenId, 1n).success).toBe(true)
+    expect(z.safeDecode(z_TokenId.TokenId, -1n).success).toMatchInlineSnapshot(
+      `false`,
+    )
+  })
+
+  test('decodes and encodes token addresses', () => {
+    expect(
+      z.decode(z_TokenId.address, '0x20c0000000000000000000000000000000000001'),
+    ).toMatchInlineSnapshot(`1n`)
+    expect(z.encode(z_TokenId.address, 1n)).toMatchInlineSnapshot(
+      `"0x20c0000000000000000000000000000000000001"`,
+    )
+  })
+})

package/src/zod/tempo/_test/TokenRole.test-d.ts

@@ -0,0 +1,10 @@
+import type * as core_TokenRole from '../../../tempo/TokenRole.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_TokenRole from '../TokenRole.js'
+
+test('TokenRole schema preserves the role union', () => {
+  expectTypeOf<
+    z.output<typeof z_TokenRole.TokenRole>
+  >().toEqualTypeOf<core_TokenRole.TokenRole>()
+})

package/src/zod/tempo/_test/TokenRole.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_TokenRole from '../TokenRole.js'
+import * as z from 'zod/mini'
+
+describe('TokenRole', () => {
+  test('accepts known roles', () => {
+    expect(z.safeDecode(z_TokenRole.TokenRole, 'issuer').success).toBe(true)
+    expect(z.safeDecode(z_TokenRole.TokenRole, 'defaultAdmin').success).toBe(
+      true,
+    )
+  })
+
+  test('rejects unknown roles', () => {
+    expect(
+      z.safeDecode(z_TokenRole.TokenRole, 'unknown' as never).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+})

package/src/zod/tempo/_test/Transaction.test-d.ts

@@ -0,0 +1,10 @@
+import type * as core_Transaction from '../../../tempo/Transaction.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_Transaction from '../Transaction.js'
+
+test('Tempo decodes RPC into a tempo transaction', () => {
+  expectTypeOf<
+    z.output<typeof z_Transaction.Tempo>
+  >().toMatchTypeOf<core_Transaction.Tempo>()
+})

package/src/zod/tempo/_test/Transaction.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_Transaction from '../Transaction.js'
+import * as z from 'zod/mini'
+
+const rpc = {
+  accessList: [],
+  blockHash:
+    '0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b',
+  blockNumber: '0x12f296f',
+  blockTimestamp: '0x66434e07',
+  calls: [
+    {
+      input: '0xdeadbeef',
+      to: '0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad',
+      value: '0x9b6e64a8ec60000',
+    },
+  ],
+  chainId: '0x1',
+  feeToken: '0x20c0000000000000000000000000000000000000',
+  from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+  gas: '0x43f5d',
+  gasPrice: '0x2ca6ae494',
+  hash: '0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0',
+  maxFeePerGas: '0x2',
+  maxPriorityFeePerGas: '0x1',
+  nonce: '0x357',
+  signature: {
+    r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+    s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+    type: 'secp256k1',
+    v: '0x0',
+    yParity: '0x0',
+  },
+  transactionIndex: '0x2',
+  type: '0x76',
+} as const
+
+describe('Tempo', () => {
+  test('decodes a tempo transaction', () => {
+    const decoded = z.decode(z_Transaction.Tempo, rpc)
+    expect(decoded).toMatchObject({
+      blockNumber: 19868015n,
+      chainId: 1,
+      feeToken: '0x20c0000000000000000000000000000000000000',
+      from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+      gas: 278365n,
+      maxFeePerGas: 2n,
+      maxPriorityFeePerGas: 1n,
+      nonce: 855n,
+      transactionIndex: 2,
+      type: 'tempo',
+    })
+    expect(decoded.calls).toEqual([
+      {
+        data: '0xdeadbeef',
+        to: '0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad',
+        value: 700000000000000000n,
+      },
+    ])
+  })
+
+  test('round-trips via encode', () => {
+    const decoded = z.decode(z_Transaction.Tempo, rpc)
+    const encoded = z.encode(z_Transaction.Tempo, decoded)
+    expect(encoded).toMatchObject({
+      blockNumber: '0x12f296f',
+      chainId: '0x1',
+      from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+      gas: '0x43f5d',
+      maxFeePerGas: '0x2',
+      type: '0x76',
+    })
+  })
+})
+
+describe('Transaction', () => {
+  test('decodes a tempo transaction via the union', () => {
+    const decoded = z.decode(z_Transaction.Transaction, rpc)
+    expect(decoded).toMatchObject({ type: 'tempo' })
+  })
+
+  test('rejects an invalid transaction', () => {
+    expect(
+      z.safeDecode(z_Transaction.Transaction, { type: '0x76' } as never)
+        .success,
+    ).toBe(false)
+  })
+})

package/src/zod/tempo/_test/TransactionReceipt.test-d.ts

@@ -0,0 +1,13 @@
+import type * as core_TransactionReceipt from '../../../tempo/TransactionReceipt.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_TransactionReceipt from '../TransactionReceipt.js'
+
+test('TransactionReceipt decodes RPC into a tempo receipt', () => {
+  expectTypeOf<core_TransactionReceipt.Rpc>().toExtend<
+    z.input<typeof z_TransactionReceipt.TransactionReceipt>
+  >()
+  expectTypeOf<core_TransactionReceipt.TransactionReceipt>().toExtend<
+    z.output<typeof z_TransactionReceipt.TransactionReceipt>
+  >()
+})

package/src/zod/tempo/_test/TransactionReceipt.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'vp/test'
+import * as core_TransactionReceipt from '../../../tempo/TransactionReceipt.js'
+import * as z_TransactionReceipt from '../TransactionReceipt.js'
+import * as z from 'zod/mini'
+
+const rpc: core_TransactionReceipt.Rpc = {
+  blockHash:
+    '0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b',
+  blockNumber: '0x12f296f',
+  contractAddress: null,
+  cumulativeGasUsed: '0x82515',
+  effectiveGasPrice: '0x21c2f6c09',
+  feePayer: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+  feeToken: '0x20c0000000000000000000000000000000000001',
+  from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+  gasUsed: '0x2abba',
+  logs: [],
+  logsBloom: `0x${'00'.repeat(256)}`,
+  status: '0x1',
+  to: '0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad',
+  transactionHash:
+    '0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0',
+  transactionIndex: '0x2',
+  type: '0x76',
+}
+
+describe('TransactionReceipt', () => {
+  test('decodes a tempo receipt', () => {
+    const decoded = z.decode(z_TransactionReceipt.TransactionReceipt, rpc)
+    expect(decoded).toMatchObject({
+      blockNumber: 19868015n,
+      cumulativeGasUsed: 533781n,
+      effectiveGasPrice: 9062804489n,
+      feePayer: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+      feeToken: '0x20c0000000000000000000000000000000000001',
+      gasUsed: 175034n,
+      status: 'success',
+      transactionIndex: 2,
+      type: 'tempo',
+    })
+  })
+
+  test('round-trips a tempo receipt via encode', () => {
+    const decoded = z.decode(z_TransactionReceipt.TransactionReceipt, rpc)
+    expect(z.encode(z_TransactionReceipt.TransactionReceipt, decoded)).toEqual(
+      rpc,
+    )
+  })
+
+  test('decodes the tempo type', () => {
+    expect(z.decode(z_TransactionReceipt.Type, '0x76')).toBe('tempo')
+    expect(z.encode(z_TransactionReceipt.Type, 'tempo')).toBe('0x76')
+  })
+})

package/src/zod/tempo/_test/TransactionRequest.test-d.ts

@@ -0,0 +1,13 @@
+import type * as core_TransactionRequest from '../../../tempo/TransactionRequest.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_TransactionRequest from '../TransactionRequest.js'
+
+test('TransactionRequest decodes RPC into a tempo transaction request', () => {
+  expectTypeOf<core_TransactionRequest.Rpc>().toMatchTypeOf<
+    z.input<typeof z_TransactionRequest.TransactionRequest>
+  >()
+  expectTypeOf<
+    z.output<typeof z_TransactionRequest.TransactionRequest>
+  >().toMatchTypeOf<core_TransactionRequest.TransactionRequest>()
+})

package/src/zod/tempo/_test/TransactionRequest.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'vp/test'
+import * as core_TransactionRequest from '../../../tempo/TransactionRequest.js'
+import * as z_TransactionRequest from '../TransactionRequest.js'
+import * as z from 'zod/mini'
+
+const rpc = {
+  calls: [
+    {
+      data: '0xdeadbeef',
+      to: '0xcafebabecafebabecafebabecafebabecafebabe',
+      value: '0x9b6e64a8ec60000',
+    },
+  ],
+  chainId: '0x1',
+  feeToken: '0x20c0000000000000000000000000000000000000',
+  from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+  maxFeePerGas: '0x2',
+  type: '0x76',
+} as const
+
+describe('TransactionRequest', () => {
+  test('decodes an rpc tempo transaction request', () => {
+    const decoded = z.decode(z_TransactionRequest.TransactionRequest, rpc)
+    expect(decoded).toMatchObject({
+      chainId: 1,
+      feeToken: '0x20c0000000000000000000000000000000000000',
+      from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+      maxFeePerGas: 2n,
+      type: 'tempo',
+    })
+    expect(decoded.calls).toEqual([
+      {
+        data: '0xdeadbeef',
+        to: '0xcafebabecafebabecafebabecafebabecafebabe',
+        value: 700000000000000000n,
+      },
+    ])
+  })
+
+  test('round-trips via encode', () => {
+    const decoded = z.decode(z_TransactionRequest.TransactionRequest, rpc)
+    expect(z.encode(z_TransactionRequest.TransactionRequest, decoded)).toEqual(
+      core_TransactionRequest.toRpc(decoded),
+    )
+  })
+
+  test('rejects an invalid request', () => {
+    expect(
+      z.safeDecode(z_TransactionRequest.TransactionRequest, {
+        chainId: 1,
+      } as never).success,
+    ).toBe(false)
+  })
+})

package/src/zod/tempo/_test/TxEnvelopeTempo.test-d.ts

@@ -0,0 +1,16 @@
+import type * as core_TxEnvelopeTempo from '../../../tempo/TxEnvelopeTempo.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_TxEnvelopeTempo from '../TxEnvelopeTempo.js'
+
+test('TxEnvelopeTempo accepts a tempo transaction envelope', () => {
+  expectTypeOf<
+    z.output<typeof z_TxEnvelopeTempo.TxEnvelopeTempo>
+  >().toMatchTypeOf<core_TxEnvelopeTempo.TxEnvelopeTempo>()
+})
+
+test('Signed accepts a signed tempo transaction envelope', () => {
+  expectTypeOf<
+    z.output<typeof z_TxEnvelopeTempo.Signed>
+  >().toMatchTypeOf<core_TxEnvelopeTempo.Signed>()
+})

package/src/zod/tempo/_test/TxEnvelopeTempo.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from 'vp/test'
+import * as core_SignatureEnvelope from '../../../tempo/SignatureEnvelope.js'
+import * as core_TxEnvelopeTempo from '../../../tempo/TxEnvelopeTempo.js'
+import * as z_TxEnvelopeTempo from '../TxEnvelopeTempo.js'
+import * as z from 'zod/mini'
+
+const envelope = {
+  calls: [
+    {
+      to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+    },
+  ],
+  chainId: 1,
+  maxFeePerGas: 2_000_000_000n,
+  maxPriorityFeePerGas: 2_000_000_000n,
+  nonce: 785n,
+  nonceKey: 0n,
+  type: 'tempo',
+} as const
+
+const signature = core_SignatureEnvelope.from({
+  type: 'secp256k1',
+  signature: {
+    r: '0x635dc2033e60185bb36709c29c75d64ea51dfbd91c32ef4be198e4ceb169fb4d',
+    s: '0x50c2667ac4c771072746acfdcf1f1483336dcca8bd2df47cd83175dbe60f0540',
+    yParity: 0,
+  },
+})
+
+describe('TxEnvelopeTempo', () => {
+  test('validates an envelope', () => {
+    expect(
+      z.safeDecode(z_TxEnvelopeTempo.TxEnvelopeTempo, envelope).success,
+    ).toBe(true)
+  })
+
+  test('validates a signed envelope', () => {
+    expect(
+      z.safeDecode(z_TxEnvelopeTempo.Signed, { ...envelope, signature })
+        .success,
+    ).toBe(true)
+  })
+
+  test('rejects a signed envelope missing the signature', () => {
+    expect(
+      z.safeDecode(z_TxEnvelopeTempo.Signed, envelope as never).success,
+    ).toBe(false)
+  })
+
+  test('rejects an invalid envelope', () => {
+    expect(
+      z.safeDecode(z_TxEnvelopeTempo.TxEnvelopeTempo, {
+        type: 'tempo',
+      } as never).success,
+    ).toBe(false)
+  })
+
+  test('decodes the tempo type literal', () => {
+    expect(z.decode(z_TxEnvelopeTempo.Type, 'tempo')).toBe('tempo')
+  })
+})
+
+describe('serialized', () => {
+  test('decodes a serialized envelope', () => {
+    const signed = core_TxEnvelopeTempo.from(envelope, { signature })
+    const serialized = core_TxEnvelopeTempo.serialize(signed)
+    expect(z.decode(z_TxEnvelopeTempo.serialized, serialized)).toMatchObject({
+      chainId: 1,
+      type: 'tempo',
+    })
+  })
+
+  test('round-trips a serialized envelope via encode', () => {
+    const signed = core_TxEnvelopeTempo.from(envelope, { signature })
+    const serialized = core_TxEnvelopeTempo.serialize(signed)
+    const decoded = z.decode(z_TxEnvelopeTempo.serialized, serialized)
+    expect(z.encode(z_TxEnvelopeTempo.serialized, decoded)).toBe(serialized)
+  })
+})

package/src/zod/tempo/_test/VirtualAddress.test-d.ts

@@ -0,0 +1,13 @@
+import type * as core_Address from '../../../core/Address.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_VirtualAddress from '../VirtualAddress.js'
+
+test('VirtualAddress schemas preserve decoded types', () => {
+  expectTypeOf<
+    z.output<typeof z_VirtualAddress.VirtualAddress>
+  >().toEqualTypeOf<core_Address.Address>()
+  expectTypeOf<
+    z.output<typeof z_VirtualAddress.from>
+  >().toEqualTypeOf<core_Address.Address>()
+})

package/src/zod/tempo/_test/VirtualAddress.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_VirtualAddress from '../VirtualAddress.js'
+import * as z from 'zod/mini'
+
+const address = '0x58e21090fdfdfdfdfdfdfdfdfdfd010203040506'
+
+describe('VirtualAddress', () => {
+  test('accepts valid virtual addresses', () => {
+    expect(z.safeDecode(z_VirtualAddress.VirtualAddress, address).success).toBe(
+      true,
+    )
+  })
+
+  test('rejects non-virtual addresses', () => {
+    expect(
+      z.safeDecode(
+        z_VirtualAddress.VirtualAddress,
+        '0x0000000000000000000000000000000000000000',
+      ).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+
+  test('decodes and encodes parts', () => {
+    expect(
+      z.decode(z_VirtualAddress.from, {
+        masterId: '0x58e21090',
+        userTag: '0x010203040506',
+      }),
+    ).toMatchInlineSnapshot(`"0x58e21090fdfdfdfdfdfdfdfdfdfd010203040506"`)
+    expect(z.encode(z_VirtualAddress.from, address)).toMatchInlineSnapshot(`
+      {
+        "masterId": "0x58e21090",
+        "userTag": "0x010203040506",
+      }
+    `)
+  })
+})

package/src/zod/tempo/_test/ZoneId.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_ZoneId from '../ZoneId.js'
+import * as z from 'zod/mini'
+
+describe('ZoneId', () => {
+  test('accepts non-negative integers', () => {
+    expect(z.safeDecode(z_ZoneId.ZoneId, 6).success).toBe(true)
+    expect(z.safeDecode(z_ZoneId.ZoneId, -1).success).toMatchInlineSnapshot(
+      `false`,
+    )
+  })
+
+  test('decodes and encodes chain ids', () => {
+    expect(z.decode(z_ZoneId.chainId, 4_217_000_006)).toMatchInlineSnapshot(`6`)
+    expect(z.encode(z_ZoneId.chainId, 6)).toMatchInlineSnapshot(`4217000006`)
+  })
+})

package/src/zod/tempo/_test/ZoneRpcAuthentication.test-d.ts

@@ -0,0 +1,16 @@
+import type * as core_ZoneRpcAuthentication from '../../../tempo/ZoneRpcAuthentication.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_ZoneRpcAuthentication from '../ZoneRpcAuthentication.js'
+
+test('Signed validates a signed Zone RPC authentication token', () => {
+  expectTypeOf<core_ZoneRpcAuthentication.Signed>().toExtend<
+    z.output<typeof z_ZoneRpcAuthentication.Signed>
+  >()
+})
+
+test('serialized decodes a serialized token into a signed token', () => {
+  expectTypeOf<core_ZoneRpcAuthentication.Signed>().toExtend<
+    z.output<typeof z_ZoneRpcAuthentication.serialized>
+  >()
+})