ox 1.7.1 → 1.7.2

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

@@ -9,7 +9,7 @@ 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 +49,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 +72,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 +101,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,
+          }),
         }),
       }),
     )
@@ -149,9 +142,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 +162,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 +193,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 +206,7 @@ describe('behavior: multisig (TIP-1061)', () => {
         {
           to: '0xaacc000000000000000000000000000000000000',
           data: AbiFunction.encodeData(updateConfig, [
+            initialConfig,
             rotatedConfig.threshold,
             rotatedConfig.owners,
           ]),
@@ -226,9 +221,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 +255,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 +292,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 +327,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 +367,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 +415,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 +470,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 +508,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 +525,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 +583,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 +633,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 +714,7 @@ describe('behavior: multisig (TIP-1061)', () => {
         {
           to: '0xaacc000000000000000000000000000000000000',
           data: AbiFunction.encodeData(updateConfig, [
+            initialConfig,
             initialConfig.threshold,
             initialConfig.owners,
           ]),
@@ -744,11 +761,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 +807,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 +829,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.2'

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,69 @@
+/* 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_Uint from '../Uint.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,
+    configVersion: z_Uint.Uint64,
+    createdAt: z.number(),
+    hash: z_Hash.Hash,
+    init: z.boolean(),
+    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/MultisigWitness.ts

@@ -0,0 +1,101 @@
+/* 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_MultisigWitness from '../../tempo/MultisigWitness.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 ConfigRpc = z
+  .object({
+    owners: z.readonly(z.array(z_MultisigConfig.Owner)),
+    salt: z_Hex.Hex,
+    threshold: z.number(),
+    version: z.number(),
+  })
+  .check(
+    z.refine(
+      (value) => core_MultisigConfig.validate(value),
+      'expected valid native multisig configuration',
+    ),
+  )
+
+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 NestedWitness = z.object({
+  account: z_Address.Address,
+  approvals: z.readonly(
+    z
+      .array(NestedPrimitiveApproval)
+      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
+  ),
+  config: z_MultisigConfig.Config,
+})
+
+const NestedWitnessRpc = z.object({
+  account: z_Address.Address,
+  approvals: z.readonly(
+    z
+      .array(NestedPrimitiveApproval)
+      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
+  ),
+  config: ConfigRpc,
+})
+
+/** Native multisig simulation witness schema. */
+export const Domain = z.object({
+  account: z_Address.Address,
+  approvals: z.readonly(
+    z
+      .array(
+        z.union([
+          PrimitiveApproval,
+          z.object({
+            type: z.literal('multisig'),
+            witness: NestedWitness,
+          }),
+        ]),
+      )
+      .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({
+            type: z.literal('multisig'),
+            witness: NestedWitnessRpc,
+          }),
+        ]),
+      )
+      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
+  ),
+  config: ConfigRpc,
+})
+
+/** Codec decoding an RPC multisig witness into its domain representation. */
+export const MultisigWitness = z.codec(Rpc_, Domain, {
+  decode: (value) => core_MultisigWitness.fromRpc(value),
+  encode: (value) => core_MultisigWitness.toRpc(value),
+})
+
+/** RPC native multisig simulation witness schema. */
+export const Rpc = Rpc_

package/src/zod/tempo/RpcSchemaTempo.ts

@@ -6,6 +6,8 @@ import * as z_Log from '../Log.js'
 import * as z_StateOverrides from '../StateOverrides.js'
 import { from } from '../internal/rpcSchemas/from.js'
 import * as z from 'zod/mini'
+import * as z_KeyAuthorization from './KeyAuthorization.js'
+import * as z_MultisigOperation from './MultisigOperation.js'
 import * as z_TransactionRequest from './TransactionRequest.js'
 
 const BlockNumberOrTagOrIdentifier = z.union([
@@ -85,3 +87,44 @@ export const tempo_simulateV1 = from({
 
 /** JSON-RPC method schemas for the `tempo_` namespace. */
 export const Tempo = { tempo_simulateV1 }
+
+/** Schema for the `multisig_approveRawTransaction` JSON-RPC method. */
+export const multisig_approveRawTransaction = from({
+  method: 'multisig_approveRawTransaction',
+  params: z.tuple([z_Hex.Hex]),
+  returns: z_Hex.Hex,
+})
+
+/** Schema for the `multisig_approveRawTransactionSync` JSON-RPC method. */
+export const multisig_approveRawTransactionSync = from({
+  method: 'multisig_approveRawTransactionSync',
+  params: z.tuple([z_Hex.Hex, z.optional(z.number())]),
+  returns: z_MultisigOperation.TransactionOperation,
+})
+
+/** Schema for the `multisig_approveKeyAuthorization` JSON-RPC method. */
+export const multisig_approveKeyAuthorization = from({
+  method: 'multisig_approveKeyAuthorization',
+  params: z.tuple([
+    z.union([
+      z.object({ keyAuthorization: z_KeyAuthorization.Rpc }),
+      z.object({ hash: z_Hex.Hex, signature: z_Hex.Hex }),
+    ]),
+  ]),
+  returns: z_MultisigOperation.KeyAuthorizationOperation,
+})
+
+/** Schema for the `multisig_getOperation` JSON-RPC method. */
+export const multisig_getOperation = from({
+  method: 'multisig_getOperation',
+  params: z.tuple([z_Hex.Hex]),
+  returns: z.nullable(z_MultisigOperation.Operation),
+})
+
+/** JSON-RPC method schemas for the `multisig_` namespace. */
+export const Multisig = {
+  multisig_approveKeyAuthorization,
+  multisig_approveRawTransaction,
+  multisig_approveRawTransactionSync,
+  multisig_getOperation,
+}