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

package/src/zod/tempo/AuthorizationTempo.ts

@@ -14,6 +14,14 @@ export const Unsigned = z.object({
   signature: z.optional(z.undefined()),
 })
 
+/** Encode-only unsigned AA authorization schema accepting numberish `toRpc` inputs. */
+export const UnsignedToRpc = z.object({
+  address: z_Address.Address,
+  chainId: z_Number.NumberToRpc,
+  nonce: z_Uint.UintToRpc,
+  signature: z.optional(z.undefined()),
+})
+
 /** Signed AA authorization schema. */
 export const Signed = z.object({
   address: z_Address.Address,
@@ -22,6 +30,14 @@ export const Signed = z.object({
   signature: z_SignatureEnvelope.SignatureEnvelope,
 })
 
+/** Encode-only signed AA authorization schema accepting numberish `toRpc` inputs. */
+export const SignedToRpc = z.object({
+  address: z_Address.Address,
+  chainId: z_Number.NumberToRpc,
+  nonce: z_Uint.UintToRpc,
+  signature: z_SignatureEnvelope.SignatureEnvelope,
+})
+
 /** Decoded signed AA authorization schema. */
 export const Domain = z.object({
   address: z_Address.Address,
@@ -36,12 +52,21 @@ export const DomainList = z.readonly(z.array(Domain))
 /** AA authorization schema. */
 export const AuthorizationTempo = z.union([Signed, Unsigned])
 
+/** Encode-only AA authorization schema accepting numberish `toRpc` inputs. */
+export const AuthorizationTempoToRpc = z.union([SignedToRpc, UnsignedToRpc])
+
 /** AA authorization list schema. */
 export const List = z.readonly(z.array(AuthorizationTempo))
 
+/** Encode-only AA authorization list schema accepting numberish `toRpc` inputs. */
+export const ListToRpc = z.readonly(z.array(AuthorizationTempoToRpc))
+
 /** Signed AA authorization list schema. */
 export const ListSigned = z.readonly(z.array(Signed))
 
+/** Encode-only signed AA authorization list schema accepting numberish `toRpc` inputs. */
+export const ListSignedToRpc = z.readonly(z.array(SignedToRpc))
+
 /** RPC AA authorization schema. */
 export const Rpc = z.object({
   address: z_Address.Address,

package/src/zod/tempo/KeyAuthorization.ts

@@ -2,37 +2,44 @@
 import * as core_KeyAuthorization from '../../tempo/KeyAuthorization.js'
 import * as z_Address from '../Address.js'
 import * as z_Hex from '../Hex.js'
+import {
+  uintBigintNumberish,
+  uintNumberNumberish,
+} from '../internal/Integer.js'
 import * as z from 'zod/mini'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 
 /** RPC token spending limit schema. */
 export const RpcTokenLimit = z.object({
   limit: z_Hex.Hex,
-  period: z.optional(z_Hex.Hex),
+  period: z.optional(z.nullable(z_Hex.Hex)),
   token: z_Address.Address,
 })
 
 /** RPC selector rule schema. */
 export const RpcSelectorRule = z.object({
-  recipients: z.optional(z.readonly(z.array(z_Address.Address))),
+  recipients: z.optional(z.nullable(z.readonly(z.array(z_Address.Address)))),
   selector: z_Hex.Hex,
 })
 
 /** RPC call scope schema. */
 export const RpcCallScope = z.object({
-  selectorRules: z.optional(z.readonly(z.array(RpcSelectorRule))),
+  selectorRules: z.optional(z.nullable(z.readonly(z.array(RpcSelectorRule)))),
   target: z_Address.Address,
 })
 
 /** RPC key authorization schema. */
 export const Rpc = z.object({
-  allowedCalls: z.optional(z.readonly(z.array(RpcCallScope))),
+  account: z.optional(z.nullable(z_Address.Address)),
+  allowedCalls: z.optional(z.nullable(z.readonly(z.array(RpcCallScope)))),
   chainId: z_Hex.Hex,
   expiry: z.optional(z.nullable(z_Hex.Hex)),
+  isAdmin: z.optional(z.nullable(z.boolean())),
   keyId: z_Address.Address,
   keyType: z_SignatureEnvelope.Type,
-  limits: z.optional(z.readonly(z.array(RpcTokenLimit))),
+  limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
   signature: z_SignatureEnvelope.Rpc,
+  witness: z.optional(z.nullable(z_Hex.Hex)),
 })
 
 /** Token spending limit schema. */
@@ -42,6 +49,13 @@ export const TokenLimit = z.object({
   token: z_Address.Address,
 })
 
+/** Encode-only token spending limit schema accepting numberish `toRpc` inputs. */
+export const TokenLimitToRpc = z.object({
+  limit: uintBigintNumberish(),
+  period: z.optional(uintNumberNumberish()),
+  token: z_Address.Address,
+})
+
 /** Call scope schema. */
 export const Scope = z.object({
   address: z_Address.Address,
@@ -49,8 +63,7 @@ export const Scope = z.object({
   selector: z.optional(z.union([z_Hex.Hex, z.string()])),
 })
 
-/** Decoded key authorization schema. */
-export const Domain = z.object({
+const domainShape = {
   address: z_Address.Address,
   chainId: z.bigint(),
   expiry: z.optional(z.number()),
@@ -58,7 +71,35 @@ export const Domain = z.object({
   scopes: z.optional(z.readonly(z.array(Scope))),
   signature: z_SignatureEnvelope.Domain,
   type: z_SignatureEnvelope.Type,
-})
+  witness: z.optional(z_Hex.Hex),
+}
+
+/** Decoded key authorization schema (TIP-1049 admin fields are paired: both or neither). */
+export const Domain = z.union([
+  z.object({
+    ...domainShape,
+    account: z_Address.Address,
+    isAdmin: z.boolean(),
+  }),
+  z.object(domainShape),
+])
+
+const domainToRpcShape = {
+  ...domainShape,
+  chainId: uintBigintNumberish(),
+  expiry: z.optional(uintNumberNumberish()),
+  limits: z.optional(z.readonly(z.array(TokenLimitToRpc))),
+}
+
+/** Encode-only decoded key authorization schema accepting numberish `toRpc` inputs. */
+export const DomainToRpc = z.union([
+  z.object({
+    ...domainToRpcShape,
+    account: z_Address.Address,
+    isAdmin: z.boolean(),
+  }),
+  z.object(domainToRpcShape),
+])
 
 /** Codec decoding an RPC key authorization into a signed key authorization. */
 export const KeyAuthorization = z.codec(Rpc, Domain, {
@@ -66,5 +107,14 @@ export const KeyAuthorization = z.codec(Rpc, Domain, {
   encode: (value) => core_KeyAuthorization.toRpc(value as never) as never,
 })
 
+/** Encode-only key authorization codec accepting numberish `toRpc` inputs. */
+export const KeyAuthorizationToRpc = z.codec(Rpc, DomainToRpc, {
+  decode: (value) => core_KeyAuthorization.fromRpc(value as never) as never,
+  encode: (value) => core_KeyAuthorization.toRpc(value as never) as never,
+})
+
 /** Signed key authorization schema. */
 export const Signed = KeyAuthorization
+
+/** Encode-only signed key authorization schema accepting numberish `toRpc` inputs. */
+export const SignedToRpc = KeyAuthorizationToRpc

package/src/zod/tempo/SignatureEnvelope.ts

@@ -83,7 +83,6 @@ export const KeychainRpc = z.object({
 /** RPC native multisig signature envelope schema. */
 export const MultisigRpc = z.object({
   account: z_Address.Address,
-  configId: z_Hex.Hex,
   init: z.optional(z_MultisigConfig.Config),
   // Owner approvals are raw serialized signatures (node `Vec<Bytes>`).
   signatures: z.readonly(z.array(z_Hex.Hex)),
@@ -140,7 +139,6 @@ export const Keychain = z.object({
 /** Native multisig signature envelope schema. */
 export const Multisig = z.object({
   account: z_Address.Address,
-  genesisConfigId: z_Hex.Hex,
   init: z.optional(z_MultisigConfig.Config),
   // `signatures` is recursive; type the getter concretely to break the cycle.
   signatures: z.lazy(

package/src/zod/tempo/Transaction.ts

@@ -22,12 +22,16 @@ const FeePayerSignature = z.object({
   yParity: z_Number.Number,
 })
 
+/** Nullable RPC call field schema (the node serializes absent fields as `null`). */
+const NullableHex = z.optional(z.union([z_Hex.Hex, z.null()]))
+
 /** Tempo transaction call schema (decodes the RPC `input` field to `data`). */
 const Call = z.codec(
   z.object({
-    input: z.optional(z_Hex.Hex),
-    to: z.optional(z_Hex.Hex),
-    value: z.optional(z_Hex.Hex),
+    data: NullableHex,
+    input: NullableHex,
+    to: NullableHex,
+    value: NullableHex,
   }),
   z.object({
     data: z.optional(z_Hex.Hex),
@@ -36,9 +40,36 @@ const Call = z.codec(
   }),
   {
     decode: (value) => ({
-      data: value.input,
+      data: value.input ?? value.data ?? undefined,
+      to: value.to ?? undefined,
+      value: !value.value || value.value === '0x' ? undefined : value.value,
+    }),
+    encode: (value) => ({
+      input: value.data,
       to: value.to,
-      value: value.value === '0x' ? undefined : value.value,
+      value: value.value,
+    }),
+  },
+)
+
+/** Encode-only tempo transaction call schema accepting numberish `toRpc` inputs. */
+const CallToRpc = z.codec(
+  z.object({
+    data: NullableHex,
+    input: NullableHex,
+    to: NullableHex,
+    value: NullableHex,
+  }),
+  z.object({
+    data: z.optional(z_Hex.Hex),
+    to: z.optional(z_Hex.Hex),
+    value: z.optional(z_Uint.UintToRpc),
+  }),
+  {
+    decode: (value) => ({
+      data: value.input ?? value.data ?? undefined,
+      to: value.to ?? undefined,
+      value: !value.value || value.value === '0x' ? undefined : value.value,
     }),
     encode: (value) => ({
       input: value.data,
@@ -48,36 +79,120 @@ const Call = z.codec(
   },
 )
 
+/** Optional fields the node serializes as `null` when absent. */
+const nullableFields = [
+  'feePayer',
+  'feePayerSignature',
+  'gasPrice',
+  'keyAuthorization',
+  'nonceKey',
+  'validAfter',
+  'validBefore',
+] as const
+
+/**
+ * Wraps a tempo transaction object schema in a wire-shape codec: scrubs
+ * node-null optionals and maps the `aaAuthorizationList` RPC field to
+ * `authorizationList` (and back on encode).
+ */
+function wire<schema extends z.ZodMiniType>(schema: schema) {
+  return z.codec(z.looseObject({ type: z.literal('0x76') }), schema, {
+    decode: (rpc) => {
+      const { aaAuthorizationList, ...rest } = rpc as Record<string, unknown>
+      for (const key of nullableFields) if (rest[key] === null) delete rest[key]
+      if (Array.isArray(aaAuthorizationList) && aaAuthorizationList.length > 0)
+        rest.authorizationList = aaAuthorizationList
+      return rest as never
+    },
+    encode: (rpc) => {
+      const { authorizationList, ...rest } = rpc as Record<string, unknown>
+      return {
+        ...rest,
+        ...(authorizationList
+          ? { aaAuthorizationList: authorizationList }
+          : {}),
+      } as never
+    },
+  })
+}
+
 /** Tempo transaction schema (type `0x76`). */
-export const Tempo = z.object({
-  accessList: z_AccessList.AccessList,
-  authorizationList: z.optional(z_AuthorizationTempo.ListSigned),
-  blockHash: z_Hex.Hex,
-  blockNumber: z_Uint.Uint,
-  blockTimestamp: z.optional(z_Uint.Uint),
-  calls: z.readonly(z.array(Call)),
-  chainId: z_Number.Number,
-  feePayer: z.optional(z_Address.Address),
-  feePayerSignature: z.optional(FeePayerSignature),
-  feeToken: z_Address.Address,
-  from: z_Address.Address,
-  gas: z_Uint.Uint,
-  gasPrice: z.optional(z_Uint.Uint),
-  hash: z_Hex.Hex,
-  keyAuthorization: z.optional(z_KeyAuthorization.KeyAuthorization),
-  maxFeePerGas: z_Uint.Uint,
-  maxPriorityFeePerGas: z_Uint.Uint,
-  nonce: z_Uint.Uint,
-  nonceKey: z.optional(z_Uint.Uint),
-  signature: z_SignatureEnvelope.SignatureEnvelope,
-  transactionIndex: z_Number.Number,
-  type: Type,
-  validAfter: z.optional(z_Number.Number),
-  validBefore: z.optional(z_Number.Number),
-})
+export const Tempo = wire(
+  z.object(
+    fields(z_Uint.Uint, z_Number.Number, Call, z_AuthorizationTempo.ListSigned),
+  ),
+)
+
+/** Encode-only tempo transaction schema accepting numberish `toRpc` inputs. */
+export const TempoToRpc = wire(
+  z.object(
+    fields(
+      z_Uint.UintToRpc,
+      z_Number.NumberToRpc,
+      CallToRpc,
+      z_AuthorizationTempo.ListSignedToRpc,
+    ),
+  ),
+)
+
+/** Pending tempo transaction schema (type `0x76`, not yet included in a block). */
+export const PendingTempo = wire(
+  z.object({
+    ...fields(
+      z_Uint.Uint,
+      z_Number.Number,
+      Call,
+      z_AuthorizationTempo.ListSigned,
+    ),
+    blockHash: z.null(),
+    blockNumber: z.null(),
+    blockTimestamp: z.optional(z.null()),
+    transactionIndex: z.null(),
+  }),
+)
+
+function fields<
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+  call extends z.ZodMiniType,
+  authList extends z.ZodMiniType,
+>(uint: uint, num: num, call: call, authList: authList) {
+  return {
+    accessList: z_AccessList.AccessList,
+    authorizationList: z.optional(authList),
+    blockHash: z_Hex.Hex,
+    blockNumber: uint,
+    blockTimestamp: z.optional(uint),
+    calls: z.readonly(z.array(call)),
+    chainId: num,
+    feePayer: z.optional(z_Address.Address),
+    feePayerSignature: z.optional(FeePayerSignature),
+    feeToken: z_Address.Address,
+    from: z_Address.Address,
+    gas: uint,
+    gasPrice: z.optional(uint),
+    hash: z_Hex.Hex,
+    keyAuthorization: z.optional(z_KeyAuthorization.KeyAuthorization),
+    maxFeePerGas: uint,
+    maxPriorityFeePerGas: uint,
+    nonce: uint,
+    nonceKey: z.optional(uint),
+    signature: z_SignatureEnvelope.SignatureEnvelope,
+    transactionIndex: num,
+    type: Type,
+    validAfter: z.optional(num),
+    validBefore: z.optional(num),
+  }
+}
 
 /** Tempo transaction schema (union of tempo + standard transaction types). */
 export const Transaction = z.union([Tempo, z_Transaction.Transaction])
 
-/** Pending tempo transaction schema. */
-export const Pending = z_Transaction.Pending
+/** Encode-only tempo transaction schema accepting numberish `toRpc` inputs. */
+export const TransactionToRpc = z.union([
+  TempoToRpc,
+  z_Transaction.TransactionToRpc,
+])
+
+/** Pending tempo transaction schema (union of tempo + standard transaction types). */
+export const Pending = z.union([PendingTempo, z_Transaction.Pending])

package/src/zod/tempo/TransactionReceipt.ts

@@ -51,24 +51,39 @@ export const Type = z.codec(z.string(), z.string(), {
 })
 
 /** Tempo transaction receipt schema. */
-export const TransactionReceipt = z.object({
-  blobGasPrice: z.optional(z_Uint.Uint),
-  blobGasUsed: z.optional(z_Uint.Uint),
-  blockHash: z_Hex.Hex,
-  blockNumber: z_Uint.Uint,
-  contractAddress: z.optional(z.union([z_Address.Address, z.null()])),
-  cumulativeGasUsed: z_Uint.Uint,
-  effectiveGasPrice: z_Uint.Uint,
-  feePayer: z.optional(z_Address.Address),
-  feeToken: z.optional(z_Address.Address),
-  from: z_Address.Address,
-  gasUsed: z_Uint.Uint,
-  logs: z.array(z_Log.Log),
-  logsBloom: z_Hex.Hex,
-  root: z.optional(z_Hex.Hex),
-  status: Status,
-  to: z.union([z_Address.Address, z.null()]),
-  transactionHash: z_Hex.Hex,
-  transactionIndex: z_Number.Number,
-  type: Type,
-})
+export const TransactionReceipt = z.object(
+  fields(z_Uint.Uint, z_Number.Number, z_Log.Log),
+)
+
+/** Encode-only tempo transaction receipt schema accepting numberish `toRpc` inputs. */
+export const TransactionReceiptToRpc = z.object(
+  fields(z_Uint.UintToRpc, z_Number.NumberToRpc, z_Log.LogToRpc),
+)
+
+function fields<
+  uint extends z.ZodMiniType,
+  num extends z.ZodMiniType,
+  log extends z.ZodMiniType,
+>(uint: uint, num: num, log: log) {
+  return {
+    blobGasPrice: z.optional(uint),
+    blobGasUsed: z.optional(uint),
+    blockHash: z_Hex.Hex,
+    blockNumber: uint,
+    contractAddress: z.optional(z.union([z_Address.Address, z.null()])),
+    cumulativeGasUsed: uint,
+    effectiveGasPrice: uint,
+    feePayer: z.optional(z_Address.Address),
+    feeToken: z.optional(z_Address.Address),
+    from: z_Address.Address,
+    gasUsed: uint,
+    logs: z.array(log),
+    logsBloom: z_Hex.Hex,
+    root: z.optional(z_Hex.Hex),
+    status: Status,
+    to: z.union([z_Address.Address, z.null()]),
+    transactionHash: z_Hex.Hex,
+    transactionIndex: num,
+    type: Type,
+  }
+}