ox 1.0.0-beta.8 → 1.0.0

package/src/tempo/Transaction.ts

@@ -103,18 +103,40 @@ export type Tempo<
 export type TempoRpc<pending extends boolean = false> = Compute<
   Omit<
     Tempo<pending, Hex.Hex, Hex.Hex, ToRpcType['tempo']>,
-    'authorizationList' | 'calls' | 'keyAuthorization' | 'signature'
+    | 'authorizationList'
+    | 'calls'
+    | 'feePayerSignature'
+    | 'gasPrice'
+    | 'keyAuthorization'
+    | 'nonceKey'
+    | 'signature'
+    | 'validAfter'
+    | 'validBefore'
   > & {
     aaAuthorizationList?: AuthorizationTempo.ListRpc | undefined
     calls:
       | readonly {
-          input?: Hex.Hex | undefined
-          to?: Hex.Hex | undefined
-          value?: Hex.Hex | undefined
+          data?: Hex.Hex | null | undefined
+          input?: Hex.Hex | null | undefined
+          to?: Hex.Hex | null | undefined
+          value?: Hex.Hex | null | undefined
         }[]
       | undefined
-    keyAuthorization?: KeyAuthorization.Rpc | undefined
+    feePayerSignature?:
+      | {
+          r: Hex.Hex
+          s: Hex.Hex
+          v?: Hex.Hex | undefined
+          yParity: Hex.Hex
+        }
+      | null
+      | undefined
+    gasPrice?: Hex.Hex | null | undefined
+    keyAuthorization?: KeyAuthorization.Rpc | null | undefined
+    nonceKey?: Hex.Hex | null | undefined
     signature: SignatureEnvelope.SignatureEnvelopeRpc
+    validAfter?: Hex.Hex | null | undefined
+    validBefore?: Hex.Hex | null | undefined
   }
 >
 
@@ -199,19 +221,26 @@ export function fromRpc<
     transaction as ox_Transaction.Rpc<pending>,
   ) as Transaction<pending>
 
-  transaction_.type = fromRpcType[transaction.type as keyof typeof fromRpcType]
+  if (transaction.type !== '0x76') return transaction_ as never
+
+  transaction_.type = 'tempo'
 
-  if (transaction.aaAuthorizationList) {
+  // Tempo transactions carry `calls`; scrub the flat call fields the generic
+  // decoder fabricates.
+  delete (transaction_ as any).data
+  delete (transaction_ as any).input
+  delete (transaction_ as any).to
+  delete (transaction_ as any).value
+
+  if (transaction.aaAuthorizationList?.length)
     transaction_.authorizationList = AuthorizationTempo.fromRpcList(
       transaction.aaAuthorizationList,
     )
-    delete (transaction_ as any).aaAuthorizationList
-  }
+  delete (transaction_ as any).aaAuthorizationList
   if (transaction.calls)
     transaction_.calls = transaction.calls.map((call) => ({
-      to: call.to,
+      to: call.to ?? undefined,
       value: call.value && call.value !== '0x' ? BigInt(call.value) : undefined,
-      // @ts-expect-error
       data: call.input || call.data || '0x',
     }))
   if (transaction.feeToken) transaction_.feeToken = transaction.feeToken
@@ -235,6 +264,18 @@ export function fromRpc<
     )
   }
 
+  // The node serializes absent optional fields as `null`; scrub them.
+  for (const key of [
+    'feePayer',
+    'feePayerSignature',
+    'gasPrice',
+    'keyAuthorization',
+    'nonceKey',
+    'validAfter',
+    'validBefore',
+  ] as const)
+    if ((transaction_ as any)[key] === null) delete (transaction_ as any)[key]
+
   return transaction_ as never
 }
 
@@ -300,7 +341,15 @@ export function toRpc<pending extends boolean = false>(
     transaction as ox_Transaction.Transaction<pending>,
   ) as Rpc<pending>
 
-  rpc.type = toRpcType[transaction.type as keyof typeof toRpcType]
+  if (transaction.type !== 'tempo') return rpc
+
+  rpc.type = '0x76'
+
+  // Tempo transactions carry `calls`; scrub the flat call fields the generic
+  // encoder fabricates.
+  delete (rpc as any).input
+  delete (rpc as any).to
+  delete (rpc as any).value
 
   if (transaction.authorizationList)
     rpc.aaAuthorizationList = AuthorizationTempo.toRpcList(
@@ -323,6 +372,8 @@ export function toRpc<pending extends boolean = false>(
       Signature.yParityToV(Number(transaction.feePayerSignature.yParity)),
     )
   }
+  if (transaction.nonceKey !== undefined)
+    rpc.nonceKey = Quantity.fromNumberish(transaction.nonceKey)
   if (transaction.signature)
     rpc.signature = SignatureEnvelope.toRpc(transaction.signature)
   if (transaction.validAfter !== undefined)

package/src/tempo/TransactionReceipt.test.ts

@@ -0,0 +1,76 @@
+import { TransactionReceipt } from 'ox/tempo'
+import { describe, expect, test } from 'vite-plus/test'
+
+const rpc = {
+  blockHash:
+    '0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b',
+  blockNumber: '0x12f296f',
+  contractAddress: null,
+  cumulativeGasUsed: '0x82515',
+  effectiveGasPrice: '0x21c2f6c09',
+  feePayer: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+  feeToken: '0x20c0000000000000000000000000000000000001',
+  from: '0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6',
+  gasUsed: '0x2abba',
+  logs: [],
+  logsBloom: `0x${'00'.repeat(256)}`,
+  status: '0x1',
+  to: '0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad',
+  transactionHash:
+    '0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0',
+  transactionIndex: '0x2',
+  type: '0x76',
+} as const satisfies TransactionReceipt.Rpc
+
+describe('fromRpc', () => {
+  test('default', () => {
+    const receipt = TransactionReceipt.fromRpc(rpc)
+    expect(receipt).toMatchInlineSnapshot(`
+      {
+        "blobGasPrice": undefined,
+        "blobGasUsed": undefined,
+        "blockHash": "0xc350d807505fb835650f0013632c5515592987ba169bbc6626d9fc54d91f0f0b",
+        "blockNumber": 19868015n,
+        "contractAddress": null,
+        "cumulativeGasUsed": 533781n,
+        "effectiveGasPrice": 9062804489n,
+        "feePayer": "0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6",
+        "feeToken": "0x20c0000000000000000000000000000000000001",
+        "from": "0x814e5e0e31016b9a7f138c76b7e7b2bb5c1ab6a6",
+        "gasUsed": 175034n,
+        "logs": [],
+        "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        "status": "success",
+        "to": "0x3fc91a3afd70395cd496c647d5a6cc9d4b2b7fad",
+        "transactionHash": "0x353fdfc38a2f26115daadee9f5b8392ce62b84f410957967e2ed56b35338cdd0",
+        "transactionIndex": 2,
+        "type": "tempo",
+      }
+    `)
+  })
+
+  test('behavior: non-tempo type passes through the generic mapping', () => {
+    const receipt = TransactionReceipt.fromRpc({ ...rpc, type: '0x2' })
+    expect(receipt.type).toBe('eip1559')
+  })
+
+  test('behavior: null', () => {
+    expect(TransactionReceipt.fromRpc(null)).toBeNull()
+  })
+})
+
+describe('toRpc', () => {
+  test('default', () => {
+    const receipt = TransactionReceipt.fromRpc(rpc)
+    const encoded = TransactionReceipt.toRpc(receipt)
+    expect(encoded.type).toBe('0x76')
+    expect(encoded.feePayer).toBe(rpc.feePayer)
+    expect(encoded.feeToken).toBe(rpc.feeToken)
+    expect(TransactionReceipt.fromRpc(encoded)).toEqual(receipt)
+  })
+
+  test('behavior: non-tempo type passes through the generic mapping', () => {
+    const receipt = TransactionReceipt.fromRpc({ ...rpc, type: '0x2' })
+    expect(TransactionReceipt.toRpc(receipt).type).toBe('0x2')
+  })
+})

package/src/tempo/TransactionReceipt.ts

@@ -13,7 +13,7 @@ import * as ox_TransactionReceipt from '../core/TransactionReceipt.js'
  */
 export type TransactionReceipt<
   status = ox_TransactionReceipt.Status,
-  type = ox_TransactionReceipt.Type,
+  type = Type,
   bigintType = bigint,
   numberType = number,
 > = Compute<
@@ -32,7 +32,7 @@ export type TransactionReceipt<
 
 export type Rpc = TransactionReceipt<
   ox_TransactionReceipt.RpcStatus,
-  ox_TransactionReceipt.RpcType,
+  RpcType,
   Hex.Hex,
   Hex.Hex
 >
@@ -118,9 +118,14 @@ export const toRpcType = {
 export function fromRpc<const receipt extends Rpc | null>(
   receipt: receipt | Rpc | null,
 ): receipt extends Rpc ? TransactionReceipt : null {
-  return ox_TransactionReceipt.fromRpc(
+  const decoded = ox_TransactionReceipt.fromRpc(
     receipt as ox_TransactionReceipt.Rpc,
-  ) as never
+  )
+  if (!decoded) return null as never
+  return {
+    ...decoded,
+    type: (fromRpcType as any)[receipt!.type] ?? receipt!.type,
+  } as never
 }
 
 export declare namespace fromRpc {
@@ -192,6 +197,7 @@ export function toRpc(receipt: toRpc.Input): Rpc {
     ...rpc,
     feePayer: receipt.feePayer,
     feeToken: receipt.feeToken,
+    type: (toRpcType as any)[receipt.type] ?? receipt.type,
   }
 }
 
@@ -199,7 +205,7 @@ export declare namespace toRpc {
   /** Numberish input accepted by {@link ox#TransactionReceipt.(toRpc:function)}. */
   export type Input = TransactionReceipt<
     ox_TransactionReceipt.Status,
-    ox_TransactionReceipt.Type,
+    Type,
     Hex.Hex | bigint | number,
     Hex.Hex | number
   >

package/src/tempo/TransactionRequest.test.ts

@@ -69,6 +69,40 @@ describe('fromRpc', () => {
     expect(request.nonceKey).toBe(255n)
   })
 
+  test('behavior: gas-model hints and capabilities pass through', () => {
+    const request = TransactionRequest.fromRpc({
+      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe' }],
+      capabilities: { balanceDiffs: true },
+      feePayer: true,
+      keyData: '0x0578',
+      keyId: '0xcccccccccccccccccccccccccccccccccccccccc',
+      keyType: 'webAuthn',
+      multisigInit: {
+        salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        threshold: 2,
+        owners: [
+          {
+            owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+            weight: 1,
+          },
+          {
+            owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+            weight: 1,
+          },
+        ],
+      },
+      multisigSignatureCount: 2,
+      type: '0x76',
+    })
+    expect(request.capabilities).toEqual({ balanceDiffs: true })
+    expect(request.feePayer).toBe(true)
+    expect(request.keyData).toBe('0x0578')
+    expect(request.keyId).toBe('0xcccccccccccccccccccccccccccccccccccccccc')
+    expect(request.keyType).toBe('webAuthn')
+    expect(request.multisigInit).toMatchObject({ threshold: 2 })
+    expect(request.multisigSignatureCount).toBe(2)
+  })
+
   test('behavior: empty', () => {
     const request = TransactionRequest.fromRpc({})
     expect(request).toMatchInlineSnapshot('{}')
@@ -123,6 +157,101 @@ describe('toRpc', () => {
     `)
   })
 
+  test('behavior: gas-model hints and capabilities are carried', () => {
+    const request = TransactionRequest.toRpc({
+      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe' }],
+      capabilities: { balanceDiffs: true },
+      feePayer: false,
+      keyData: '0x0578',
+      keyId: '0xcccccccccccccccccccccccccccccccccccccccc',
+      keyType: 'webAuthn',
+      multisigInit: {
+        salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        threshold: 2,
+        owners: [
+          {
+            owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+            weight: 1,
+          },
+          {
+            owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+            weight: 1,
+          },
+        ],
+      },
+      multisigSignatureCount: 2,
+    })
+    expect(request.capabilities).toEqual({ balanceDiffs: true })
+    expect(request.feePayer).toBe(false)
+    expect(request.keyData).toBe('0x0578')
+    expect(request.keyId).toBe('0xcccccccccccccccccccccccccccccccccccccccc')
+    expect(request.keyType).toBe('webAuthn')
+    expect(request.multisigInit).toMatchObject({ threshold: 2 })
+    expect(request.multisigSignatureCount).toBe(2)
+    expect(request.type).toBe('0x76')
+  })
+
+  test('behavior: key data longer than 4 bytes shims into a length hint', () => {
+    const request = TransactionRequest.toRpc({
+      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe' }],
+      keyData: `0x${'aa'.repeat(1400)}`,
+      keyType: 'webAuthn',
+    })
+    // 1400 bytes -> 0x0578 big-endian length hint.
+    expect(request.keyData).toBe('0x0578')
+  })
+
+  test('behavior: feeToken is withheld until the fee payer signs (TIP-76)', () => {
+    const pending = TransactionRequest.toRpc({
+      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe' }],
+      feePayer: true,
+      feeToken: '0x20c0000000000000000000000000000000000000',
+    })
+    expect(pending.feeToken).toBeUndefined()
+    expect(pending.feePayer).toBe(true)
+
+    const signed = TransactionRequest.toRpc({
+      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe' }],
+      feePayer: true,
+      feePayerSignature: {
+        r: '0x0000000000000000000000000000000000000000000000000000000000000001',
+        s: '0x0000000000000000000000000000000000000000000000000000000000000002',
+        yParity: 1,
+      },
+      feeToken: '0x20c0000000000000000000000000000000000000',
+    })
+    expect(signed.feeToken).toBe('0x20c0000000000000000000000000000000000000')
+  })
+
+  test('behavior: data-less call defaults to the zero address', () => {
+    const flat = TransactionRequest.toRpc({
+      feeToken: '0x20c0000000000000000000000000000000000000',
+      value: 100n,
+    })
+    expect(flat.calls).toMatchInlineSnapshot(`
+      [
+        {
+          "data": "0x",
+          "to": "0x0000000000000000000000000000000000000000",
+          "value": "0x64",
+        },
+      ]
+    `)
+
+    const bare = TransactionRequest.toRpc({
+      feeToken: '0x20c0000000000000000000000000000000000000',
+    })
+    expect(bare.calls).toMatchInlineSnapshot(`
+      [
+        {
+          "data": "0x",
+          "to": "0x0000000000000000000000000000000000000000",
+          "value": "0x",
+        },
+      ]
+    `)
+  })
+
   test("behavior: nonceKey 'random' generates a 192-bit value", () => {
     const request = TransactionRequest.toRpc({
       calls: [
@@ -311,9 +440,53 @@ describe('toEnvelope', () => {
     expect(envelope.validAfter).toBe(100)
   })
 
-  test('error: empty calls throws via envelope assert', () => {
+  test('behavior: data-less request defaults to a zero-address call', () => {
+    const envelope = TransactionRequest.toEnvelope({
+      chainId: 1,
+      maxFeePerGas: 1n,
+    })
+    expect(envelope.calls).toEqual([
+      { to: '0x0000000000000000000000000000000000000000' },
+    ])
+  })
+
+  test('behavior: feePayer marks the envelope as pending a fee payer signature (TIP-76)', () => {
+    const envelope = TransactionRequest.toEnvelope({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId: 1,
+      feePayer: true,
+      feeToken: '0x20c0000000000000000000000000000000000000',
+      maxFeePerGas: 1n,
+    })
+    expect(envelope.feePayerSignature).toBeNull()
+
+    // An explicit fee payer signature wins over the marker.
+    const signed = TransactionRequest.toEnvelope({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId: 1,
+      feePayer: true,
+      feePayerSignature: {
+        r: '0x0000000000000000000000000000000000000000000000000000000000000001',
+        s: '0x0000000000000000000000000000000000000000000000000000000000000002',
+        yParity: 1,
+      },
+      maxFeePerGas: 1n,
+    })
+    expect(signed.feePayerSignature).not.toBeNull()
+
+    // No fee payer, no marker.
+    const plain = TransactionRequest.toEnvelope({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId: 1,
+      maxFeePerGas: 1n,
+    })
+    expect(plain.feePayerSignature).toBeUndefined()
+  })
+
+  test('error: explicit empty calls throws via envelope assert', () => {
     expect(() =>
       TransactionRequest.toEnvelope({
+        calls: [],
         chainId: 1,
         maxFeePerGas: 1n,
       }),

package/src/tempo/TransactionRequest.ts

@@ -1,3 +1,4 @@
+import type * as Address from '../core/Address.js'
 import type * as Errors from '../core/Errors.js'
 import * as Hex from '../core/Hex.js'
 import * as Quantity from '../core/internal/quantity.js'
@@ -6,14 +7,21 @@ import * as Signature from '../core/Signature.js'
 import * as ox_TransactionRequest from '../core/TransactionRequest.js'
 import * as AuthorizationTempo from './AuthorizationTempo.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
+import type * as MultisigConfig from './MultisigConfig.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
-import * as TokenId from './TokenId.js'
 import * as Transaction from './Transaction.js'
 import * as TxEnvelopeTempo from './TxEnvelopeTempo.js'
 import type { Call } from './TxEnvelopeTempo.js'
 
 type KeyType = 'secp256k1' | 'p256' | 'webAuthn'
 
+/**
+ * Bootstrap multisig config hint for node-side gas modeling (TIP-1061).
+ * The node prices multisig gas from it during simulation, and ignores it
+ * for registered senders.
+ */
+export type MultisigInit = Compute<MultisigConfig.Config & { salt: Hex.Hex }>
+
 /**
  * A Transaction Request that is generic to all transaction types.
  *
@@ -35,12 +43,16 @@ export type TransactionRequest<
       | AuthorizationTempo.ListSigned<bigintType, numberType>
       | undefined
     calls?: readonly Call<bigintType>[] | undefined
+    capabilities?: Record<string, unknown> | undefined
     feePayerSignature?: Signature.Signature<true, numberType> | null | undefined
     keyAuthorization?: KeyAuthorization.KeyAuthorization<true> | undefined
     keyData?: Hex.Hex | undefined
+    keyId?: Address.Address | undefined
     keyType?: KeyType | undefined
     feePayer?: boolean | undefined
-    feeToken?: TokenId.TokenIdOrAddress | undefined
+    feeToken?: Address.Address | undefined
+    multisigInit?: MultisigInit | undefined
+    multisigSignatureCount?: number | undefined
     nonceKey?: 'random' | bigintType | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<numberType> | undefined
     validBefore?: numberType | undefined
@@ -202,6 +214,22 @@ export function toRpc(request: toRpc.Input): Rpc {
     authorizationList: undefined,
   }) as 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 = AuthorizationTempo.toRpcList(
       request.authorizationList,
@@ -216,20 +244,40 @@ export function toRpc(request: toRpc.Input): Rpc {
       value: call.value ? Quantity.fromNumberish(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 ? Quantity.fromNumberish(request.value) : '0x',
         data: request.data ?? '0x',
       },
     ]
-  if (typeof request.feeToken !== 'undefined')
-    request_rpc.feeToken = TokenId.toAddress(request.feeToken)
+  if (
+    typeof request.feeToken !== 'undefined' &&
+    !(request.feePayer === true && !request.feePayerSignature)
+  )
+    request_rpc.feeToken = request.feeToken
   if (request.keyAuthorization)
     request_rpc.keyAuthorization = KeyAuthorization.toRpc(
       request.keyAuthorization,
     )
+  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 = Quantity.fromNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -243,16 +291,7 @@ export function toRpc(request: toRpc.Input): Rpc {
   })()
   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 = Transaction.toRpcType.tempo
     delete request_rpc.data
     delete request_rpc.input
@@ -306,21 +345,20 @@ export function toEnvelope(
 ): TxEnvelopeTempo.TxEnvelopeTempo {
   const calls = (() => {
     if (request.calls) return request.calls
-    if (request.to || request.data || request.value)
-      return [
-        {
-          ...(typeof request.to !== 'undefined' && request.to !== null
-            ? { to: request.to }
-            : {}),
-          ...(typeof request.data !== 'undefined'
-            ? { data: request.data }
-            : {}),
-          ...(typeof request.value !== 'undefined'
-            ? { value: request.value }
-            : {}),
-        },
-      ] satisfies readonly Call[]
-    return [] as readonly Call[]
+    const to =
+      request.to ||
+      (!request.data || request.data === '0x'
+        ? '0x0000000000000000000000000000000000000000'
+        : undefined)
+    return [
+      {
+        ...(typeof to !== 'undefined' ? { to } : {}),
+        ...(typeof request.data !== 'undefined' ? { data: request.data } : {}),
+        ...(typeof request.value !== 'undefined'
+          ? { value: request.value }
+          : {}),
+      },
+    ] satisfies readonly Call[]
   })()
 
   const nonceKey = (() => {
@@ -342,7 +380,9 @@ export function toEnvelope(
       : {}),
     ...(typeof request.feePayerSignature !== 'undefined'
       ? { feePayerSignature: request.feePayerSignature }
-      : {}),
+      : request.feePayer
+        ? { feePayerSignature: null }
+        : {}),
     ...(typeof request.feeToken !== 'undefined'
       ? { feeToken: request.feeToken }
       : {}),
@@ -387,3 +427,15 @@ export declare namespace toEnvelope {
     | Hex.toBigInt.ErrorType
     | Errors.GlobalErrorType
 }
+
+/**
+ * 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 as a
+ * signature-size hint; anything else silently falls back to the default.
+ * @internal
+ */
+function shimKeyData(data: Hex.Hex): Hex.Hex {
+  const byteLength = Hex.size(data)
+  if (byteLength <= 4) return data
+  return Hex.fromNumber(byteLength, { size: 2 })
+}

package/src/tempo/TxEnvelopeTempo.test.ts

@@ -1464,7 +1464,7 @@ describe('encodeForSigning', () => {
         },
       ],
       feePayerSignature: null,
-      feeToken: 1n,
+      feeToken: '0x20c0000000000000000000000000000000000001',
       nonce: 0n,
     })
     const signature = Secp256k1.sign({
@@ -1485,7 +1485,7 @@ describe('encodeForSigning', () => {
     const sponsored = TxEnvelopeTempo.from({
       ...signed,
       feePayerSignature,
-      feeToken: 2n,
+      feeToken: '0x20c0000000000000000000000000000000000002',
     })
 
     expect(TxEnvelopeTempo.encodeForSigning(sponsored)).toBe(