ox 1.7.1 → 1.7.2

package/src/tempo/TransactionRequest.test-d.ts

@@ -1,6 +1,7 @@
 import type * as ox_TransactionRequest from '../core/TransactionRequest.js'
 import * as Signature from '../core/Signature.js'
 import { describe, expectTypeOf, test } from 'vp/test'
+import * as MultisigWitness from './MultisigWitness.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 import * as TransactionRequest from './TransactionRequest.js'
 import * as TxEnvelopeTempo from './TxEnvelopeTempo.js'
@@ -47,6 +48,15 @@ describe('TransactionRequest type', () => {
       Signature.Rpc | null | undefined
     >()
   })
+
+  test('carries domain and RPC multisig witnesses', () => {
+    expectTypeOf<
+      TransactionRequest.TransactionRequest['multisigWitness']
+    >().toEqualTypeOf<MultisigWitness.MultisigWitness | undefined>()
+    expectTypeOf<TransactionRequest.Rpc['multisigWitness']>().toEqualTypeOf<
+      MultisigWitness.Rpc | undefined
+    >()
+  })
 })
 
 describe('toEnvelope', () => {
@@ -77,6 +87,7 @@ describe('toEnvelope', () => {
       keyType: 'secp256k1',
       maxFeePerGas: 1n,
       maxPriorityFeePerGas: 1n,
+      multisigWitness: undefined,
       nonce: 0n,
       nonceKey: 'random',
       signature: undefined,

package/src/tempo/TransactionRequest.test.ts

@@ -69,7 +69,7 @@ describe('fromRpc', () => {
     expect(request.nonceKey).toBe(255n)
   })
 
-  test('behavior: gas-model hints and capabilities pass through', () => {
+  test('behavior: capabilities and key hints pass through', () => {
     const request = TransactionRequest.fromRpc({
       calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe' }],
       capabilities: { balanceDiffs: true },
@@ -77,30 +77,156 @@ describe('fromRpc', () => {
       keyData: '0x0578',
       keyId: '0xcccccccccccccccccccccccccccccccccccccccc',
       keyType: 'webAuthn',
-      multisigInit: {
-        salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-        threshold: 2,
-        owners: [
+      type: '0x76',
+    })
+    expect(request).toMatchInlineSnapshot(`
+      {
+        "calls": [
+          {
+            "data": undefined,
+            "to": "0xcafebabecafebabecafebabecafebabecafebabe",
+          },
+        ],
+        "capabilities": {
+          "balanceDiffs": true,
+        },
+        "feePayer": true,
+        "keyData": "0x0578",
+        "keyId": "0xcccccccccccccccccccccccccccccccccccccccc",
+        "keyType": "webAuthn",
+        "type": "tempo",
+      }
+    `)
+  })
+
+  test('behavior: multisig witness configs decode from RPC numbers', () => {
+    const request = TransactionRequest.fromRpc({
+      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe' }],
+      multisigWitness: {
+        account: '0xcccccccccccccccccccccccccccccccccccccccc',
+        approvals: [
           {
+            keyData: '0x0578',
+            keyType: 'webAuthn',
             owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-            weight: 1,
+            type: 'primitive',
           },
           {
-            owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-            weight: 1,
+            type: 'multisig',
+            witness: {
+              account: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+              approvals: [
+                {
+                  keyType: 'secp256k1',
+                  owner: '0xdddddddddddddddddddddddddddddddddddddddd',
+                },
+                {
+                  owner: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+                },
+              ],
+              config: {
+                owners: [
+                  {
+                    owner: '0xdddddddddddddddddddddddddddddddddddddddd',
+                    weight: 1,
+                  },
+                  {
+                    owner: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+                    weight: 1,
+                  },
+                ],
+                salt: '0x2222222222222222222222222222222222222222222222222222222222222222',
+                threshold: 2,
+                version: 2,
+              },
+            },
           },
         ],
+        config: {
+          owners: [
+            {
+              owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+              weight: 1,
+            },
+            {
+              owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+              weight: 1,
+            },
+          ],
+          salt: '0x1111111111111111111111111111111111111111111111111111111111111111',
+          threshold: 2,
+          version: 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)
+    expect(request).toMatchInlineSnapshot(`
+      {
+        "calls": [
+          {
+            "data": undefined,
+            "to": "0xcafebabecafebabecafebabecafebabecafebabe",
+          },
+        ],
+        "multisigWitness": {
+          "account": "0xcccccccccccccccccccccccccccccccccccccccc",
+          "approvals": [
+            {
+              "keyData": "0x0578",
+              "keyType": "webAuthn",
+              "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+              "type": "primitive",
+            },
+            {
+              "type": "multisig",
+              "witness": {
+                "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                "approvals": [
+                  {
+                    "keyType": "secp256k1",
+                    "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
+                  },
+                  {
+                    "owner": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                  },
+                ],
+                "config": {
+                  "owners": [
+                    {
+                      "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
+                      "weight": 1,
+                    },
+                    {
+                      "owner": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                      "weight": 1,
+                    },
+                  ],
+                  "salt": "0x2222222222222222222222222222222222222222222222222222222222222222",
+                  "threshold": 2,
+                  "version": 2n,
+                },
+              },
+            },
+          ],
+          "config": {
+            "owners": [
+              {
+                "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                "weight": 1,
+              },
+              {
+                "owner": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                "weight": 1,
+              },
+            ],
+            "salt": "0x1111111111111111111111111111111111111111111111111111111111111111",
+            "threshold": 2,
+            "version": 1n,
+          },
+        },
+        "type": "tempo",
+      }
+    `)
   })
 
   test('behavior: empty', () => {
@@ -157,7 +283,7 @@ describe('toRpc', () => {
     `)
   })
 
-  test('behavior: gas-model hints and capabilities are carried', () => {
+  test('behavior: capabilities and key hints are carried', () => {
     const request = TransactionRequest.toRpc({
       calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe' }],
       capabilities: { balanceDiffs: true },
@@ -165,30 +291,156 @@ describe('toRpc', () => {
       keyData: '0x0578',
       keyId: '0xcccccccccccccccccccccccccccccccccccccccc',
       keyType: 'webAuthn',
-      multisigInit: {
-        salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-        threshold: 2,
-        owners: [
+    })
+    expect(request).toMatchInlineSnapshot(`
+      {
+        "calls": [
+          {
+            "data": "0x",
+            "to": "0xcafebabecafebabecafebabecafebabecafebabe",
+            "value": "0x",
+          },
+        ],
+        "capabilities": {
+          "balanceDiffs": true,
+        },
+        "feePayer": false,
+        "keyData": "0x0578",
+        "keyId": "0xcccccccccccccccccccccccccccccccccccccccc",
+        "keyType": "webAuthn",
+        "type": "0x76",
+      }
+    `)
+  })
+
+  test('behavior: multisig witness configs encode as RPC numbers', () => {
+    const request = TransactionRequest.toRpc({
+      calls: [{ to: '0xcafebabecafebabecafebabecafebabecafebabe' }],
+      multisigWitness: {
+        account: '0xcccccccccccccccccccccccccccccccccccccccc',
+        approvals: [
           {
+            keyData: '0x0578',
+            keyType: 'webAuthn',
             owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-            weight: 1,
+            type: 'primitive',
           },
           {
-            owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-            weight: 1,
+            type: 'multisig',
+            witness: {
+              account: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+              approvals: [
+                {
+                  keyType: 'secp256k1',
+                  owner: '0xdddddddddddddddddddddddddddddddddddddddd',
+                },
+                {
+                  owner: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+                },
+              ],
+              config: {
+                owners: [
+                  {
+                    owner: '0xdddddddddddddddddddddddddddddddddddddddd',
+                    weight: 1,
+                  },
+                  {
+                    owner: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+                    weight: 1,
+                  },
+                ],
+                salt: '0x2222222222222222222222222222222222222222222222222222222222222222',
+                threshold: 2,
+                version: 2n,
+              },
+            },
           },
         ],
+        config: {
+          owners: [
+            {
+              owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+              weight: 1,
+            },
+            {
+              owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+              weight: 1,
+            },
+          ],
+          salt: '0x1111111111111111111111111111111111111111111111111111111111111111',
+          threshold: 2,
+          version: 1n,
+        },
       },
-      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')
+    expect(request).toMatchInlineSnapshot(`
+      {
+        "calls": [
+          {
+            "data": "0x",
+            "to": "0xcafebabecafebabecafebabecafebabecafebabe",
+            "value": "0x",
+          },
+        ],
+        "multisigWitness": {
+          "account": "0xcccccccccccccccccccccccccccccccccccccccc",
+          "approvals": [
+            {
+              "keyData": "0x0578",
+              "keyType": "webAuthn",
+              "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+              "type": "primitive",
+            },
+            {
+              "type": "multisig",
+              "witness": {
+                "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                "approvals": [
+                  {
+                    "keyType": "secp256k1",
+                    "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
+                  },
+                  {
+                    "owner": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                  },
+                ],
+                "config": {
+                  "owners": [
+                    {
+                      "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
+                      "weight": 1,
+                    },
+                    {
+                      "owner": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+                      "weight": 1,
+                    },
+                  ],
+                  "salt": "0x2222222222222222222222222222222222222222222222222222222222222222",
+                  "threshold": 2,
+                  "version": 2,
+                },
+              },
+            },
+          ],
+          "config": {
+            "owners": [
+              {
+                "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+                "weight": 1,
+              },
+              {
+                "owner": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+                "weight": 1,
+              },
+            ],
+            "salt": "0x1111111111111111111111111111111111111111111111111111111111111111",
+            "threshold": 2,
+            "version": 1,
+          },
+        },
+        "type": "0x76",
+      }
+    `)
   })
 
   test('behavior: key data longer than 4 bytes shims into a length hint', () => {

package/src/tempo/TransactionRequest.ts

@@ -7,7 +7,7 @@ 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 MultisigWitness from './MultisigWitness.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 import * as Transaction from './Transaction.js'
 import * as TxEnvelopeTempo from './TxEnvelopeTempo.js'
@@ -15,13 +15,6 @@ 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.
  *
@@ -44,19 +37,18 @@ export type TransactionRequest<
       | undefined
     calls?: readonly Call<bigintType>[] | undefined
     capabilities?: Record<string, unknown> | undefined
+    feePayer?: boolean | undefined
     feePayerSignature?: Signature.Signature<true, numberType> | null | undefined
+    feeToken?: Address.Address | undefined
     keyAuthorization?: KeyAuthorization.KeyAuthorization<true> | undefined
     keyData?: Hex.Hex | undefined
     keyId?: Address.Address | undefined
     keyType?: KeyType | undefined
-    feePayer?: boolean | undefined
-    feeToken?: Address.Address | undefined
-    multisigInit?: MultisigInit | undefined
-    multisigSignatureCount?: number | undefined
+    multisigWitness?: MultisigWitness.MultisigWitness | undefined
     nonceKey?: 'random' | bigintType | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<numberType> | undefined
-    validBefore?: numberType | undefined
     validAfter?: numberType | undefined
+    validBefore?: numberType | undefined
   }
 >
 
@@ -67,12 +59,14 @@ export type Rpc = Omit<
   | 'feePayerSignature'
   | 'feeToken'
   | 'keyAuthorization'
+  | 'multisigWitness'
   | 'signature'
 > & {
   authorizationList?: AuthorizationTempo.ListRpc | undefined
   feePayerSignature?: Signature.Rpc | null | undefined
   feeToken?: Hex.Hex | undefined
   keyAuthorization?: KeyAuthorization.Rpc | undefined
+  multisigWitness?: MultisigWitness.Rpc | undefined
   nonceKey?: Hex.Hex | undefined
   signature?: SignatureEnvelope.SignatureEnvelopeRpc | undefined
 }
@@ -100,7 +94,7 @@ export type Rpc = Omit<
  * @returns A transaction request.
  */
 export function fromRpc(request: Rpc): TransactionRequest {
-  const { authorizationList: _, ...rest } = request
+  const { authorizationList: _, multisigWitness: __, ...rest } = request
   const request_ = ox_TransactionRequest.fromRpc(
     rest as any,
   ) as TransactionRequest
@@ -135,6 +129,8 @@ export function fromRpc(request: Rpc): TransactionRequest {
     request_.keyAuthorization = KeyAuthorization.fromRpc(
       request.keyAuthorization,
     )
+  if (request.multisigWitness)
+    request_.multisigWitness = MultisigWitness.fromRpc(request.multisigWitness)
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = Hex.toNumber(request.validBefore as Hex.Hex)
   if (typeof request.validAfter !== 'undefined')
@@ -150,6 +146,7 @@ export declare namespace fromRpc {
     | AuthorizationTempo.fromRpcList.ErrorType
     | Hex.toNumber.ErrorType
     | Hex.toBigInt.ErrorType
+    | MultisigWitness.fromRpc.ErrorType
     | Errors.GlobalErrorType
 }
 
@@ -223,8 +220,7 @@ export function toRpc(request: toRpc.Input): Rpc {
     typeof request.keyData !== 'undefined' ||
     typeof request.keyId !== 'undefined' ||
     typeof request.keyType !== 'undefined' ||
-    typeof request.multisigInit !== 'undefined' ||
-    typeof request.multisigSignatureCount !== 'undefined' ||
+    typeof request.multisigWitness !== 'undefined' ||
     typeof request.nonceKey !== 'undefined' ||
     typeof request.validBefore !== 'undefined' ||
     typeof request.validAfter !== 'undefined' ||
@@ -274,10 +270,8 @@ export function toRpc(request: toRpc.Input): Rpc {
   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.multisigWitness !== 'undefined')
+    request_rpc.multisigWitness = MultisigWitness.toRpc(request.multisigWitness)
   if (typeof request.validBefore !== 'undefined')
     request_rpc.validBefore = Quantity.fromNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -312,6 +306,7 @@ export declare namespace toRpc {
   export type ErrorType =
     | AuthorizationTempo.toRpcList.ErrorType
     | Hex.fromNumber.ErrorType
+    | MultisigWitness.toRpc.ErrorType
     | Errors.GlobalErrorType
 }
 

package/src/tempo/TxEnvelopeTempo.test-d.ts

@@ -0,0 +1,7 @@
+import { expectTypeOf, test } from 'vp/test'
+import type * as TxEnvelopeTempo from './TxEnvelopeTempo.js'
+
+test('Serialized', () => {
+  expectTypeOf<'0x76'>().toExtend<TxEnvelopeTempo.Serialized>()
+  expectTypeOf<'0x78'>().toExtend<TxEnvelopeTempo.Serialized>()
+})

package/src/tempo/TxEnvelopeTempo.test.ts

@@ -138,6 +138,31 @@ describe('deserialize', () => {
     expect(deserialized).toEqual(transaction)
   })
 
+  test('fee payer', () => {
+    const serialized = TxEnvelopeTempo.serialize(transaction, {
+      format: 'feePayer',
+      sender: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+    })
+
+    expect(TxEnvelopeTempo.deserialize(serialized)).toMatchInlineSnapshot(`
+      {
+        "calls": [
+          {
+            "to": "0x70997970c51812dc3a010c7d01b50e0d17dc79c8",
+          },
+        ],
+        "chainId": 1,
+        "feePayerSignature": null,
+        "from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
+        "maxFeePerGas": 2000000000n,
+        "maxPriorityFeePerGas": 2000000000n,
+        "nonce": 785n,
+        "nonceKey": 0n,
+        "type": "tempo",
+      }
+    `)
+  })
+
   test('minimal', () => {
     const transaction = TxEnvelopeTempo.from({
       chainId: 1,

package/src/tempo/TxEnvelopeTempo.ts

@@ -134,7 +134,8 @@ export type Rpc<signed extends boolean = boolean> = TxEnvelopeTempo<
 export const feePayerMagic = '0x78' as const
 export type FeePayerMagic = typeof feePayerMagic
 
-export type Serialized = `${SerializedType}${string}`
+/** Serialized standard or fee-payer Tempo transaction. */
+export type Serialized = `${SerializedType | FeePayerMagic}${string}`
 
 export type Signed = TxEnvelopeTempo<true>
 
@@ -232,7 +233,7 @@ export declare namespace assert {
 }
 
 /**
- * Deserializes a {@link ox#TxEnvelopeTempo.TxEnvelopeTempo} from its serialized form.
+ * Deserializes a standard or fee-payer {@link ox#TxEnvelopeTempo.TxEnvelopeTempo}.
  *
  * @example
  * ```ts twoslash
@@ -254,7 +255,8 @@ export declare namespace assert {
  * @returns Deserialized Transaction Envelope.
  */
 export function deserialize(serialized: Serialized): Compute<TxEnvelopeTempo> {
-  if (Hex.slice(serialized, 0, 1) !== serializedType)
+  const prefix = Hex.slice(serialized, 0, 1)
+  if (prefix !== serializedType && prefix !== feePayerMagic)
     throw new TransactionEnvelope.InvalidSerializedError({
       attributes: {},
       serialized,

package/src/tempo/index.ts

@@ -173,6 +173,24 @@ export * as KeyAuthorization from './KeyAuthorization.js'
  * @category Reference
  */
 export * as MultisigConfig from './MultisigConfig.js'
+/**
+ * Offchain multisig transaction and key authorization operation utilities.
+ *
+ * Derives operation hashes, selects owner approvals, serializes transactions,
+ * validates operation state, and converts JSON-RPC representations.
+ *
+ * @category Reference
+ */
+export * as MultisigOperation from './MultisigOperation.js'
+/**
+ * Native multisig RPC simulation witness utilities.
+ *
+ * Converts complete root and nested owner witnesses between their domain and
+ * Tempo JSON-RPC representations.
+ *
+ * @category Reference
+ */
+export * as MultisigWitness from './MultisigWitness.js'
 /**
  * Utilities for constructing period durations (in seconds) for recurring spending limits.
  *
@@ -251,7 +269,7 @@ export * as PoolId from './PoolId.js'
  */
 export * as ReceivePolicyReceipt from './ReceivePolicyReceipt.js'
 /**
- * Union of all JSON-RPC Methods for the `tempo_` namespace.
+ * JSON-RPC schemas for the `tempo_` and `multisig_` namespaces.
  *
  * @example
  * ```ts twoslash
@@ -260,7 +278,9 @@ export * as ReceivePolicyReceipt from './ReceivePolicyReceipt.js'
  * import { RpcSchemaTempo } from 'ox/tempo'
  *
  * const schema = RpcSchema.from<
- *   RpcSchema.Default | RpcSchemaTempo.Tempo
+ *   | RpcSchema.Default
+ *   | RpcSchemaTempo.Multisig
+ *   | RpcSchemaTempo.Tempo
  * >()
  *
  * const provider = Provider.from(window.ethereum!, { schema })