ox 1.0.0-beta.9 → 1.0.0

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,9 @@ const Call = z.codec(
   }),
   {
     decode: (value) => ({
-      data: value.input,
-      to: value.to,
-      value: value.value === '0x' ? undefined : value.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,
@@ -51,9 +55,10 @@ const Call = z.codec(
 /** Encode-only tempo transaction call schema accepting numberish `toRpc` inputs. */
 const CallToRpc = 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),
@@ -62,9 +67,9 @@ const CallToRpc = z.codec(
   }),
   {
     decode: (value) => ({
-      data: value.input,
-      to: value.to,
-      value: value.value === '0x' ? undefined : value.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,
@@ -74,21 +79,78 @@ const CallToRpc = 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(
-  fields(z_Uint.Uint, z_Number.Number, Call, z_AuthorizationTempo.ListSigned),
+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 = z.object(
-  fields(
-    z_Uint.UintToRpc,
-    z_Number.NumberToRpc,
-    CallToRpc,
-    z_AuthorizationTempo.ListSignedToRpc,
+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,
@@ -132,5 +194,5 @@ export const TransactionToRpc = z.union([
   z_Transaction.TransactionToRpc,
 ])
 
-/** Pending tempo transaction schema. */
-export const Pending = z_Transaction.Pending
+/** Pending tempo transaction schema (union of tempo + standard transaction types). */
+export const Pending = z.union([PendingTempo, z_Transaction.Pending])

package/src/zod/tempo/TransactionRequest.ts

@@ -14,7 +14,6 @@ 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
@@ -57,6 +56,16 @@ const CallToRpc = z.object({
   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),
@@ -64,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()),
@@ -75,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),
@@ -114,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),
@@ -150,21 +167,25 @@ export const DomainToRpc = 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(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.union([z_Address.Address, z.bigint()])),
+  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),
@@ -232,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')
@@ -251,6 +283,22 @@ function toRpc(
     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.ListSignedToRpc,
@@ -269,24 +317,41 @@ function toRpc(
       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,
+        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.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 = encodeNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -300,16 +365,7 @@ function toRpc(
   })()
   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
@@ -320,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/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,

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', () => {

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

@@ -44,6 +44,50 @@ describe('TransactionRequest', () => {
     )
   })
 
+  test('gas-model hints and capabilities round-trip', () => {
+    const hints = {
+      capabilities: { balanceDiffs: true },
+      keyData: '0x0578',
+      keyId: '0xcccccccccccccccccccccccccccccccccccccccc',
+      keyType: 'webAuthn',
+      multisigInit: {
+        salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        threshold: 2,
+        owners: [
+          {
+            owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+            weight: 1,
+          },
+          {
+            owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+            weight: 1,
+          },
+        ],
+      },
+      multisigSignatureCount: 2,
+    } as const
+
+    const decoded = z.decode(z_TransactionRequest.TransactionRequest, {
+      ...rpc,
+      ...hints,
+    })
+    expect(decoded).toMatchObject(hints)
+
+    const encoded = z.encode(z_TransactionRequest.TransactionRequest, decoded)
+    expect(encoded).toMatchObject(hints)
+    expect(encoded).toEqual(core_TransactionRequest.toRpc(decoded))
+  })
+
+  test('feeToken is withheld until the fee payer signs (TIP-76)', () => {
+    const decoded = z.decode(z_TransactionRequest.TransactionRequest, rpc)
+    const pending = z.encode(z_TransactionRequest.TransactionRequest, {
+      ...decoded,
+      feePayer: true,
+    })
+    expect(pending.feeToken).toBeUndefined()
+    expect(pending.feePayer).toBe(true)
+  })
+
   test('rejects an invalid request', () => {
     expect(
       z.safeDecode(z_TransactionRequest.TransactionRequest, {