ox 1.0.0-beta.2 → 1.0.0-beta.21

package/src/zod/tempo/TransactionRequest.ts

@@ -5,11 +5,15 @@ import * as z_AccessList from '../AccessList.js'
 import * as z_Address from '../Address.js'
 import * as z_Hex from '../Hex.js'
 import * as z_TransactionRequest from '../TransactionRequest.js'
+import {
+  encodeNumberish,
+  uintBigintNumberish,
+  uintNumberNumberish,
+} from '../internal/Integer.js'
 import * as z from 'zod/mini'
 import * as z_AuthorizationTempo from './AuthorizationTempo.js'
 import * as z_KeyAuthorization from './KeyAuthorization.js'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
-import * as z_TokenId from './TokenId.js'
 
 const fromRpcType = { '0x76': 'tempo' } as const
 const toRpcType = { tempo: '0x76' } as const
@@ -46,6 +50,22 @@ const Call = z.object({
   value: z.optional(z.bigint()),
 })
 
+const CallToRpc = z.object({
+  data: z.optional(z_Hex.Hex),
+  to: z.optional(z_Address.Address),
+  value: z.optional(uintBigintNumberish()),
+})
+
+const Capabilities = z.record(z.string(), z.unknown())
+
+const MultisigInit = z.object({
+  salt: z_Hex.Hex,
+  threshold: z.number(),
+  owners: z.readonly(
+    z.array(z.object({ owner: z_Address.Address, weight: z.number() })),
+  ),
+})
+
 /** RPC tempo transaction request schema. */
 export const Rpc = z.object({
   accessList: z.optional(z_AccessList.AccessList),
@@ -53,6 +73,7 @@ export const Rpc = z.object({
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
   calls: z.optional(z.readonly(z.array(CallRpc))),
+  capabilities: z.optional(Capabilities),
   chainId: z.optional(z_Hex.Hex),
   data: z.optional(z_Hex.Hex),
   feePayer: z.optional(z.boolean()),
@@ -64,10 +85,13 @@ export const Rpc = z.object({
   input: z.optional(z_Hex.Hex),
   keyAuthorization: z.optional(z_KeyAuthorization.Rpc),
   keyData: z.optional(z_Hex.Hex),
+  keyId: z.optional(z_Address.Address),
   keyType: z.optional(KeyType),
   maxFeePerBlobGas: z.optional(z_Hex.Hex),
   maxFeePerGas: z.optional(z_Hex.Hex),
   maxPriorityFeePerGas: z.optional(z_Hex.Hex),
+  multisigInit: z.optional(MultisigInit),
+  multisigSignatureCount: z.optional(z.number()),
   nonce: z.optional(z_Hex.Hex),
   nonceKey: z.optional(z_Hex.Hex),
   r: z.optional(z_Hex.Hex),
@@ -89,6 +113,13 @@ const AuthorizationSigned = z.object({
   signature: z_SignatureEnvelope.Domain,
 })
 
+const AuthorizationSignedToRpc = z.object({
+  address: z_Address.Address,
+  chainId: uintNumberNumberish(),
+  nonce: uintBigintNumberish(),
+  signature: z_SignatureEnvelope.Domain,
+})
+
 /** Decoded tempo transaction request schema. */
 export const Domain = z.object({
   accessList: z.optional(z_AccessList.AccessList),
@@ -96,21 +127,25 @@ export const Domain = z.object({
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
   calls: z.optional(z.readonly(z.array(Call))),
+  capabilities: z.optional(Capabilities),
   chainId: z.optional(z.number()),
   data: z.optional(z_Hex.Hex),
   feePayer: z.optional(z.boolean()),
   feePayerSignature: z.optional(z.union([SignatureDecoded, z.null()])),
-  feeToken: z.optional(z.union([z_Address.Address, z.bigint()])),
+  feeToken: z.optional(z_Address.Address),
   from: z.optional(z_Address.Address),
   gas: z.optional(z.bigint()),
   gasPrice: z.optional(z.bigint()),
   input: z.optional(z_Hex.Hex),
   keyAuthorization: z.optional(z_KeyAuthorization.Domain),
   keyData: z.optional(z_Hex.Hex),
+  keyId: z.optional(z_Address.Address),
   keyType: z.optional(KeyType),
   maxFeePerBlobGas: z.optional(z.bigint()),
   maxFeePerGas: z.optional(z.bigint()),
   maxPriorityFeePerGas: z.optional(z.bigint()),
+  multisigInit: z.optional(MultisigInit),
+  multisigSignatureCount: z.optional(z.number()),
   nonce: z.optional(z.bigint()),
   nonceKey: z.optional(z.union([z.bigint(), z.literal('random')])),
   r: z.optional(z_Hex.Hex),
@@ -125,12 +160,58 @@ export const Domain = z.object({
   yParity: z.optional(z.number()),
 })
 
+/** Encode-only decoded tempo transaction request schema accepting numberish `toRpc` inputs. */
+export const DomainToRpc = z.object({
+  accessList: z.optional(z_AccessList.AccessList),
+  authorizationList: z.optional(z.readonly(z.array(AuthorizationSignedToRpc))),
+  blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
+  blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
+  calls: z.optional(z.readonly(z.array(CallToRpc))),
+  capabilities: z.optional(Capabilities),
+  chainId: z.optional(uintNumberNumberish()),
+  data: z.optional(z_Hex.Hex),
+  feePayer: z.optional(z.boolean()),
+  feePayerSignature: z.optional(z.union([SignatureDecoded, z.null()])),
+  feeToken: z.optional(z_Address.Address),
+  from: z.optional(z_Address.Address),
+  gas: z.optional(uintBigintNumberish()),
+  gasPrice: z.optional(uintBigintNumberish()),
+  input: z.optional(z_Hex.Hex),
+  keyAuthorization: z.optional(z_KeyAuthorization.DomainToRpc),
+  keyData: z.optional(z_Hex.Hex),
+  keyId: z.optional(z_Address.Address),
+  keyType: z.optional(KeyType),
+  maxFeePerBlobGas: z.optional(uintBigintNumberish()),
+  maxFeePerGas: z.optional(uintBigintNumberish()),
+  maxPriorityFeePerGas: z.optional(uintBigintNumberish()),
+  multisigInit: z.optional(MultisigInit),
+  multisigSignatureCount: z.optional(z.number()),
+  nonce: z.optional(uintBigintNumberish()),
+  nonceKey: z.optional(z.union([uintBigintNumberish(), z.literal('random')])),
+  r: z.optional(z_Hex.Hex),
+  s: z.optional(z_Hex.Hex),
+  signature: z.optional(z_SignatureEnvelope.Domain),
+  to: z.optional(z.union([z_Address.Address, z.null()])),
+  type: z.optional(z.string()),
+  v: z.optional(z.number()),
+  validAfter: z.optional(uintNumberNumberish()),
+  validBefore: z.optional(uintNumberNumberish()),
+  value: z.optional(uintBigintNumberish()),
+  yParity: z.optional(z.number()),
+})
+
 /** Codec decoding an RPC tempo transaction request into a transaction request. */
 export const TransactionRequest = z.codec(Rpc, Domain, {
   decode: (value) => fromRpc(value as never) as never,
   encode: (value) => toRpc(value as never) as never,
 })
 
+/** Encode-only tempo transaction request codec accepting numberish `toRpc` inputs. */
+export const TransactionRequestToRpc = z.codec(Rpc, DomainToRpc, {
+  decode: (value) => fromRpc(value as never) as never,
+  encode: (value) => toRpc(value as never) as never,
+})
+
 /** Decodes an RPC tempo transaction request into a transaction request. */
 function fromRpc(
   request: core_TransactionRequest.Rpc,
@@ -172,6 +253,17 @@ function fromRpc(
       z_KeyAuthorization.KeyAuthorization,
       request.keyAuthorization as never,
     ) as never
+  if (typeof request.capabilities !== 'undefined')
+    request_.capabilities = request.capabilities
+  if (typeof request.feePayer !== 'undefined')
+    request_.feePayer = request.feePayer
+  if (typeof request.keyData !== 'undefined') request_.keyData = request.keyData
+  if (typeof request.keyId !== 'undefined') request_.keyId = request.keyId
+  if (typeof request.keyType !== 'undefined') request_.keyType = request.keyType
+  if (typeof request.multisigInit !== 'undefined')
+    request_.multisigInit = request.multisigInit
+  if (typeof request.multisigSignatureCount !== 'undefined')
+    request_.multisigSignatureCount = request.multisigSignatureCount
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = core_Hex.toNumber(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -186,14 +278,30 @@ function fromRpc(
 function toRpc(
   request: core_TransactionRequest.TransactionRequest,
 ): core_TransactionRequest.Rpc {
-  const request_rpc = z.encode(z_TransactionRequest.TransactionRequest, {
+  const request_rpc = z.encode(z_TransactionRequest.TransactionRequestToRpc, {
     ...request,
     authorizationList: undefined,
   } as never) as core_TransactionRequest.Rpc
 
+  const tempo =
+    typeof request.calls !== 'undefined' ||
+    typeof request.capabilities !== 'undefined' ||
+    typeof request.feePayer !== 'undefined' ||
+    typeof request.feeToken !== 'undefined' ||
+    typeof request.keyAuthorization !== 'undefined' ||
+    typeof request.keyData !== 'undefined' ||
+    typeof request.keyId !== 'undefined' ||
+    typeof request.keyType !== 'undefined' ||
+    typeof request.multisigInit !== 'undefined' ||
+    typeof request.multisigSignatureCount !== 'undefined' ||
+    typeof request.nonceKey !== 'undefined' ||
+    typeof request.validBefore !== 'undefined' ||
+    typeof request.validAfter !== 'undefined' ||
+    request.type === 'tempo'
+
   if (request.authorizationList)
     request_rpc.authorizationList = z.encode(
-      z_AuthorizationTempo.ListSigned,
+      z_AuthorizationTempo.ListSignedToRpc,
       request.authorizationList as never,
     ) as never
   if (request.signature)
@@ -206,50 +314,58 @@ function toRpc(
   if (request.calls)
     request_rpc.calls = request.calls.map((call) => ({
       to: call.to,
-      value: call.value ? core_Hex.fromNumber(call.value) : '0x',
+      value: call.value ? encodeNumberish(call.value) : '0x',
       data: call.data ?? '0x',
     }))
-  else if (request.to || request.data || request.value)
+  else if (request.to || request.data || request.value || tempo)
     request_rpc.calls = [
       {
-        to: request.to ?? undefined,
-        value: request.value ? core_Hex.fromNumber(request.value) : '0x',
+        to:
+          request.to ||
+          (tempo && (!request.data || request.data === '0x')
+            ? '0x0000000000000000000000000000000000000000'
+            : undefined),
+        value: request.value ? encodeNumberish(request.value) : '0x',
         data: request.data ?? '0x',
       },
     ]
-  if (typeof request.feeToken !== 'undefined')
-    request_rpc.feeToken =
-      typeof request.feeToken === 'bigint'
-        ? z.encode(z_TokenId.address, request.feeToken)
-        : request.feeToken
+  if (
+    typeof request.feeToken !== 'undefined' &&
+    !(request.feePayer === true && !request.feePayerSignature)
+  )
+    request_rpc.feeToken = request.feeToken
   if (request.keyAuthorization)
     request_rpc.keyAuthorization = z.encode(
-      z_KeyAuthorization.KeyAuthorization,
+      z_KeyAuthorization.KeyAuthorizationToRpc,
       request.keyAuthorization as never,
     ) as never
+  if (typeof request.capabilities !== 'undefined')
+    request_rpc.capabilities = request.capabilities
+  if (typeof request.feePayer !== 'undefined')
+    request_rpc.feePayer = request.feePayer
+  if (typeof request.keyData !== 'undefined')
+    request_rpc.keyData = shimKeyData(request.keyData)
+  if (typeof request.keyId !== 'undefined') request_rpc.keyId = request.keyId
+  if (typeof request.keyType !== 'undefined')
+    request_rpc.keyType = request.keyType
+  if (typeof request.multisigInit !== 'undefined')
+    request_rpc.multisigInit = request.multisigInit
+  if (typeof request.multisigSignatureCount !== 'undefined')
+    request_rpc.multisigSignatureCount = request.multisigSignatureCount
   if (typeof request.validBefore !== 'undefined')
-    request_rpc.validBefore = core_Hex.fromNumber(request.validBefore)
+    request_rpc.validBefore = encodeNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
-    request_rpc.validAfter = core_Hex.fromNumber(request.validAfter)
+    request_rpc.validAfter = encodeNumberish(request.validAfter)
 
   const nonceKey = (() => {
     if (request.nonceKey === 'random') return core_Hex.random(24)
-    if (typeof request.nonceKey === 'bigint')
-      return core_Hex.fromNumber(request.nonceKey)
+    if (typeof request.nonceKey !== 'undefined')
+      return encodeNumberish(request.nonceKey)
     return undefined
   })()
   if (nonceKey) request_rpc.nonceKey = nonceKey
 
-  if (
-    typeof request.calls !== 'undefined' ||
-    typeof request.feePayer !== 'undefined' ||
-    typeof request.feeToken !== 'undefined' ||
-    typeof request.keyAuthorization !== 'undefined' ||
-    typeof request.nonceKey !== 'undefined' ||
-    typeof request.validBefore !== 'undefined' ||
-    typeof request.validAfter !== 'undefined' ||
-    request.type === 'tempo'
-  ) {
+  if (tempo) {
     request_rpc.type = toRpcType.tempo
     delete request_rpc.data
     delete request_rpc.input
@@ -260,6 +376,16 @@ function toRpc(
   return request_rpc
 }
 
+/**
+ * Shims key data longer than 4 bytes into a 2-byte big-endian length hint
+ * (the node's gas estimator only accepts 1, 2, or 4-byte key data).
+ */
+function shimKeyData(data: core_Hex.Hex): core_Hex.Hex {
+  const byteLength = core_Hex.size(data)
+  if (byteLength <= 4) return data
+  return core_Hex.fromNumber(byteLength, { size: 2 })
+}
+
 /** Decodes an RPC signature into a recovered signature. */
 function signatureFromRpc(signature: {
   r: core_Hex.Hex

package/src/zod/tempo/TxEnvelopeTempo.ts

@@ -31,7 +31,7 @@ const baseFields = {
   calls: z.readonly(z.array(Call)),
   chainId: z.number(),
   feePayerSignature: z.optional(z.union([FeePayerSignature, z.null()])),
-  feeToken: z.optional(z.union([z_Address.Address, z.bigint()])),
+  feeToken: z.optional(z_Address.Address),
   from: z.optional(z_Address.Address),
   gas: z.optional(z.bigint()),
   keyAuthorization: z.optional(z_KeyAuthorization.Domain),

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

@@ -41,6 +41,30 @@ describe('AuthorizationTempo', () => {
     ])
   })
 
+  test('UnsignedToRpc accepts numberish encode inputs', () => {
+    const decoded = {
+      address: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
+      chainId: 1,
+      nonce: 42n,
+    } as const
+    const expected = z.encode(z_AuthorizationTempo.Unsigned, decoded)
+
+    expect(
+      z.encode(z_AuthorizationTempo.UnsignedToRpc, {
+        ...decoded,
+        chainId: 1,
+        nonce: 42,
+      }),
+    ).toEqual(expected)
+    expect(
+      z.encode(z_AuthorizationTempo.UnsignedToRpc, {
+        ...decoded,
+        chainId: '0x1',
+        nonce: '0x2a',
+      }),
+    ).toEqual(expected)
+  })
+
   test('rejects an invalid authorization', () => {
     expect(
       z.safeDecode(z_AuthorizationTempo.Signed, { chainId: '0x1' } as never)

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

@@ -26,6 +26,59 @@ describe('KeyAuthorization', () => {
     )
   })
 
+  test('decodes node-null optional fields', () => {
+    const withNulls = {
+      ...rpc,
+      allowedCalls: null,
+      expiry: null,
+      limits: null,
+    } as const
+    expect(z.decode(z_KeyAuthorization.KeyAuthorization, withNulls)).toEqual(
+      core_KeyAuthorization.fromRpc(withNulls),
+    )
+  })
+
+  test('decodes nested node-null optional fields', () => {
+    const withNestedNulls = {
+      ...rpc,
+      allowedCalls: [
+        {
+          selectorRules: [{ recipients: null, selector: '0xa9059cbb' }],
+          target: '0x20c0000000000000000000000000000000000001',
+        },
+        {
+          selectorRules: null,
+          target: '0x20c0000000000000000000000000000000000002',
+        },
+      ],
+      limits: [
+        {
+          limit: '0x989680',
+          period: null,
+          token: '0x20c0000000000000000000000000000000000001',
+        },
+      ],
+    } as const
+    expect(
+      z.decode(z_KeyAuthorization.KeyAuthorization, withNestedNulls),
+    ).toEqual(core_KeyAuthorization.fromRpc(withNestedNulls))
+  })
+
+  test('decodes witness and admin fields', () => {
+    const withAdmin = {
+      ...rpc,
+      account: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+      isAdmin: true,
+      witness:
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+    } as const
+    const decoded = z.decode(z_KeyAuthorization.KeyAuthorization, withAdmin)
+    expect(decoded).toEqual(core_KeyAuthorization.fromRpc(withAdmin))
+    expect(z.encode(z_KeyAuthorization.KeyAuthorization, decoded)).toEqual(
+      core_KeyAuthorization.toRpc(decoded),
+    )
+  })
+
   test('decodes nested allowedCalls into scopes', () => {
     const withScopes = {
       ...rpc,
@@ -48,6 +101,38 @@ describe('KeyAuthorization', () => {
     )
   })
 
+  test('KeyAuthorizationToRpc accepts numberish encode inputs', () => {
+    const decoded = z.decode(z_KeyAuthorization.KeyAuthorization, rpc)
+    const strict = z.encode(z_KeyAuthorization.KeyAuthorization, decoded)
+
+    expect(
+      z.encode(z_KeyAuthorization.KeyAuthorizationToRpc, {
+        ...decoded,
+        chainId: 1,
+        expiry: 1234567890,
+        limits: [
+          {
+            limit: 10000000,
+            token: '0x20c0000000000000000000000000000000000001',
+          },
+        ],
+      }),
+    ).toEqual(strict)
+    expect(
+      z.encode(z_KeyAuthorization.KeyAuthorizationToRpc, {
+        ...decoded,
+        chainId: '0x1',
+        expiry: '0x499602d2',
+        limits: [
+          {
+            limit: '0x989680',
+            token: '0x20c0000000000000000000000000000000000001',
+          },
+        ],
+      }),
+    ).toEqual(strict)
+  })
+
   test('rejects an invalid key authorization', () => {
     expect(
       z.safeDecode(z_KeyAuthorization.KeyAuthorization, {

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

@@ -21,8 +21,6 @@ const p256 = {
 
 const multisig = {
   account: '0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c',
-  configId:
-    '0x0000000000000000000000000000000000000000000000000000000000000000',
   signatures: [
     core_SignatureEnvelope.serialize(core_SignatureEnvelope.fromRpc(secp256k1)),
   ],

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

@@ -35,6 +35,48 @@ const rpc = {
   type: '0x76',
 } as const
 
+/** Mined shape as serialized by the tempo node (absent optionals are `null`). */
+const nodeRpc = {
+  accessList: [],
+  aaAuthorizationList: [],
+  blockHash:
+    '0xa27e7b87e6f558014cb357e8361579de7f8bff8c2f39beb47e5cc75cd7bbba40',
+  blockNumber: '0x5a',
+  blockTimestamp: '0x6a4d7ca5',
+  calls: [
+    {
+      data: null,
+      input:
+        '0x5c559d2000000000000000000000000000000000000000000000000000000000abf52baf',
+      to: '0xfdc0000000000000000000000000000000000000',
+      value: '0x0',
+    },
+  ],
+  chainId: '0x539',
+  feePayerSignature: null,
+  feeToken: '0x20c0000000000000000000000000000000000000',
+  from: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+  gas: '0x81fb2',
+  gasPrice: '0x23c34600',
+  hash: '0x76e9adc3b5f6262159d49582a64b8696ecf5864ac5237f72b5c0797ca380e9d4',
+  keyAuthorization: null,
+  maxFeePerGas: '0x2aea5400',
+  maxPriorityFeePerGas: '0x0',
+  nonce: '0x0',
+  nonceKey: '0x0',
+  signature: {
+    r: '0xc5363149ebd9b247cd6948469677efbed1c58be3a79ec020ff767e41196b464',
+    s: '0x701c441f1ce3ca8dd0bff969924db2c8817a7dec1ade02c39c79bd57c8d0089d',
+    type: 'secp256k1',
+    v: '0x0',
+    yParity: '0x0',
+  },
+  transactionIndex: '0x0',
+  type: '0x76',
+  validAfter: null,
+  validBefore: null,
+} as const
+
 describe('Tempo', () => {
   test('decodes a tempo transaction', () => {
     const decoded = z.decode(z_Transaction.Tempo, rpc)
@@ -71,6 +113,119 @@ describe('Tempo', () => {
       type: '0x76',
     })
   })
+
+  test('decodes a node transaction (null optionals)', () => {
+    const decoded = z.decode(z_Transaction.Tempo, nodeRpc)
+    expect(decoded).toMatchInlineSnapshot(`
+      {
+        "accessList": [],
+        "blockHash": "0xa27e7b87e6f558014cb357e8361579de7f8bff8c2f39beb47e5cc75cd7bbba40",
+        "blockNumber": 90n,
+        "blockTimestamp": 1783463077n,
+        "calls": [
+          {
+            "data": "0x5c559d2000000000000000000000000000000000000000000000000000000000abf52baf",
+            "to": "0xfdc0000000000000000000000000000000000000",
+            "value": 0n,
+          },
+        ],
+        "chainId": 1337,
+        "feeToken": "0x20c0000000000000000000000000000000000000",
+        "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+        "gas": 532402n,
+        "gasPrice": 600000000n,
+        "hash": "0x76e9adc3b5f6262159d49582a64b8696ecf5864ac5237f72b5c0797ca380e9d4",
+        "maxFeePerGas": 720000000n,
+        "maxPriorityFeePerGas": 0n,
+        "nonce": 0n,
+        "nonceKey": 0n,
+        "signature": {
+          "signature": {
+            "r": "0x0c5363149ebd9b247cd6948469677efbed1c58be3a79ec020ff767e41196b464",
+            "s": "0x701c441f1ce3ca8dd0bff969924db2c8817a7dec1ade02c39c79bd57c8d0089d",
+            "yParity": 0,
+          },
+          "type": "secp256k1",
+        },
+        "transactionIndex": 0,
+        "type": "tempo",
+      }
+    `)
+  })
+
+  test('maps `aaAuthorizationList` to `authorizationList`', () => {
+    const decoded = z.decode(z_Transaction.Tempo, {
+      ...nodeRpc,
+      aaAuthorizationList: [
+        {
+          address: '0xfdc0000000000000000000000000000000000000',
+          chainId: '0x539',
+          nonce: '0x1',
+          signature: {
+            r: '0xc5363149ebd9b247cd6948469677efbed1c58be3a79ec020ff767e41196b464',
+            s: '0x701c441f1ce3ca8dd0bff969924db2c8817a7dec1ade02c39c79bd57c8d0089d',
+            type: 'secp256k1',
+            yParity: '0x0',
+          },
+        },
+      ],
+    })
+    expect(decoded.type === 'tempo' && decoded.authorizationList)
+      .toMatchInlineSnapshot(`
+      [
+        {
+          "address": "0xfdc0000000000000000000000000000000000000",
+          "chainId": 1337,
+          "nonce": 1n,
+          "signature": {
+            "signature": {
+              "r": "0x0c5363149ebd9b247cd6948469677efbed1c58be3a79ec020ff767e41196b464",
+              "s": "0x701c441f1ce3ca8dd0bff969924db2c8817a7dec1ade02c39c79bd57c8d0089d",
+              "yParity": 0,
+            },
+            "type": "secp256k1",
+          },
+        },
+      ]
+    `)
+
+    const encoded = z.encode(z_Transaction.Tempo, decoded)
+    expect(
+      'aaAuthorizationList' in encoded && encoded.aaAuthorizationList,
+    ).toHaveLength(1)
+    expect(encoded).not.toHaveProperty('authorizationList')
+  })
+})
+
+describe('PendingTempo', () => {
+  test('decodes a pending node transaction', () => {
+    const decoded = z.decode(z_Transaction.PendingTempo, {
+      ...nodeRpc,
+      blockHash: null,
+      blockNumber: null,
+      blockTimestamp: undefined,
+      gasPrice: '0x2aea5400',
+      transactionIndex: null,
+    })
+    expect(decoded).toMatchObject({
+      blockHash: null,
+      blockNumber: null,
+      gasPrice: 720000000n,
+      transactionIndex: null,
+      type: 'tempo',
+    })
+  })
+
+  test('decodes via the `Pending` union', () => {
+    const decoded = z.decode(z_Transaction.Pending, {
+      ...nodeRpc,
+      blockHash: null,
+      blockNumber: null,
+      blockTimestamp: undefined,
+      transactionIndex: null,
+    })
+    expect(decoded).toMatchObject({ type: 'tempo' })
+  })
 })
 
 describe('Transaction', () => {
@@ -79,6 +234,29 @@ describe('Transaction', () => {
     expect(decoded).toMatchObject({ type: 'tempo' })
   })
 
+  test('TempoToRpc accepts numberish encode inputs', () => {
+    const decoded = z.decode(z_Transaction.Tempo, rpc)
+    const strict = z.encode(z_Transaction.Tempo, decoded)
+
+    expect(
+      z.encode(z_Transaction.TempoToRpc, {
+        ...decoded,
+        chainId: 1,
+        gas: 278365,
+        maxFeePerGas: 2,
+        transactionIndex: 2,
+      }),
+    ).toEqual(strict)
+    expect(
+      z.encode(z_Transaction.TempoToRpc, {
+        ...decoded,
+        chainId: '0x1',
+        gas: '0x43f5d',
+        maxFeePerGas: '0x2',
+      }),
+    ).toEqual(strict)
+  })
+
   test('rejects an invalid transaction', () => {
     expect(
       z.safeDecode(z_Transaction.Transaction, { type: '0x76' } as never)

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

@@ -52,3 +52,29 @@ describe('TransactionReceipt', () => {
     expect(z.encode(z_TransactionReceipt.Type, 'tempo')).toBe('0x76')
   })
 })
+
+describe('TransactionReceiptToRpc', () => {
+  test('accepts numberish encode inputs', () => {
+    const decoded = z.decode(z_TransactionReceipt.TransactionReceipt, rpc)
+    const strict = z.encode(z_TransactionReceipt.TransactionReceipt, decoded)
+
+    // numberish: bigint quantities as `number`, number quantities as `number`
+    expect(
+      z.encode(z_TransactionReceipt.TransactionReceiptToRpc, {
+        ...decoded,
+        cumulativeGasUsed: 533781,
+        gasUsed: 175034,
+        transactionIndex: 2,
+      }),
+    ).toEqual(strict)
+
+    // numberish: quantities as hex pass-through
+    expect(
+      z.encode(z_TransactionReceipt.TransactionReceiptToRpc, {
+        ...decoded,
+        blockNumber: '0x12f296f',
+        gasUsed: '0x2abba',
+      }),
+    ).toEqual(strict)
+  })
+})