ox 1.7.1 → 1.7.4

package/src/tempo/multisig.e2e.test.ts

@@ -2,14 +2,19 @@ import { AbiFunction, Address, Hex, Secp256k1, Value } from 'ox'
 import { getTransactionCount } from 'viem/actions'
 import { describe, expect, test } from 'vp/test'
 import { chain, client, fundAddress } from '../../test/tempo/config.js'
-import { KeyAuthorization, MultisigConfig, SignatureEnvelope } from './index.js'
+import {
+  KeyAuthorization,
+  MultisigConfig,
+  SignatureEnvelope,
+  TransactionRequest,
+} from './index.js'
 import * as Transaction from './Transaction.js'
 import * as TransactionReceipt from './TransactionReceipt.js'
 import * as TxEnvelopeTempo from './TxEnvelopeTempo.js'
 
 const chainId = chain.id
 const updateConfig = AbiFunction.from(
-  'function updateConfig(uint8 threshold, (address owner, uint8 weight)[] owners)',
+  'function updateConfig((bytes32 salt, uint64 version, uint8 threshold, (address owner, uint8 weight)[] owners) current, uint8 threshold, (address owner, uint8 weight)[] owners)',
 )
 
 describe('behavior: multisig (TIP-1061)', () => {
@@ -49,16 +54,21 @@ describe('behavior: multisig (TIP-1061)', () => {
   }
 
   function approve(parameters: {
-    initialConfig: MultisigConfig.Config
+    address?: Address.Address | undefined
+    config: MultisigConfig.Config
     payload: Hex.Hex
     signers: readonly { privateKey: Hex.Hex }[]
-    version?: bigint | undefined
   }) {
-    const { initialConfig, payload, signers, version = 0n } = parameters
+    const {
+      address = MultisigConfig.getAddress(parameters.config),
+      config,
+      payload,
+      signers,
+    } = parameters
     const digest = MultisigConfig.getSignPayload({
+      account: address,
+      config,
       payload,
-      initialConfig,
-      version,
     })
     const signatures = signers.map((signer) =>
       SignatureEnvelope.from(
@@ -67,25 +77,10 @@ describe('behavior: multisig (TIP-1061)', () => {
     )
     // The node requires approvals ordered by recovered owner address.
     return SignatureEnvelope.sortMultisigApprovals({
-      initialConfig,
+      account: address,
+      config,
       payload,
       signatures,
-      version,
-    })
-  }
-
-  function multisigSignature(parameters: {
-    initialConfig: MultisigConfig.Config
-    payload: Hex.Hex
-    signers: readonly { privateKey: Hex.Hex }[]
-    init?: boolean | undefined
-    version?: bigint | undefined
-  }) {
-    const { init = false, ...approval } = parameters
-    return SignatureEnvelope.from({
-      initialConfig: parameters.initialConfig,
-      ...(init ? { init: true } : {}),
-      signatures: approve(approval),
     })
   }
 
@@ -111,11 +106,14 @@ describe('behavior: multisig (TIP-1061)', () => {
     })
     const receipt = await send(
       TxEnvelopeTempo.serialize(transaction, {
-        signature: multisigSignature({
-          initialConfig: multisig.initialConfig,
-          init: true,
-          payload: TxEnvelopeTempo.getSignPayload(transaction),
-          signers: multisig.ownerKeys,
+        signature: SignatureEnvelope.from({
+          account: multisig.account,
+          config: multisig.initialConfig,
+          signatures: approve({
+            config: multisig.initialConfig,
+            payload: TxEnvelopeTempo.getSignPayload(transaction),
+            signers: multisig.ownerKeys,
+          }),
         }),
       }),
     )
@@ -142,6 +140,51 @@ describe('behavior: multisig (TIP-1061)', () => {
     })
   }
 
+  test('behavior: fills a multisig simulation', async () => {
+    const { account, initialConfig, ownerKeys } = setup({
+      count: 2,
+      threshold: 2,
+    })
+    await fundAddress(client, { address: account })
+
+    const request = TransactionRequest.toRpc({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      from: account,
+      multisigSimulation: {
+        account,
+        approvals: ownerKeys.map((owner) => ({
+          keyType: 'secp256k1',
+          owner: owner.address,
+          type: 'primitive',
+        })),
+        config: initialConfig,
+      },
+    })
+    expect(request.multisigSimulation?.config).toBeTypeOf('string')
+
+    const response = await client.request({
+      method: 'eth_fillTransaction',
+      params: [request as never],
+    })
+    const transaction = TransactionRequest.fromRpc(
+      response.tx as TransactionRequest.Rpc,
+    )
+
+    expect(Hex.validate(response.raw)).toBe(true)
+    expect(transaction.calls).toHaveLength(1)
+    expect(transaction.calls?.[0]?.to).toBe(
+      '0x0000000000000000000000000000000000000000',
+    )
+    expect(transaction.chainId).toBe(chainId)
+    expect(transaction.feeToken).toBeNull()
+    expect(transaction.gas).toBeGreaterThan(0n)
+    expect(transaction.maxFeePerGas).toBeTypeOf('bigint')
+    expect(transaction.maxPriorityFeePerGas).toBeTypeOf('bigint')
+    expect(transaction.nonce ?? 0n).toBe(0n)
+    expect(transaction.nonceKey ?? 0n).toBe(0n)
+    expect(transaction.type).toBe('tempo')
+  })
+
   test('examples: bootstrap, initialized, and configuration rotation', async () => {
     const { account, initialConfig, ownerKeys } = setup({
       count: 3,
@@ -149,9 +192,10 @@ describe('behavior: multisig (TIP-1061)', () => {
     })
     const replacement = createKey()
     const rotatedConfig = MultisigConfig.from({
+      owners: [{ owner: replacement.address, weight: 1 }],
       salt: initialConfig.salt,
       threshold: 1,
-      owners: [{ owner: replacement.address, weight: 1 }],
+      version: 1,
     })
 
     await fundAddress(client, { address: account })
@@ -168,10 +212,10 @@ describe('behavior: multisig (TIP-1061)', () => {
 
     const bootstrap_signed = TxEnvelopeTempo.serialize(bootstrap, {
       signature: SignatureEnvelope.from({
-        initialConfig,
-        init: true,
+        account,
+        config: initialConfig,
         signatures: approve({
-          initialConfig,
+          config: initialConfig,
           payload: TxEnvelopeTempo.getSignPayload(bootstrap),
           signers: [ownerKeys[0]!, ownerKeys[1]!],
         }),
@@ -199,7 +243,7 @@ describe('behavior: multisig (TIP-1061)', () => {
       expect(response.from).toBe(account)
       expect(response.signature?.type).toBe('multisig')
       expect(
-        (response.signature as SignatureEnvelope.Multisig | undefined)?.init,
+        (response.signature as SignatureEnvelope.Multisig | undefined)?.config,
       ).toEqual(initialConfig)
     }
 
@@ -212,6 +256,7 @@ describe('behavior: multisig (TIP-1061)', () => {
         {
           to: '0xaacc000000000000000000000000000000000000',
           data: AbiFunction.encodeData(updateConfig, [
+            initialConfig,
             rotatedConfig.threshold,
             rotatedConfig.owners,
           ]),
@@ -226,9 +271,10 @@ describe('behavior: multisig (TIP-1061)', () => {
     })
     const updateSigned = TxEnvelopeTempo.serialize(update, {
       signature: SignatureEnvelope.from({
-        initialConfig,
+        account,
+        config: initialConfig,
         signatures: approve({
-          initialConfig,
+          config: initialConfig,
           payload: TxEnvelopeTempo.getSignPayload(update),
           signers: [ownerKeys[0]!, ownerKeys[1]!],
         }),
@@ -259,12 +305,13 @@ describe('behavior: multisig (TIP-1061)', () => {
 
     const spend_signed = TxEnvelopeTempo.serialize(spend, {
       signature: SignatureEnvelope.from({
-        initialConfig,
+        account,
+        config: rotatedConfig,
         signatures: approve({
-          initialConfig,
+          address: account,
+          config: rotatedConfig,
           payload: TxEnvelopeTempo.getSignPayload(spend),
           signers: [replacement],
-          version: 1n,
         }),
       }),
     })
@@ -295,10 +342,10 @@ describe('behavior: multisig (TIP-1061)', () => {
     })
     const childBootstrapSigned = TxEnvelopeTempo.serialize(childBootstrap, {
       signature: SignatureEnvelope.from({
-        initialConfig: child.initialConfig,
-        init: true,
+        account: child.account,
+        config: child.initialConfig,
         signatures: approve({
-          initialConfig: child.initialConfig,
+          config: child.initialConfig,
           payload: TxEnvelopeTempo.getSignPayload(childBootstrap),
           signers: child.ownerKeys,
         }),
@@ -330,21 +377,23 @@ describe('behavior: multisig (TIP-1061)', () => {
       maxPriorityFeePerGas: Value.fromGwei('10'),
     })
     const digest = MultisigConfig.getSignPayload({
-      initialConfig,
+      account,
+      config: initialConfig,
       payload: TxEnvelopeTempo.getSignPayload(bootstrap),
     })
     const nested = SignatureEnvelope.from({
-      initialConfig: child.initialConfig,
+      account: child.account,
+      config: child.initialConfig,
       signatures: approve({
-        initialConfig: child.initialConfig,
+        config: child.initialConfig,
         payload: digest,
         signers: child.ownerKeys,
       }),
     })
     const bootstrapSigned = TxEnvelopeTempo.serialize(bootstrap, {
       signature: SignatureEnvelope.from({
-        initialConfig,
-        init: true,
+        account,
+        config: initialConfig,
         signatures: [nested],
       }),
     })
@@ -368,17 +417,23 @@ describe('behavior: multisig (TIP-1061)', () => {
       maxPriorityFeePerGas: Value.fromGwei('10'),
     })
     const parentDigest = MultisigConfig.getSignPayload({
-      initialConfig,
+      account,
+      config: initialConfig,
       payload: TxEnvelopeTempo.getSignPayload(transaction),
     })
-    const childSignature = multisigSignature({
-      initialConfig: child.initialConfig,
-      payload: parentDigest,
-      signers: child.ownerKeys,
+    const childSignature = SignatureEnvelope.from({
+      account: child.account,
+      config: child.initialConfig,
+      signatures: approve({
+        config: child.initialConfig,
+        payload: parentDigest,
+        signers: child.ownerKeys,
+      }),
     })
     const serialized = TxEnvelopeTempo.serialize(transaction, {
       signature: SignatureEnvelope.from({
-        initialConfig,
+        account,
+        config: initialConfig,
         signatures: [childSignature],
       }),
     })
@@ -410,10 +465,14 @@ describe('behavior: multisig (TIP-1061)', () => {
       maxPriorityFeePerGas: Value.fromGwei('10'),
     })
     const signedByOwners = TxEnvelopeTempo.from(transaction, {
-      signature: multisigSignature({
-        initialConfig: multisig.initialConfig,
-        payload: TxEnvelopeTempo.getSignPayload(transaction),
-        signers: multisig.ownerKeys,
+      signature: SignatureEnvelope.from({
+        account: multisig.account,
+        config: multisig.initialConfig,
+        signatures: approve({
+          config: multisig.initialConfig,
+          payload: TxEnvelopeTempo.getSignPayload(transaction),
+          signers: multisig.ownerKeys,
+        }),
       }),
     })
     const sponsored = TxEnvelopeTempo.from({
@@ -461,10 +520,14 @@ describe('behavior: multisig (TIP-1061)', () => {
     const sponsored = TxEnvelopeTempo.from(transaction, { feePayerSignature })
     const receipt = await send(
       TxEnvelopeTempo.serialize(sponsored, {
-        signature: multisigSignature({
-          initialConfig: multisig.initialConfig,
-          payload: TxEnvelopeTempo.getSignPayload(sponsored),
-          signers: multisig.ownerKeys,
+        signature: SignatureEnvelope.from({
+          account: multisig.account,
+          config: multisig.initialConfig,
+          signatures: approve({
+            config: multisig.initialConfig,
+            payload: TxEnvelopeTempo.getSignPayload(sponsored),
+            signers: multisig.ownerKeys,
+          }),
         }),
       }),
     )
@@ -495,14 +558,16 @@ describe('behavior: multisig (TIP-1061)', () => {
     const serialize = (
       value: ReturnType<typeof transaction>,
       signers: readonly { privateKey: Hex.Hex }[],
-      init = false,
     ) =>
       TxEnvelopeTempo.serialize(value, {
-        signature: multisigSignature({
-          initialConfig,
-          init,
-          payload: TxEnvelopeTempo.getSignPayload(value),
-          signers,
+        signature: SignatureEnvelope.from({
+          account,
+          config: initialConfig,
+          signatures: approve({
+            config: initialConfig,
+            payload: TxEnvelopeTempo.getSignPayload(value),
+            signers,
+          }),
         }),
       })
 
@@ -510,7 +575,7 @@ describe('behavior: multisig (TIP-1061)', () => {
     const bootstrapReceipt = (await client
       .request({
         method: 'eth_sendRawTransactionSync',
-        params: [serialize(bootstrap, [ownerKeys[0]!, ownerKeys[1]!], true)],
+        params: [serialize(bootstrap, [ownerKeys[0]!, ownerKeys[1]!])],
       })
       .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
     expect(bootstrapReceipt.status).toBe('success')
@@ -568,10 +633,10 @@ describe('behavior: multisig (TIP-1061)', () => {
 
     const bootstrap_signed = TxEnvelopeTempo.serialize(bootstrap, {
       signature: SignatureEnvelope.from({
-        initialConfig,
-        init: true,
+        account,
+        config: initialConfig,
         signatures: approve({
-          initialConfig,
+          config: initialConfig,
           payload: TxEnvelopeTempo.getSignPayload(bootstrap),
           signers: ownerKeys,
         }),
@@ -618,9 +683,10 @@ describe('behavior: multisig (TIP-1061)', () => {
 
     const authorize_signed = TxEnvelopeTempo.serialize(authorize, {
       signature: SignatureEnvelope.from({
-        initialConfig,
+        account,
+        config: initialConfig,
         signatures: approve({
-          initialConfig,
+          config: initialConfig,
           payload: TxEnvelopeTempo.getSignPayload(authorize),
           signers: ownerKeys,
         }),
@@ -698,6 +764,7 @@ describe('behavior: multisig (TIP-1061)', () => {
         {
           to: '0xaacc000000000000000000000000000000000000',
           data: AbiFunction.encodeData(updateConfig, [
+            initialConfig,
             initialConfig.threshold,
             initialConfig.owners,
           ]),
@@ -744,11 +811,14 @@ describe('behavior: multisig (TIP-1061)', () => {
       type: 'secp256k1',
     })
     const keyAuthorizationSigned = KeyAuthorization.from(keyAuthorization, {
-      signature: multisigSignature({
-        initialConfig: multisig.initialConfig,
-        init: true,
-        payload: KeyAuthorization.getSignPayload(keyAuthorization),
-        signers: multisig.ownerKeys,
+      signature: SignatureEnvelope.from({
+        account: multisig.account,
+        config: multisig.initialConfig,
+        signatures: approve({
+          config: multisig.initialConfig,
+          payload: KeyAuthorization.getSignPayload(keyAuthorization),
+          signers: multisig.ownerKeys,
+        }),
       }),
     })
     const transaction = TxEnvelopeTempo.from({
@@ -787,10 +857,14 @@ describe('behavior: multisig (TIP-1061)', () => {
       type: 'secp256k1',
     })
     const keyAuthorizationSigned = KeyAuthorization.from(keyAuthorization, {
-      signature: multisigSignature({
-        initialConfig: multisig.initialConfig,
-        payload: KeyAuthorization.getSignPayload(keyAuthorization),
-        signers: multisig.ownerKeys,
+      signature: SignatureEnvelope.from({
+        account: multisig.account,
+        config: multisig.initialConfig,
+        signatures: approve({
+          config: multisig.initialConfig,
+          payload: KeyAuthorization.getSignPayload(keyAuthorization),
+          signers: multisig.ownerKeys,
+        }),
       }),
     })
     const bootstrapTransaction = TxEnvelopeTempo.from({
@@ -805,11 +879,14 @@ describe('behavior: multisig (TIP-1061)', () => {
     })
     const bootstrapReceipt = await send(
       TxEnvelopeTempo.serialize(bootstrapTransaction, {
-        signature: multisigSignature({
-          initialConfig: multisig.initialConfig,
-          init: true,
-          payload: TxEnvelopeTempo.getSignPayload(bootstrapTransaction),
-          signers: multisig.ownerKeys,
+        signature: SignatureEnvelope.from({
+          account: multisig.account,
+          config: multisig.initialConfig,
+          signatures: approve({
+            config: multisig.initialConfig,
+            payload: TxEnvelopeTempo.getSignPayload(bootstrapTransaction),
+            signers: multisig.ownerKeys,
+          }),
         }),
       }),
     )

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.7.1'
+export const version = '1.7.4'

package/src/zod/tempo/MultisigConfig.ts

@@ -10,12 +10,13 @@ export const Owner = z.object({
   weight: z.number(),
 })
 
-/** Native multisig configuration schema. */
+/** Native multisig configuration domain schema. */
 export const Config = z
   .object({
-    salt: z.optional(z_Hex.Hex),
-    threshold: z.number(),
     owners: z.readonly(z.array(Owner)),
+    salt: z_Hex.Hex,
+    threshold: z.number(),
+    version: z.bigint(),
   })
   .check(
     z.refine(
@@ -23,3 +24,28 @@ export const Config = z
       'expected valid native multisig configuration',
     ),
   )
+
+/** Native multisig configuration RPC schema. */
+export const Rpc = z
+  .object({
+    owners: z.readonly(z.array(Owner)),
+    salt: z_Hex.Hex,
+    threshold: z.number(),
+    version: z_Hex.Hex,
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_MultisigConfig.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'expected valid native multisig configuration'),
+  )
+
+/** Codec decoding an RPC multisig configuration into a domain configuration. */
+export const MultisigConfig = z.codec(Rpc, Config, {
+  decode: (value) => core_MultisigConfig.fromRpc(value),
+  encode: (value) => core_MultisigConfig.toRpc(value),
+})

package/src/zod/tempo/MultisigOperation.ts

@@ -0,0 +1,66 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as core_MultisigOperation from '../../tempo/MultisigOperation.js'
+import * as z_Address from '../Address.js'
+import * as z_Hash from '../Hash.js'
+import * as z_Hex from '../Hex.js'
+import * as z from 'zod/mini'
+import * as z_MultisigConfig from './MultisigConfig.js'
+
+function baseFields() {
+  return {
+    account: z_Address.Address,
+    approvals: z.readonly(z.array(z_Hex.Hex)),
+    config: z_MultisigConfig.MultisigConfig,
+    createdAt: z.number(),
+    hash: z_Hash.Hash,
+    signatureCount: z.number(),
+    threshold: z.number(),
+    updatedAt: z.number(),
+    weight: z.number(),
+  }
+}
+
+const valid = z.refine((value) => {
+  try {
+    core_MultisigOperation.from(value as never)
+    return true
+  } catch {
+    return false
+  }
+}, 'expected valid multisig operation')
+
+/** Fields shared by every multisig operation schema. */
+export const Base = z.object(baseFields())
+
+/** Multisig transaction approval operation schema. */
+export const TransactionOperation = z
+  .object({
+    ...baseFields(),
+    expiresAt: z.optional(z.number()),
+    status: z.union([
+      z.literal('pending'),
+      z.literal('submitting'),
+      z.literal('success'),
+    ]),
+    submissionId: z.optional(z_Hash.Hash),
+    transaction: z_Hex.Hex,
+    transactionHash: z.optional(z_Hash.Hash),
+    type: z.literal('transaction'),
+  })
+  .check(valid)
+
+/** Multisig key authorization approval operation schema. */
+export const KeyAuthorizationOperation = z
+  .object({
+    ...baseFields(),
+    keyAuthorization: z_Hex.Hex,
+    status: z.union([z.literal('pending'), z.literal('success')]),
+    type: z.literal('keyAuthorization'),
+  })
+  .check(valid)
+
+/** Transaction or key authorization multisig operation schema. */
+export const Operation = z.union([
+  TransactionOperation,
+  KeyAuthorizationOperation,
+])

package/src/zod/tempo/MultisigSimulation.ts

@@ -0,0 +1,98 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as core_MultisigConfig from '../../tempo/MultisigConfig.js'
+import * as core_MultisigSimulation from '../../tempo/MultisigSimulation.js'
+import * as z_Address from '../Address.js'
+import * as z_Hex from '../Hex.js'
+import * as z from 'zod/mini'
+import * as z_MultisigConfig from './MultisigConfig.js'
+import * as z_SignatureEnvelope from './SignatureEnvelope.js'
+
+const NestedPrimitiveApproval = z.object({
+  keyData: z.optional(z_Hex.Hex),
+  keyType: z.optional(z_SignatureEnvelope.Type),
+  owner: z_Address.Address,
+})
+
+const PrimitiveApproval = z.object({
+  keyData: z.optional(z_Hex.Hex),
+  keyType: z.optional(z_SignatureEnvelope.Type),
+  owner: z_Address.Address,
+  type: z.literal('primitive'),
+})
+
+const NestedSpec = z.object({
+  account: z_Address.Address,
+  approvals: z.readonly(
+    z
+      .array(NestedPrimitiveApproval)
+      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
+  ),
+  config: z_MultisigConfig.Config,
+})
+
+const NestedSpecRpc = z.object({
+  account: z_Address.Address,
+  approvals: z.readonly(
+    z
+      .array(NestedPrimitiveApproval)
+      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
+  ),
+  config: z_Hex.Hex,
+})
+
+/** Native multisig simulation spec schema. */
+export const Domain = z.object({
+  account: z_Address.Address,
+  approvals: z.readonly(
+    z
+      .array(
+        z.union([
+          PrimitiveApproval,
+          z.object({
+            spec: NestedSpec,
+            type: z.literal('multisig'),
+          }),
+        ]),
+      )
+      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
+  ),
+  config: z_MultisigConfig.Config,
+})
+
+const Rpc_ = z
+  .object({
+    account: z_Address.Address,
+    approvals: z.readonly(
+      z
+        .array(
+          z.union([
+            PrimitiveApproval,
+            z.object({
+              spec: NestedSpecRpc,
+              type: z.literal('multisig'),
+            }),
+          ]),
+        )
+        .check(z.maxLength(core_MultisigConfig.maxSignatures)),
+    ),
+    config: z_Hex.Hex,
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_MultisigSimulation.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'expected valid native multisig simulation spec'),
+  )
+
+/** Codec decoding an RPC multisig simulation spec into its domain representation. */
+export const MultisigSimulation = z.codec(Rpc_, Domain, {
+  decode: (value) => core_MultisigSimulation.fromRpc(value),
+  encode: (value) => core_MultisigSimulation.toRpc(value),
+})
+
+/** RPC native multisig simulation spec schema. */
+export const Rpc = Rpc_