ox 1.0.0-beta.2 → 1.0.0-beta.20

package/src/zod/_test/Abi.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, test } from 'vp/test'
+import * as z_Abi from '../Abi.js'
+import * as z_AbiConstructor from '../AbiConstructor.js'
+import * as z_AbiFunction from '../AbiFunction.js'
+import * as z_AbiParameter from '../AbiParameter.js'
+import * as z_Solidity from '../Solidity.js'
+import * as z from 'zod/mini'
+
+describe('Abi', () => {
+  test('decodes ABI items and normalizes legacy mutability fields', () => {
+    const input = [
+      {
+        constant: true,
+        inputs: [{ name: 'owner', type: 'address' }],
+        name: 'balanceOf',
+        outputs: [{ name: 'balance', type: 'uint256' }],
+        type: 'function',
+      },
+      {
+        inputs: [{ name: 'owner', type: 'address' }],
+        payable: true,
+        type: 'constructor',
+      },
+      {
+        payable: false,
+        type: 'fallback',
+      },
+    ] as const
+
+    expect(z.decode(z_Abi.Abi, input)).toMatchInlineSnapshot(`
+      [
+        {
+          "constant": true,
+          "inputs": [
+            {
+              "name": "owner",
+              "type": "address",
+            },
+          ],
+          "name": "balanceOf",
+          "outputs": [
+            {
+              "name": "balance",
+              "type": "uint256",
+            },
+          ],
+          "stateMutability": "view",
+          "type": "function",
+        },
+        {
+          "inputs": [
+            {
+              "name": "owner",
+              "type": "address",
+            },
+          ],
+          "payable": true,
+          "stateMutability": "payable",
+          "type": "constructor",
+        },
+        {
+          "payable": false,
+          "stateMutability": "nonpayable",
+          "type": "fallback",
+        },
+      ]
+    `)
+    expect(input[0]).not.toHaveProperty('stateMutability')
+  })
+
+  test('strips unknown keys', () => {
+    const input: unknown = {
+      type: 'function',
+      inputs: [],
+      name: 'totalSupply',
+      outputs: [{ type: 'uint256', extra: true }],
+      stateMutability: 'view',
+      extra: true,
+    }
+
+    expect(z.parse(z_AbiFunction.AbiFunction, input)).toMatchInlineSnapshot(`
+      {
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+          {
+            "type": "uint256",
+          },
+        ],
+        "stateMutability": "view",
+        "type": "function",
+      }
+    `)
+  })
+
+  test('decodes tuple parameters recursively', () => {
+    expect(
+      z.decode(z_AbiParameter.AbiParameter, {
+        name: 'foo',
+        type: 'tuple[]',
+        components: [
+          { name: 'owner', type: 'address' },
+          { name: 'ids', type: 'uint256[]' },
+        ],
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "components": [
+          {
+            "name": "owner",
+            "type": "address",
+          },
+          {
+            "name": "ids",
+            "type": "uint256[]",
+          },
+        ],
+        "name": "foo",
+        "type": "tuple[]",
+      }
+    `)
+  })
+
+  test('rejects invalid parameter types', () => {
+    expect(
+      z.safeDecode(z_AbiParameter.AbiParameter, { type: 'notAValidType' })
+        .success,
+    ).toBe(false)
+  })
+
+  test('decodes constructors with explicit mutability', () => {
+    expect(
+      z.decode(z_AbiConstructor.AbiConstructor, {
+        type: 'constructor',
+        inputs: [],
+        payable: true,
+        stateMutability: 'nonpayable',
+      }),
+    ).toMatchInlineSnapshot(`
+      {
+        "inputs": [],
+        "payable": true,
+        "stateMutability": "nonpayable",
+        "type": "constructor",
+      }
+    `)
+  })
+})
+
+describe('Solidity', () => {
+  test('decodes Solidity type tokens', () => {
+    expect(z.decode(z_Solidity.Address, 'address')).toMatchInlineSnapshot(
+      `"address"`,
+    )
+    expect(z.decode(z_Solidity.Int, 'uint256')).toMatchInlineSnapshot(
+      `"uint256"`,
+    )
+    expect(z.decode(z_Solidity.Array, 'tuple[2][]')).toMatchInlineSnapshot(
+      `"tuple[2][]"`,
+    )
+    expect(z.safeDecode(z_Solidity.Bytes, 'bytes33').success).toBe(false)
+  })
+})

package/src/zod/_test/AccountProof.test.ts

@@ -81,6 +81,38 @@ describe('AccountProof', () => {
     `)
   })
 
+  test('AccountProofToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      ...proof,
+      balance: 1n,
+      nonce: 2,
+      storageProof: [
+        { key: proof.storageProof[0].key, proof: ['0xdead'], value: 3n },
+      ],
+    } as const
+    const expected = z.encode(z_AccountProof.AccountProof, decoded)
+
+    expect(
+      z.encode(z_AccountProof.AccountProofToRpc, {
+        ...decoded,
+        balance: 1,
+        storageProof: [
+          { key: proof.storageProof[0].key, proof: ['0xdead'], value: 3 },
+        ],
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_AccountProof.AccountProofToRpc, {
+        ...decoded,
+        balance: '0x1',
+        nonce: '0x2',
+        storageProof: [
+          { key: proof.storageProof[0].key, proof: ['0xdead'], value: '0x3' },
+        ],
+      }),
+    ).toEqual(expected)
+  })
+
   test('validates storage proofs', () => {
     expect(z.decode(z_AccountProof.StorageProof, proof.storageProof[0]))
       .toMatchInlineSnapshot(`

package/src/zod/_test/Authorization.test.ts

@@ -77,6 +77,48 @@ describe('Authorization', () => {
     `)
   })
 
+  test('AuthorizationToRpc accepts numberish encode inputs', () => {
+    const expected = {
+      address,
+      chainId: '0x1',
+      nonce: '0x2',
+      r,
+      s,
+      yParity: '0x1',
+    }
+
+    expect(
+      z.encode(z_Authorization.SignedToRpc, {
+        address,
+        chainId: 1,
+        nonce: 2n,
+        r,
+        s,
+        yParity: 1,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_Authorization.SignedToRpc, {
+        address,
+        chainId: 1,
+        nonce: 2,
+        r,
+        s,
+        yParity: 1,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_Authorization.SignedToRpc, {
+        address,
+        chainId: '0x1',
+        nonce: '0x2',
+        r,
+        s,
+        yParity: 1,
+      }),
+    ).toEqual(expected)
+  })
+
   test('validates lists and tuples', () => {
     expect(
       z.decode(z_Authorization.ListSigned, [

package/src/zod/_test/BigInt.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from 'vp/test'
+import { describe, expect, test } from 'vp/test'
 import * as z_BigInt from '../BigInt.js'
 import * as z from 'zod/mini'
 
@@ -7,3 +7,11 @@ test('BigInt decodes and encodes hex quantities', () => {
   expect(z.encode(z_BigInt.BigInt, 42n)).toMatchInlineSnapshot(`"0x2a"`)
   expect(z.safeDecode(z_BigInt.BigInt, '0x').success).toBe(false)
 })
+
+describe('BigIntToRpc', () => {
+  test('accepts numberish encode inputs', () => {
+    expect(z.encode(z_BigInt.BigIntToRpc, 42n)).toBe('0x2a')
+    expect(z.encode(z_BigInt.BigIntToRpc, 42)).toBe('0x2a')
+    expect(z.encode(z_BigInt.BigIntToRpc, '0x2a')).toBe('0x2a')
+  })
+})

package/src/zod/_test/Block.test.ts

@@ -203,6 +203,60 @@ describe('Block', () => {
     ).toMatchObject({ hash: null, number: null })
   })
 
+  test('BlockToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      baseFeePerGas: 1n,
+      blobGasUsed: 2n,
+      difficulty: 3n,
+      excessBlobGas: 4n,
+      extraData: '0x',
+      gasLimit: 5n,
+      gasUsed: 6n,
+      hash,
+      logsBloom: '0x',
+      miner: address,
+      mixHash: hash,
+      nonce: '0x0000000000000000',
+      number: 7n,
+      parentBeaconBlockRoot: hash,
+      parentHash: hash,
+      receiptsRoot: hash,
+      sealFields: [hash, '0x0000000000000000'],
+      sha3Uncles: hash,
+      size: 8n,
+      stateRoot: hash,
+      timestamp: 9n,
+      totalDifficulty: 10n,
+      transactions: [hash2],
+      transactionsRoot: hash,
+      uncles: [hash2],
+      withdrawals: [{ address, amount: 11n, index: 12, validatorIndex: 13 }],
+      withdrawalsRoot: hash,
+    } as const
+    const expected = z.encode(z_Block.Block, decoded)
+
+    expect(
+      z.encode(z_Block.BlockToRpc, {
+        ...decoded,
+        baseFeePerGas: 1,
+        gasLimit: 5,
+        number: 7,
+        size: 8,
+        timestamp: 9,
+        totalDifficulty: 10,
+        withdrawals: [{ address, amount: 11, index: 12, validatorIndex: 13 }],
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_Block.BlockToRpc, {
+        ...decoded,
+        baseFeePerGas: '0x1',
+        gasLimit: '0x5',
+        number: '0x7',
+      }),
+    ).toEqual(expected)
+  })
+
   test('decodes identifiers and rejects invalid blocks', () => {
     expect(
       z.decode(z_Block.Identifier, {

package/src/zod/_test/BlockOverrides.test.ts

@@ -82,6 +82,41 @@ describe('BlockOverrides', () => {
     `)
   })
 
+  test('BlockOverridesToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      baseFeePerGas: 1n,
+      blobBaseFee: 2n,
+      feeRecipient: address,
+      gasLimit: 3n,
+      number: 4n,
+      prevRandao: 5n,
+      time: 6n,
+      withdrawals: [{ address, amount: 7n, index: 0, validatorIndex: 1 }],
+    } as const
+    const expected = z.encode(z_BlockOverrides.BlockOverrides, {
+      ...decoded,
+      withdrawals: [{ address, amount: 7n, index: 0, validatorIndex: 1 }],
+    })
+
+    expect(
+      z.encode(z_BlockOverrides.BlockOverridesToRpc, {
+        ...decoded,
+        baseFeePerGas: 1,
+        gasLimit: 3,
+        time: 6,
+        withdrawals: [{ address, amount: 7, index: 0, validatorIndex: 1 }],
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_BlockOverrides.BlockOverridesToRpc, {
+        ...decoded,
+        baseFeePerGas: '0x1',
+        number: '0x4',
+        withdrawals: [{ address, amount: '0x7', index: 0, validatorIndex: 1 }],
+      }),
+    ).toEqual(expected)
+  })
+
   test('rejects invalid nested withdrawals', () => {
     expect(
       z.safeDecode(z_BlockOverrides.BlockOverrides, {

package/src/zod/_test/Filter.test.ts

@@ -74,6 +74,40 @@ describe('Filter', () => {
     `)
   })
 
+  test('FilterToRpc accepts numberish encode inputs', () => {
+    const expected = {
+      address: [address, address2],
+      fromBlock: 'latest',
+      toBlock: '0x10f2c',
+      topics: [topic, null, [topic2]],
+    }
+
+    expect(
+      z.encode(z_Filter.FilterToRpc, {
+        address: [address, address2],
+        fromBlock: 'latest',
+        toBlock: 69420n,
+        topics: [topic, null, [topic2]],
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_Filter.FilterToRpc, {
+        address: [address, address2],
+        fromBlock: 'latest',
+        toBlock: 69420,
+        topics: [topic, null, [topic2]],
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_Filter.FilterToRpc, {
+        address: [address, address2],
+        fromBlock: 'latest',
+        toBlock: '0x10f2c',
+        topics: [topic, null, [topic2]],
+      }),
+    ).toEqual(expected)
+  })
+
   test('rejects invalid filters', () => {
     const invalidBlockRange: never = {
       blockHash,

package/src/zod/_test/Log.test.ts

@@ -101,6 +101,55 @@ describe('Log', () => {
     `)
   })
 
+  test('LogToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      address,
+      blockHash,
+      blockNumber: 19760236n,
+      blockTimestamp: 1n,
+      data: '0xdeadbeef',
+      logIndex: 271,
+      topics: [topic],
+      transactionHash,
+      transactionIndex: 145,
+      removed: false,
+    } as const
+    const expected = z.encode(z_Log.Log, { ...decoded, topics: [topic] })
+
+    expect(
+      z.encode(z_Log.LogToRpc, {
+        ...decoded,
+        topics: [topic],
+        blockNumber: 19760236,
+        blockTimestamp: 1,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_Log.LogToRpc, {
+        ...decoded,
+        topics: [topic],
+        blockNumber: '0x12d846c',
+        blockTimestamp: '0x1',
+      }),
+    ).toEqual(expected)
+  })
+
+  test('decodes logs with no topics', () => {
+    expect(
+      z.decode(z_Log.Log, {
+        address,
+        blockHash,
+        blockNumber: '0x12d846c',
+        data: '0xdeadbeef',
+        logIndex: '0x10f',
+        topics: [],
+        transactionHash,
+        transactionIndex: '0x91',
+        removed: false,
+      }).topics,
+    ).toEqual([])
+  })
+
   test('rejects invalid topics and quantities', () => {
     expect(
       z.safeDecode(z_Log.Log, {

package/src/zod/_test/Number.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from 'vp/test'
+import { describe, expect, test } from 'vp/test'
 import * as z_Number from '../Number.js'
 import * as z from 'zod/mini'
 
@@ -9,3 +9,10 @@ test('Number decodes and encodes hex quantities', () => {
     z.safeEncode(z_Number.Number, Number.MAX_SAFE_INTEGER + 1).success,
   ).toBe(false)
 })
+
+describe('NumberToRpc', () => {
+  test('accepts numberish encode inputs', () => {
+    expect(z.encode(z_Number.NumberToRpc, 42)).toBe('0x2a')
+    expect(z.encode(z_Number.NumberToRpc, '0x2a')).toBe('0x2a')
+  })
+})

package/src/zod/_test/RpcSchema.test-d.ts

@@ -65,6 +65,52 @@ test('encode helpers infer params/returns by method', () => {
   expectTypeOf(
     z_RpcSchema.encodeReturns(z_RpcSchema.Eth, 'eth_blockNumber', 436n),
   ).toEqualTypeOf<core_Hex.Hex>()
+
+  // Params: block selector encodes to the wire shape. The EIP-1898 identifier
+  // branch must encode `blockNumber` as wire hex (matching the core request
+  // param type `Block.Identifier<Hex.Hex>`), not native bigint.
+  expectTypeOf(
+    z_RpcSchema.encodeParams(z_RpcSchema.Eth, 'eth_getTransactionCount', [
+      '0x0000000000000000000000000000000000000000',
+      { blockNumber: 436n },
+    ]),
+  ).toMatchTypeOf<
+    readonly [
+      core_Address.Address,
+      (
+        | core_Block.Number<core_Hex.Hex>
+        | core_Block.Tag
+        | core_Block.Identifier<core_Hex.Hex>
+      ),
+    ]
+  >()
+})
+
+test('codecs accept a resolved item and infer params/returns', () => {
+  const item = z_RpcSchema.parseItem(z_RpcSchema.Eth, 'eth_getTransactionCount')
+
+  // Params: native on encode input, wire on encode output.
+  expectTypeOf(
+    z_RpcSchema.encodeParams(item, [
+      '0x0000000000000000000000000000000000000000',
+      { blockNumber: 436n },
+    ]),
+  ).toMatchTypeOf<
+    readonly [
+      core_Address.Address,
+      (
+        | core_Block.Number<core_Hex.Hex>
+        | core_Block.Tag
+        | core_Block.Identifier<core_Hex.Hex>
+      ),
+    ]
+  >()
+
+  // Returns: wire hex on decode input, native number on decode output.
+  expectTypeOf(z_RpcSchema.decodeReturns(item, '0x1b4')).toEqualTypeOf<number>()
+  expectTypeOf(
+    z_RpcSchema.encodeReturns(item, 436),
+  ).toEqualTypeOf<core_Hex.Hex>()
 })
 
 test('from: namespace returns a decodable namespace', () => {

package/src/zod/_test/RpcSchema.test.ts

@@ -162,6 +162,57 @@ describe('encodeParams', () => {
       ]
     `)
   })
+
+  test('encodes eth_call request params with numberish quantities', () => {
+    expect(
+      z_RpcSchema.encodeParams(z_RpcSchema.Eth, 'eth_call', [
+        {
+          gas: '0x2dc6c0',
+          maxFeePerGas: 100_000_000_000n,
+          maxPriorityFeePerGas: 1,
+          nonce: 0,
+          to: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+          value: '0x0',
+        },
+        'latest',
+      ]),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "gas": "0x2dc6c0",
+          "maxFeePerGas": "0x174876e800",
+          "maxPriorityFeePerGas": "0x1",
+          "nonce": "0x0",
+          "to": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2",
+          "value": "0x0",
+        },
+        "latest",
+      ]
+    `)
+  })
+
+  test('encodes eth_call request params with state + block overrides', () => {
+    expect(
+      z_RpcSchema.encodeParams(z_RpcSchema.Eth, 'eth_call', [
+        { to: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2', value: 1n },
+        'latest',
+        {},
+        { number: 420n },
+      ]),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "to": "0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2",
+          "value": "0x1",
+        },
+        "latest",
+        {},
+        {
+          "number": "0x1a4",
+        },
+      ]
+    `)
+  })
 })
 
 describe('encodeReturns', () => {
@@ -211,6 +262,25 @@ describe('parseItem', () => {
       `[RpcSchema.MethodNotFoundError: Method \`eth_unknownMethod\` does not exist on the schema.]`,
     )
   })
+
+  test('codecs accept a resolved item', () => {
+    const item = z_RpcSchema.parseItem(
+      z_RpcSchema.Eth,
+      'eth_getBlockTransactionCountByNumber',
+    )
+    expect(z_RpcSchema.encodeParams(item, [1n])).toMatchInlineSnapshot(`
+      [
+        "0x1",
+      ]
+    `)
+    expect(z_RpcSchema.decodeParams(item, ['0x1'])).toMatchInlineSnapshot(`
+      [
+        1n,
+      ]
+    `)
+    expect(z_RpcSchema.decodeReturns(item, '0x1')).toMatchInlineSnapshot(`1`)
+    expect(z_RpcSchema.encodeReturns(item, 1)).toMatchInlineSnapshot(`"0x1"`)
+  })
 })
 
 describe('decodeRequest', () => {

package/src/zod/_test/Signature.test.ts

@@ -25,6 +25,16 @@ describe('Signature', () => {
       `)
   })
 
+  test('SignatureToRpc accepts numberish encode inputs', () => {
+    const expected = { r, s, yParity: '0x1' }
+    expect(z.encode(z_Signature.SignatureToRpc, { r, s, yParity: 1 })).toEqual(
+      expected,
+    )
+    expect(
+      z.encode(z_Signature.SignatureToRpc, { r, s, yParity: '0x1' }),
+    ).toEqual(expected)
+  })
+
   test('validates signature variants', () => {
     expect(z.decode(z_Signature.Legacy, { r, s, v: '0x1b' }))
       .toMatchInlineSnapshot(`

package/src/zod/_test/StateOverrides.test.ts

@@ -65,6 +65,32 @@ describe('StateOverrides', () => {
     `)
   })
 
+  test('AccountOverridesToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      balance: 1n,
+      code: '0xdeadbeef',
+      movePrecompileToAddress: movedAddress,
+      nonce: 2n,
+      stateDiff: { [slot]: value },
+    } as const
+    const expected = z.encode(z_StateOverrides.AccountOverrides, decoded)
+
+    expect(
+      z.encode(z_StateOverrides.AccountOverridesToRpc, {
+        ...decoded,
+        balance: 1,
+        nonce: 2,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_StateOverrides.AccountOverridesToRpc, {
+        ...decoded,
+        balance: '0x1',
+        nonce: '0x2',
+      }),
+    ).toEqual(expected)
+  })
+
   test('rejects invalid addresses and storage keys', () => {
     expect(
       z.safeDecode(z_StateOverrides.StateOverrides, {