ox 1.8.1 → 1.8.3

package/src/zod/TransactionRequest.ts

@@ -2,7 +2,7 @@
 import * as z_AccessList from './AccessList.js'
 import * as z_Address from './Address.js'
 import * as z_Authorization from './Authorization.js'
-import * as z_Frame from './Frame.js'
+import * as z_FrameRequest from './FrameRequest.js'
 import * as z_FrameSignature from './FrameSignature.js'
 import * as z_Hex from './Hex.js'
 import * as z_Number from './Number.js'
@@ -38,7 +38,7 @@ export const TransactionRequest = z.object(
     z_Uint.Uint,
     z_Number.Number,
     z_Authorization.ListSigned,
-    z_Frame.Frame,
+    z_FrameRequest.FrameRequest,
   ),
 )
 
@@ -48,7 +48,7 @@ export const TransactionRequestToRpc = z.object(
     z_Uint.UintToRpc,
     z_Number.NumberToRpc,
     z_Authorization.ListSignedToRpc,
-    z_Frame.FrameToRpc,
+    z_FrameRequest.FrameRequestToRpc,
   ),
 )
 

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

@@ -5,25 +5,25 @@ import { describe, expect, test } from 'vp/test'
 describe('Frame', () => {
   test('decodes RPC budgets and encodes named flags', () => {
     const frame = Frame.from({
+      executionGas: 50_000n,
       flags: 'approveExecutionAndPayment',
-      gas: 50_000n,
       mode: 'verify',
       to: '0x1111111111111111111111111111111111111111',
     })
     const rpc = z.encode(z.Frame.Frame, frame)
     expect(rpc).toEqual({
       data: '0x',
-      executionGasLimit: '0xc350',
-      flags: 3,
-      mode: 1,
-      stateGasLimit: '0x0',
+      executionGas: '0xc350',
+      flags: '0x3',
+      mode: '0x1',
+      stateGas: '0x0',
       target: '0x1111111111111111111111111111111111111111',
       value: '0x0',
     })
     expect(z.decode(z.Frame.Frame, rpc)).toEqual({
       data: '0x',
+      executionGas: 50_000n,
       flags: 3,
-      gas: 50_000n,
       mode: 1,
       stateGas: 0n,
       to: '0x1111111111111111111111111111111111111111',
@@ -32,12 +32,14 @@ describe('Frame', () => {
   })
   test('rejects invalid mode and budget', () => {
     expect(z.safeParse(z.Frame.Decoded, { mode: 3 }).success).toBe(false)
-    expect(z.safeParse(z.Frame.Decoded, { gas: -1n }).success).toBe(false)
+    expect(z.safeParse(z.Frame.Decoded, { executionGas: -1n }).success).toBe(
+      false,
+    )
   })
   test('encodes numberish values', () => {
     expect(
-      z.encode(z.Frame.FrameToRpc, { gas: '0xc350', stateGas: 0 })
-        .executionGasLimit,
+      z.encode(z.Frame.FrameToRpc, { executionGas: '0xc350', stateGas: 0 })
+        .executionGas,
     ).toBe('0xc350')
   })
 })
@@ -46,9 +48,9 @@ describe('FrameToRpc validation', () => {
   test.each([
     { mode: 3 },
     { flags: 8 },
-    { gas: 2n ** 64n },
+    { executionGas: 2n ** 64n },
     { stateGas: -1 },
-    { gas: '0x10000000000000000' },
+    { executionGas: '0x10000000000000000' },
   ])('rejects invalid frame %#', (frame) => {
     expect(
       z.safeEncode(z.Frame.FrameToRpc, frame as Frame.toRpc.Input).success,

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

@@ -7,13 +7,15 @@ describe('FrameReceipt', () => {
     expect(
       z.safeDecode(z.FrameReceipt.FrameReceipt, {
         executionGasUsed: '0x',
+        gasUsed: '0x',
         logs: [],
         stateGasUsed: '0x0',
-        status: 1,
+        status: '0x1',
       }).success,
     ).toBe(false)
     expect(
       z.safeEncode(z.FrameReceipt.FrameReceipt, {
+        executionGasUsed: 0n,
         gasUsed: -1n,
         logs: [],
         stateGasUsed: 0n,
@@ -23,6 +25,7 @@ describe('FrameReceipt', () => {
     for (const gasUsed of [-1, Number.MAX_SAFE_INTEGER + 1, '0x'] as const)
       expect(
         z.safeEncode(z.FrameReceipt.FrameReceiptToRpc, {
+          executionGasUsed: 0n,
           gasUsed,
           logs: [],
           stateGasUsed: 0n,
@@ -34,9 +37,10 @@ describe('FrameReceipt', () => {
   test('roundtrip', () => {
     const rpc = {
       executionGasUsed: '0x20000000000001',
+      gasUsed: '0x20000000000001',
       logs: [],
       stateGasUsed: '0x0',
-      status: 2,
+      status: '0x2',
     } as const
     const receipt = FrameReceipt.fromRpc(rpc)
     expect(z.decode(z.FrameReceipt.FrameReceipt, rpc)).toEqual(receipt)
@@ -47,10 +51,11 @@ describe('FrameReceipt', () => {
     expect(
       z.safeDecode(z.FrameReceipt.FrameReceipt, {
         executionGasUsed: '0x0',
+        gasUsed: '0x0',
         logs: [],
         stateGasUsed: '0x0',
         // @ts-expect-error Invalid RPC status.
-        status: 3,
+        status: '0x3',
       }).success,
     ).toBe(false)
   })
@@ -60,6 +65,7 @@ describe('FrameReceiptToRpc', () => {
   test('numberish gas', () => {
     expect(
       z.encode(z.FrameReceipt.FrameReceiptToRpc, {
+        executionGasUsed: 21000,
         gasUsed: 21000,
         logs: [],
         stateGasUsed: '0x0',
@@ -67,9 +73,10 @@ describe('FrameReceiptToRpc', () => {
       }),
     ).toEqual({
       executionGasUsed: '0x5208',
+      gasUsed: '0x5208',
       logs: [],
       stateGasUsed: '0x0',
-      status: 1,
+      status: '0x1',
     })
   })
 })

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

@@ -0,0 +1,15 @@
+import type { FrameRequest } from 'ox'
+import { z } from 'ox/zod'
+import { expectTypeOf, test } from 'vp/test'
+
+test('public frame request codecs preserve input and output types', () => {
+  expectTypeOf<
+    z.input<typeof z.FrameRequest.FrameRequest>
+  >().toEqualTypeOf<FrameRequest.Rpc>()
+  expectTypeOf<
+    z.output<typeof z.FrameRequest.FrameRequest>
+  >().toEqualTypeOf<FrameRequest.FrameRequest>()
+  expectTypeOf<
+    z.output<typeof z.FrameRequest.FrameRequestToRpc>
+  >().toEqualTypeOf<FrameRequest.toRpc.Input>()
+})

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

@@ -0,0 +1,44 @@
+import { z } from 'ox/zod'
+import { describe, expect, test } from 'vp/test'
+
+describe('FrameRequest', () => {
+  test('round-trips omitted gas through the public codec', () => {
+    const frame = z.decode(z.FrameRequest.FrameRequest, {
+      mode: '0x2',
+      stateGas: '0x0',
+    })
+    expect(frame).toEqual({
+      mode: 2,
+      flags: 0,
+      stateGas: 0n,
+      value: 0n,
+      data: '0x',
+    })
+    expect(z.encode(z.FrameRequest.FrameRequest, frame)).toEqual({
+      mode: '0x2',
+      flags: '0x0',
+      stateGas: '0x0',
+      value: '0x0',
+      data: '0x',
+    })
+  })
+})
+
+describe('FrameRequestToRpc', () => {
+  test('encodes numberish values through the public codec', () => {
+    expect(
+      z.encode(z.FrameRequest.FrameRequestToRpc, {
+        mode: 'sender',
+        executionGas: 50000,
+        stateGas: '0x0',
+      }),
+    ).toEqual({
+      mode: '0x2',
+      flags: '0x0',
+      executionGas: '0xc350',
+      stateGas: '0x0',
+      value: '0x0',
+      data: '0x',
+    })
+  })
+})

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

@@ -1,4 +1,4 @@
-import { FrameSignature, P256, Secp256k1, Hash } from 'ox'
+import { FrameSignature, P256, Secp256k1, Hash, Signature } from 'ox'
 import { z } from 'ox/zod'
 import { describe, expect, test } from 'vp/test'
 import { accounts } from '../../../test/constants/accounts.js'
@@ -8,7 +8,7 @@ describe('FrameSignature', () => {
     expect(
       z.safeDecode(z.FrameSignature.FrameSignature, {
         msg: '0x',
-        scheme: 1,
+        scheme: '0x1',
         signature: '0x01',
       }).success,
     ).toBe(false)
@@ -20,27 +20,27 @@ describe('FrameSignature', () => {
         scheme: 'arbitrary',
         signature: '0xaabb',
       }),
-    ).toEqual({ msg: '0x', scheme: 0, signature: '0xaabb' })
+    ).toEqual({ msg: '0x', scheme: '0x0', signature: '0xaabb' })
     expect(
       z.encode(z.FrameSignature.FrameSignature, {
         scheme: 'secp256k1',
       }),
-    ).toEqual({ msg: '0x', scheme: 1, signature: '0x' })
+    ).toEqual({ msg: '0x', scheme: '0x1' })
     expect(
       z.encode(z.FrameSignature.FrameSignature, {
         scheme: 'p256',
       }),
-    ).toEqual({ msg: '0x', scheme: 2, signature: '0x' })
+    ).toEqual({ msg: '0x', scheme: '0x2' })
   })
 
   test('arbitrary bytes', () => {
     expect(
       z.encode(z.FrameSignature.FrameSignature, FrameSignature.from('0xaabb')),
-    ).toEqual({ msg: '0x', scheme: 0, signature: '0xaabb' })
+    ).toEqual({ msg: '0x', scheme: '0x0', signature: '0xaabb' })
     expect(
       z.decode(z.FrameSignature.FrameSignature, {
         msg: '0x',
-        scheme: 0,
+        scheme: '0x0',
         signature: '0xaabb',
       }),
     ).toEqual(FrameSignature.from('0xaabb'))
@@ -54,7 +54,7 @@ describe('FrameSignature', () => {
       }),
     })
     const rpc = z.encode(z.FrameSignature.FrameSignature, entry)
-    expect(rpc.scheme).toBe(1)
+    expect(rpc.scheme).toBe('0x1')
     expect(z.decode(z.FrameSignature.FrameSignature, rpc)).toEqual(entry)
   })
   test('P-256 signature', () => {
@@ -68,7 +68,7 @@ describe('FrameSignature', () => {
       }),
     })
     const rpc = z.encode(z.FrameSignature.FrameSignature, entry)
-    expect(rpc.scheme).toBe(2)
+    expect(rpc.scheme).toBe('0x2')
     expect(z.decode(z.FrameSignature.FrameSignature, rpc)).toEqual({
       ...entry,
       signature: { r: entry.signature.r, s: entry.signature.s },
@@ -92,3 +92,67 @@ describe('FrameSignature', () => {
     ).toBe(false)
   })
 })
+
+test('encodes protocol hex signatures', () => {
+  const payload = Hash.keccak256('0xdeadbeef')
+  const privateKey = accounts[0].privateKey
+  const secp = FrameSignature.from({
+    scheme: 'secp256k1',
+    signature: Secp256k1.sign({ payload, privateKey }),
+  })
+  const p256 = FrameSignature.from({
+    publicKey: P256.getPublicKey({ privateKey }),
+    scheme: 'p256',
+    signature: P256.sign({ payload, privateKey }),
+  })
+
+  expect(
+    z.encode(z.FrameSignature.FrameSignature, {
+      ...secp,
+      signature: Signature.toHex(secp.signature),
+    }),
+  ).toEqual(FrameSignature.toRpc(secp))
+  expect(
+    z.encode(z.FrameSignature.FrameSignature, {
+      ...p256,
+      signature: Signature.toHex(p256.signature),
+    }),
+  ).toEqual(FrameSignature.toRpc(p256))
+})
+
+describe('RPC signers', () => {
+  test.each(['0x0', '0x1', '0x2'] as const)(
+    'accepts an empty signer for scheme %s',
+    (scheme) => {
+      expect(
+        z.safeDecode(z.FrameSignature.FrameSignature, {
+          scheme,
+          signer: '0x',
+          msg: '0x',
+          ...(scheme === '0x0' ? { signature: '0x' } : {}),
+        }).success,
+      ).toBe(true)
+    },
+  )
+  test('rejects a null signer', () => {
+    expect(
+      z.safeParse(z.FrameSignature.FrameSignature, {
+        scheme: '0x1',
+        signer: null,
+      }).success,
+    ).toBe(false)
+  })
+})
+
+describe('unsigned placeholders', () => {
+  test.each([
+    { scheme: 'secp256k1', signature: '0x' },
+    { scheme: 'p256', signature: '0x' },
+  ] as const)('$scheme', (entry) => {
+    const { signature: _, ...unsigned } = entry
+    expect(z.safeParse(z.FrameSignature.Decoded, entry).success).toBe(true)
+    expect(z.encode(z.FrameSignature.FrameSignature, entry)).toEqual(
+      FrameSignature.toRpc(unsigned),
+    )
+  })
+})

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

@@ -423,3 +423,109 @@ describe('from', () => {
     expect(schema.abe_foo.method).toMatchInlineSnapshot(`"abe_foo"`)
   })
 })
+
+describe('frame simulation results', () => {
+  test('preserves payer, per-frame output, errors, and gas through the codec', () => {
+    const block = {
+      difficulty: '0x0',
+      extraData: '0x',
+      gasLimit: '0x100000',
+      gasUsed: '0x5208',
+      hash,
+      logsBloom: '0x',
+      miner: address,
+      mixHash: hash,
+      nonce: '0x0000000000000000',
+      number: '0x1',
+      parentHash: hash,
+      receiptsRoot: hash,
+      sha3Uncles: hash,
+      size: '0x1',
+      stateRoot: hash,
+      timestamp: '0x1',
+      transactions: [],
+      transactionsRoot: hash,
+      uncles: [],
+      calls: [
+        {
+          payer: address,
+          gasUsed: '0x5208',
+          returnData: '0xdead',
+          status: '0x0',
+          logs: [],
+          frameResults: [
+            {
+              status: '0x1',
+              gasUsed: '0x2',
+              executionGasUsed: '0x1',
+              stateGasUsed: '0x1',
+              logs: [],
+              returnData: '0xabcd',
+            },
+            {
+              status: '0x0',
+              gasUsed: '0x1',
+              executionGasUsed: '0x1',
+              stateGasUsed: '0x0',
+              logs: [],
+              returnData: '0xdead',
+              error: { code: 3, message: 'execution reverted' },
+            },
+            {
+              status: '0x2',
+              gasUsed: '0x0',
+              executionGasUsed: '0x0',
+              stateGasUsed: '0x0',
+              logs: [],
+              returnData: '0x',
+            },
+          ],
+        },
+      ],
+    } satisfies z.input<typeof z_RpcSchema.Eth.eth_simulateV1.returns>[number]
+    const decoded = z_RpcSchema.decodeReturns(
+      z_RpcSchema.Eth,
+      'eth_simulateV1',
+      [block],
+    )
+    expect(decoded[0]?.calls).toEqual([
+      {
+        payer: address,
+        gasUsed: '0x5208',
+        returnData: '0xdead',
+        status: '0x0',
+        logs: [],
+        frameResults: [
+          {
+            status: 'success',
+            gasUsed: 2n,
+            executionGasUsed: 1n,
+            stateGasUsed: 1n,
+            logs: [],
+            returnData: '0xabcd',
+          },
+          {
+            status: 'reverted',
+            gasUsed: 1n,
+            executionGasUsed: 1n,
+            stateGasUsed: 0n,
+            logs: [],
+            returnData: '0xdead',
+            error: { code: 3, message: 'execution reverted' },
+          },
+          {
+            status: 'skipped',
+            gasUsed: 0n,
+            executionGasUsed: 0n,
+            stateGasUsed: 0n,
+            logs: [],
+            returnData: '0x',
+          },
+        ],
+      },
+    ])
+    expect(
+      z_RpcSchema.encodeReturns(z_RpcSchema.Eth, 'eth_simulateV1', decoded),
+    ).toEqual([block])
+  })
+})

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

@@ -220,3 +220,64 @@ describe('TransactionRequest', () => {
     ).toBe(false)
   })
 })
+
+describe('frame requests', () => {
+  test.each([
+    z_TransactionRequest.TransactionRequest,
+    z_TransactionRequest.TransactionRequestToRpc,
+  ])('preserves gas omission and zero through the request codec', (schema) => {
+    const decoded = z.decode(schema, {
+      type: '0x6',
+      frames: [{ mode: '0x2' }, { mode: '0x2', stateGas: '0x0' }],
+    })
+    expect(decoded).toEqual({
+      type: 'eip8141',
+      frames: [
+        { mode: 2, flags: 0, data: '0x', value: 0n },
+        { mode: 2, flags: 0, data: '0x', value: 0n, stateGas: 0n },
+      ],
+    })
+    expect(z.encode(schema, decoded)).toEqual({
+      type: '0x6',
+      frames: [
+        { mode: '0x2', flags: '0x0', data: '0x', value: '0x0' },
+        {
+          mode: '0x2',
+          flags: '0x0',
+          data: '0x',
+          value: '0x0',
+          stateGas: '0x0',
+        },
+      ],
+    })
+  })
+  test('encodes numberish frame limits', () => {
+    expect(
+      z.encode(z_TransactionRequest.TransactionRequestToRpc, {
+        frames: [{ mode: 'sender', executionGas: 50000, stateGas: '0x0' }],
+      }),
+    ).toEqual({
+      frames: [
+        {
+          mode: '0x2',
+          flags: '0x0',
+          data: '0x',
+          value: '0x0',
+          executionGas: '0xc350',
+          stateGas: '0x0',
+        },
+      ],
+    })
+  })
+  test.each([
+    { mode: '0x3' },
+    { mode: '0x2', executionGas: '0x00' },
+    { mode: '0x2', stateGas: null },
+    {},
+  ])('rejects malformed frame request %j', (frame) => {
+    expect(
+      z.safeParse(z_TransactionRequest.TransactionRequest, { frames: [frame] })
+        .success,
+    ).toBe(false)
+  })
+})

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

@@ -75,10 +75,10 @@ describe('TxEnvelopeEip8141', () => {
     expect(
       z.encode(z.TxEnvelopeEip8141.TxEnvelopeEip8141ToRpc, {
         chainId: '0x1',
-        frames: [{ gas: 50_000 }],
+        frames: [{ executionGas: 50_000 }],
         sender: accounts[0].address,
         type: 'eip8141',
-      }).frames[0]!.executionGasLimit,
+      }).frames[0]!.executionGas,
     ).toBe('0xc350')
   })
 })
@@ -107,7 +107,7 @@ describe('invalid envelopes', () => {
   test('rejects malformed nested RPC signatures without throwing', () => {
     const rpc = {
       ...TxEnvelopeEip8141.toRpc(envelope),
-      signatures: [{ msg: '0x', scheme: 1, signature: '0x01' }],
+      signatures: [{ msg: '0x', scheme: '0x1', signature: '0x01' }],
     } as const
     expect(
       z.safeDecode(z.TxEnvelopeEip8141.TxEnvelopeEip8141, rpc).success,

package/src/zod/internal/rpcSchemas/Eth.ts

@@ -5,6 +5,7 @@ import * as z_Block from '../../Block.js'
 import * as z_BlockOverrides from '../../BlockOverrides.js'
 import * as z_Fee from '../../Fee.js'
 import * as z_Filter from '../../Filter.js'
+import * as z_FrameReceipt from '../../FrameReceipt.js'
 import * as z_Hex from '../../Hex.js'
 import * as z_Log from '../../Log.js'
 import * as z_Number from '../../Number.js'
@@ -322,6 +323,25 @@ export const eth_simulateV1 = from({
                   message: z.string(),
                 }),
               ),
+              frameResults: z.optional(
+                z.readonly(
+                  z.array(
+                    z.intersection(
+                      z_FrameReceipt.FrameReceipt,
+                      z.object({
+                        error: z.optional(
+                          z.object({
+                            code: z.number(),
+                            message: z.string(),
+                          }),
+                        ),
+                        returnData: z_Hex.Hex,
+                      }),
+                    ),
+                  ),
+                ),
+              ),
+              payer: z.optional(z_Address.Address),
               logs: z.optional(z.array(z_Log.Log)),
               gasUsed: z_Hex.Hex,
               returnData: z_Hex.Hex,

package/src/zod/z.ts

@@ -22,6 +22,7 @@ export * as Filter from './Filter.js'
 export * as Hash from './Hash.js'
 export * as Frame from './Frame.js'
 export * as FrameReceipt from './FrameReceipt.js'
+export * as FrameRequest from './FrameRequest.js'
 export * as FrameSignature from './FrameSignature.js'
 export * as Hex from './Hex.js'
 export * as Log from './Log.js'