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

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,18 +1,27 @@
+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'
 import type { Compute } from '../core/internal/types.js'
 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.
  *
@@ -34,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
@@ -195,12 +208,28 @@ export declare namespace fromRpc {
  * @param request - The request to convert.
  * @returns An RPC request.
  */
-export function toRpc(request: TransactionRequest): Rpc {
+export function toRpc(request: toRpc.Input): Rpc {
   const request_rpc = ox_TransactionRequest.toRpc({
     ...request,
     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,
@@ -212,46 +241,57 @@ export function toRpc(request: TransactionRequest): Rpc {
   if (request.calls)
     request_rpc.calls = request.calls.map((call) => ({
       to: call.to,
-      value: call.value ? Hex.fromNumber(call.value) : '0x',
+      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,
-        value: request.value ? Hex.fromNumber(request.value) : '0x',
+        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 = Hex.fromNumber(request.validBefore)
+    request_rpc.validBefore = Quantity.fromNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
-    request_rpc.validAfter = Hex.fromNumber(request.validAfter)
+    request_rpc.validAfter = Quantity.fromNumberish(request.validAfter)
 
   const nonceKey = (() => {
     if (request.nonceKey === 'random') return Hex.random(24)
-    if (typeof request.nonceKey === 'bigint')
-      return Hex.fromNumber(request.nonceKey)
+    if (request.nonceKey !== undefined)
+      return Quantity.fromNumberish(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 = Transaction.toRpcType.tempo
     delete request_rpc.data
     delete request_rpc.input
@@ -263,6 +303,12 @@ export function toRpc(request: TransactionRequest): Rpc {
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#TransactionRequest.(toRpc:function)}. */
+  export type Input = TransactionRequest<
+    Hex.Hex | bigint | number,
+    Hex.Hex | number
+  >
+
   export type ErrorType =
     | AuthorizationTempo.toRpcList.ErrorType
     | Hex.fromNumber.ErrorType
@@ -299,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 = (() => {
@@ -335,7 +380,9 @@ export function toEnvelope(
       : {}),
     ...(typeof request.feePayerSignature !== 'undefined'
       ? { feePayerSignature: request.feePayerSignature }
-      : {}),
+      : request.feePayer
+        ? { feePayerSignature: null }
+        : {}),
     ...(typeof request.feeToken !== 'undefined'
       ? { feeToken: request.feeToken }
       : {}),
@@ -380,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(

package/src/tempo/TxEnvelopeTempo.ts

@@ -17,7 +17,6 @@ import * as TransactionEnvelope from '../core/TxEnvelope.js'
 import * as AuthorizationTempo from './AuthorizationTempo.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
-import * as TokenId from './TokenId.js'
 import type * as TransactionRequest from './TransactionRequest.js'
 
 /**
@@ -87,8 +86,8 @@ export type TxEnvelopeTempo<
     gas?: bigintType | undefined
     /** Fee payer signature. */
     feePayerSignature?: Signature.Signature<true, numberType> | null | undefined
-    /** Fee token preference. Address or ID of the TIP-20 token. */
-    feeToken?: TokenId.TokenIdOrAddress | undefined
+    /** Fee token preference. Address of the TIP-20 token. */
+    feeToken?: Address.Address | undefined
     /**
      * Key authorization for provisioning a new access key.
      *
@@ -173,6 +172,7 @@ export function assert(envelope: PartialBy<TxEnvelopeTempo, 'type'>) {
   const {
     calls,
     chainId,
+    feeToken,
     maxFeePerGas,
     maxPriorityFeePerGas,
     validBefore,
@@ -199,6 +199,9 @@ export function assert(envelope: PartialBy<TxEnvelopeTempo, 'type'>) {
     for (const call of calls)
       if (call.to) Address.assert(call.to, { strict: false })
 
+  // Validate fee token
+  if (feeToken) Address.assert(feeToken, { strict: false })
+
   // Validate chain ID
   if (chainId <= 0)
     throw new TransactionEnvelope.InvalidChainIdError({ chainId })
@@ -719,10 +722,7 @@ export function serialize(
     nonce ? Hex.fromNumber(nonce) : '0x',
     typeof validBefore === 'number' ? Hex.fromNumber(validBefore) : '0x',
     typeof validAfter === 'number' ? Hex.fromNumber(validAfter) : '0x',
-    !skipFeeToken &&
-    (typeof feeToken === 'bigint' || typeof feeToken === 'string')
-      ? TokenId.toAddress(feeToken)
-      : '0x',
+    !skipFeeToken && feeToken ? feeToken : '0x',
     feePayerSignatureOrSender,
     authorizationTupleList,
     ...(keyAuthorization ? [KeyAuthorization.toTuple(keyAuthorization)] : []),