ox 0.14.44 → 0.14.45

package/tempo/MultisigOperation.ts

@@ -144,7 +144,8 @@ export declare namespace getHash {
  *
  * The function retains one canonical approval per owner. It selects the
  * smallest deterministic quorum by owner weight, then orders the selected
- * approvals by owner address for serialization.
+ * approvals by owner address for serialization. The caller supplies the
+ * account and config; the chain validates their factory-derived identity.
  *
  * @example
  * ```ts twoslash
@@ -171,22 +172,12 @@ export async function selectApprovals(
   if (!Hash.validate(hash))
     throw new InvalidApprovalError({ reason: 'hash is invalid' })
   const config = MultisigConfig.from(options.config)
-  if (
-    config.version === 0n &&
-    !Address.isEqual(MultisigConfig.getAddress(config), account)
-  )
-    throw new InvalidApprovalError({
-      reason: 'initial config does not derive the root multisig account',
-    })
-  return selectApprovals_internal(
-    {
-      account,
-      approvals,
-      config,
-      hash,
-    },
-    [account.toLowerCase()],
-  )
+  return selectApprovals_internal({
+    account,
+    approvals,
+    config,
+    hash,
+  })
 }
 
 export declare namespace selectApprovals {
@@ -194,7 +185,7 @@ export declare namespace selectApprovals {
   export type Options = {
     /** Root multisig account. */
     account: Address.Address
-    /** Serialized primitive or nested owner approvals. */
+    /** Serialized primitive owner approvals. */
     approvals: readonly SignatureEnvelope.Serialized[]
     /** Current root multisig configuration. */
     config: MultisigConfig.Config
@@ -272,7 +263,7 @@ export function serializeKeyAuthorization(
     config,
     payload: KeyAuthorization_.getSignPayload(authorization),
     signatures: options.approvals.map((approval) =>
-      SignatureEnvelope.deserialize(approval),
+      assertApproval(options.account, approval, config),
     ),
   })
   return KeyAuthorization_.serialize(
@@ -337,7 +328,7 @@ export function serializeTransaction(
     value.transaction as TxEnvelopeTempo.Serialized,
   )
   const approvals = options.approvals.map((approval) =>
-    SignatureEnvelope.from(approval),
+    assertApproval(value.account, approval, value.config),
   )
   assertRetainedApprovals(value, approvals)
   const signatures = SignatureEnvelope.sortMultisigApprovals({
@@ -522,7 +513,6 @@ export declare namespace toRpc {
  */
 async function selectApprovals_internal(
   options: selectApprovals.Options,
-  path: readonly string[],
 ): Promise<selectApprovals.ReturnValue> {
   const owners = new Map(
     options.config.owners.map((owner) => [
@@ -533,17 +523,14 @@ async function selectApprovals_internal(
   const groups = new Map<string, ApprovalGroup>()
   for (const serialized of options.approvals) {
     const signature = SignatureEnvelope.from(serialized)
-    if (signature.type === 'keychain')
+    if (signature.type === 'keychain' || signature.type === 'multisig')
       throw new InvalidApprovalError({
-        reason: 'keychain signatures cannot approve a multisig operation',
+        reason: 'only primitive signatures can approve a multisig operation',
       })
-    const address =
-      signature.type === 'multisig'
-        ? signature.account
-        : SignatureEnvelope.extractAddress({
-            payload: options.hash,
-            signature,
-          })
+    const address = SignatureEnvelope.extractAddress({
+      payload: options.hash,
+      signature,
+    })
     const owner = owners.get(address.toLowerCase())
     if (!owner)
       throw new InvalidApprovalError({
@@ -563,79 +550,6 @@ async function selectApprovals_internal(
   const valid: SelectedApproval[] = []
   const retained: RetainedApproval[] = []
   for (const group of groups.values()) {
-    const nested = group.signatures.filter(
-      (signature) => signature.type === 'multisig',
-    )
-    if (nested.length > 0) {
-      if (nested.length !== group.signatures.length)
-        throw new InvalidApprovalError({
-          reason: `owner ${group.address} has conflicting signature types`,
-        })
-      if (
-        path.length >= MultisigConfig.maxNestingDepth ||
-        path.includes(group.address.toLowerCase())
-      )
-        throw new InvalidApprovalError({
-          reason: `nested multisig owner ${group.address} is invalid`,
-        })
-      const config = MultisigConfig.from(nested[0]!.config)
-      if (nested.some((signature) => !sameConfig(signature.config, config)))
-        throw new InvalidApprovalError({
-          reason: `nested multisig owner ${group.address} has conflicting config witnesses`,
-        })
-      if (
-        config.version === 0n &&
-        !Address.isEqual(MultisigConfig.getAddress(config), group.address)
-      )
-        throw new InvalidApprovalError({
-          reason: `initial config does not derive nested multisig owner ${group.address}`,
-        })
-      const selected = await selectApprovals_internal(
-        {
-          account: group.address,
-          approvals: nested.flatMap((signature) =>
-            signature.signatures.map((approval) =>
-              SignatureEnvelope.serialize(approval),
-            ),
-          ),
-          config,
-          hash: MultisigConfig.getSignPayload({
-            account: group.address,
-            config,
-            payload: options.hash,
-          }),
-        },
-        [...path, group.address.toLowerCase()],
-      )
-      retained.push({
-        address: group.address,
-        signature: SignatureEnvelope.serialize(
-          SignatureEnvelope.from({
-            account: group.address,
-            config,
-            signatures: selected.approvals.map((approval) =>
-              SignatureEnvelope.from(approval),
-            ),
-          }),
-        ),
-      })
-      if (selected.weight >= selected.threshold)
-        valid.push({
-          address: group.address,
-          signature: SignatureEnvelope.serialize(
-            SignatureEnvelope.from({
-              account: group.address,
-              config,
-              signatures: selected.selectedApprovals.map((approval) =>
-                SignatureEnvelope.from(approval),
-              ),
-            }),
-          ),
-          weight: group.weight,
-        })
-      continue
-    }
-
     const signatures = group.signatures.map((signature) => {
       if (
         !SignatureEnvelope.verify(signature, {
@@ -704,7 +618,7 @@ type ApprovalGroup = {
 type RetainedApproval = {
   /** Configured owner address. */
   address: Address.Address
-  /** Serialized primitive or normalized nested approval. */
+  /** Serialized primitive approval. */
   signature: SignatureEnvelope.Serialized
 }
 
@@ -824,13 +738,6 @@ function assertBase(operation: Operation, config: MultisigConfig.Config): void {
       reason:
         'weight is not reachable by signatureCount retained owner approvals',
     })
-  if (
-    config.version === 0n &&
-    !Address.isEqual(MultisigConfig.getAddress(config), operation.account)
-  )
-    throw new InvalidOperationError({
-      reason: 'initial config does not derive the operation account',
-    })
 }
 
 /**
@@ -1018,8 +925,12 @@ function assertApproval(
   account: Address.Address,
   serialized: SignatureEnvelope.Serialized,
   config: MultisigConfig.Config,
-): SignatureEnvelope.SignatureEnvelope {
+): SignatureEnvelope.Primitive {
   const approval = SignatureEnvelope.deserialize(serialized)
+  if (approval.type === 'keychain' || approval.type === 'multisig')
+    throw new InvalidOperationError({
+      reason: 'only primitive owner approvals are allowed',
+    })
   SignatureEnvelope.assert({
     account,
     config,
@@ -1047,8 +958,10 @@ function assertRetainedApprovals(
     SignatureEnvelope.deserialize(approval),
   )
   for (const approval of selected) {
-    const index = retained.findIndex((candidate) =>
-      includesApproval(candidate, approval),
+    const index = retained.findIndex(
+      (candidate) =>
+        SignatureEnvelope.serialize(candidate).toLowerCase() ===
+        SignatureEnvelope.serialize(approval).toLowerCase(),
     )
     if (index === -1)
       throw new InvalidOperationError({
@@ -1072,8 +985,10 @@ function assertSelectedApprovals(
     SignatureEnvelope.deserialize(approval),
   )
   for (const approval of selected) {
-    const index = retained.findIndex((candidate) =>
-      includesApproval(candidate, approval),
+    const index = retained.findIndex(
+      (candidate) =>
+        SignatureEnvelope.serialize(candidate).toLowerCase() ===
+        SignatureEnvelope.serialize(approval).toLowerCase(),
     )
     if (index === -1)
       throw new InvalidOperationError({
@@ -1104,36 +1019,6 @@ function assertSelectedApprovals(
   }
 }
 
-/**
- * Checks whether a selected approval is contained in a retained approval tree.
- *
- * @internal
- */
-function includesApproval(
-  retained: SignatureEnvelope.SignatureEnvelope,
-  selected: SignatureEnvelope.SignatureEnvelope,
-): boolean {
-  if (retained.type !== 'multisig' || selected.type !== 'multisig')
-    return (
-      SignatureEnvelope.serialize(retained).toLowerCase() ===
-      SignatureEnvelope.serialize(selected).toLowerCase()
-    )
-  if (retained.account.toLowerCase() !== selected.account.toLowerCase())
-    return false
-  if (!sameConfig(retained.config, selected.config)) return false
-  let index = 0
-  for (const approval of selected.signatures) {
-    while (
-      index < retained.signatures.length &&
-      !includesApproval(retained.signatures[index]!, approval)
-    )
-      index++
-    if (index === retained.signatures.length) return false
-    index++
-  }
-  return true
-}
-
 /**
  * Checks whether exactly `signatureCount` retained owners can produce `weight`.
  *

package/tempo/MultisigSimulation.test-d.ts

@@ -2,11 +2,11 @@ import { expectTypeOf, test } from 'vitest'
 import * as MultisigSimulation from './MultisigSimulation.js'
 
 const rpc = {
-  account: '0x2222222222222222222222222222222222222222',
   approvals: [
     {
+      keyType: 'webAuthn',
+      keyData: '0x0102030405',
       owner: '0x1111111111111111111111111111111111111111',
-      type: 'primitive',
     },
   ],
   config:

package/tempo/MultisigSimulation.test.ts

@@ -3,70 +3,26 @@ import { describe, expect, test } from 'vitest'
 
 const config =
   '0xf852a011111111111111111111111111111111111111111111111111111111111111118002eed694111111111111111111111111111111111111111101d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01' as const
-const nestedConfig =
-  '0xf83ba022222222222222222222222222222222222222222222222222222222222222220101d7d694222222222222222222222222222222222222222201' as const
 const rpc = {
-  account: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
   approvals: [
     {
-      keyData: '0x0102030405',
       keyType: 'webAuthn',
+      keyData: '0x0102030405',
       owner: '0x1111111111111111111111111111111111111111',
-      type: 'primitive',
-    },
-    {
-      spec: {
-        account: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-        approvals: [
-          {
-            keyData: '0x010203040506',
-            keyType: 'secp256k1',
-            owner: '0x2222222222222222222222222222222222222222',
-          },
-        ],
-        config: nestedConfig,
-      },
-      type: 'multisig',
     },
   ],
   config,
 } as const satisfies MultisigSimulation.Rpc
 
 describe('fromRpc', () => {
-  test('behavior: decodes root and nested configurations', () => {
+  test('behavior: decodes the configuration', () => {
     expect(MultisigSimulation.fromRpc(rpc)).toMatchInlineSnapshot(`
       {
-        "account": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         "approvals": [
           {
             "keyData": "0x0102030405",
             "keyType": "webAuthn",
             "owner": "0x1111111111111111111111111111111111111111",
-            "type": "primitive",
-          },
-          {
-            "spec": {
-              "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-              "approvals": [
-                {
-                  "keyData": "0x010203040506",
-                  "keyType": "secp256k1",
-                  "owner": "0x2222222222222222222222222222222222222222",
-                },
-              ],
-              "config": {
-                "owners": [
-                  {
-                    "owner": "0x2222222222222222222222222222222222222222",
-                    "weight": 1,
-                  },
-                ],
-                "salt": "0x2222222222222222222222222222222222222222222222222222222222222222",
-                "threshold": 1,
-                "version": 1n,
-              },
-            },
-            "type": "multisig",
           },
         ],
         "config": {
@@ -108,26 +64,14 @@ describe('fromRpc', () => {
       `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: approval count exceeds 8.]`,
     )
   })
-
-  test('error: rejects excess nested approvals', () => {
+  test('error: rejects nested approvals', () => {
     expect(() =>
       MultisigSimulation.fromRpc({
         ...rpc,
-        approvals: [
-          {
-            ...rpc.approvals[1],
-            spec: {
-              ...rpc.approvals[1].spec,
-              approvals: Array.from(
-                { length: 9 },
-                () => rpc.approvals[1].spec.approvals[0],
-              ),
-            },
-          },
-        ],
-      }),
+        approvals: [{ type: 'multisig', spec: rpc }],
+      } as never),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: approval count exceeds 8.]`,
+      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: only untagged primitive owner approvals are allowed.]`,
     )
   })
 
@@ -173,33 +117,17 @@ describe('toRpc', () => {
     expect(
       MultisigSimulation.toRpc(MultisigSimulation.fromRpc(rpc)),
     ).toMatchInlineSnapshot(`
-      {
-        "account": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-        "approvals": [
-          {
-            "keyData": "0x0005",
-            "keyType": "webAuthn",
-            "owner": "0x1111111111111111111111111111111111111111",
-            "type": "primitive",
-          },
-          {
-            "spec": {
-              "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-              "approvals": [
-                {
-                  "keyData": "0x0006",
-                  "keyType": "secp256k1",
-                  "owner": "0x2222222222222222222222222222222222222222",
-                },
-              ],
-              "config": "${nestedConfig}",
+        {
+          "approvals": [
+            {
+              "keyData": "0x0005",
+              "keyType": "webAuthn",
+              "owner": "0x1111111111111111111111111111111111111111",
             },
-            "type": "multisig",
-          },
-        ],
-        "config": "${config}",
-      }
-    `)
+          ],
+          "config": "0xf852a011111111111111111111111111111111111111111111111111111111111111118002eed694111111111111111111111111111111111111111101d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01",
+        }
+      `)
   })
 
   test('behavior: preserves short key data', () => {
@@ -214,7 +142,6 @@ describe('toRpc', () => {
           "keyData": "0x0102",
           "keyType": "webAuthn",
           "owner": "0x1111111111111111111111111111111111111111",
-          "type": "primitive",
         },
       ]
     `)
@@ -255,30 +182,14 @@ describe('toRpc', () => {
       `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: approval count exceeds 8.]`,
     )
   })
-
-  test('error: rejects excess nested approvals', () => {
-    const spec = MultisigSimulation.fromRpc(rpc)
-    const nested = spec.approvals[1]!
-    if (nested.type !== 'multisig') throw new Error('unreachable')
-
+  test('error: rejects nested approvals', () => {
     expect(() =>
       MultisigSimulation.toRpc({
-        ...spec,
-        approvals: [
-          {
-            ...nested,
-            spec: {
-              ...nested.spec,
-              approvals: Array.from(
-                { length: 9 },
-                () => nested.spec.approvals[0]!,
-              ),
-            },
-          },
-        ],
-      }),
+        ...rpc,
+        approvals: [{ type: 'multisig', spec: rpc }],
+      } as never),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: approval count exceeds 8.]`,
+      `[MultisigSimulation.InvalidSimulationError: Invalid multisig simulation: only untagged primitive owner approvals are allowed.]`,
     )
   })
 })

package/tempo/MultisigSimulation.ts

@@ -7,56 +7,10 @@ import * as MultisigConfig from './MultisigConfig.js'
 import type * as SignatureEnvelope from './SignatureEnvelope.js'
 
 /** Native multisig owner approval used for RPC simulation. */
-export type Approval = NestedApproval | PrimitiveApproval
+export type Approval = PrimitiveApproval
 
 /** JSON-RPC native multisig owner approval used for RPC simulation. */
-export type ApprovalRpc = NestedApprovalRpc | PrimitiveApproval
-
-/** Nested native multisig owner approval used for RPC simulation. */
-export type NestedApproval = {
-  /** Depth-2 multisig simulation spec. */
-  spec: NestedSpec
-  /** Approval type. */
-  type: 'multisig'
-}
-
-/** JSON-RPC nested native multisig owner approval used for RPC simulation. */
-export type NestedApprovalRpc = {
-  /** Depth-2 multisig simulation spec. */
-  spec: NestedSpecRpc
-  /** Approval type. */
-  type: 'multisig'
-}
-
-/** Primitive approval in a depth-2 multisig simulation spec. */
-export type NestedPrimitiveApproval = {
-  /** Optional signature-specific gas-estimation data. */
-  keyData?: Hex.Hex | undefined
-  /** Signature type to model. Omission uses a maximum-size WebAuthn signature. */
-  keyType?: SignatureEnvelope.Type | undefined
-  /** Configured owner address. */
-  owner: Address.Address
-}
-
-/** Depth-2 native multisig spec used for RPC simulation. */
-export type NestedSpec = {
-  /** Nested multisig account. */
-  account: Address.Address
-  /** Primitive owner approvals to model. */
-  approvals: readonly NestedPrimitiveApproval[]
-  /** Complete applicable configuration. */
-  config: MultisigConfig.Config
-}
-
-/** JSON-RPC depth-2 native multisig spec used for RPC simulation. */
-export type NestedSpecRpc = {
-  /** Nested multisig account. */
-  account: Address.Address
-  /** Primitive owner approvals to model. */
-  approvals: readonly NestedPrimitiveApproval[]
-  /** Canonical RLP-encoded applicable configuration. */
-  config: Hex.Hex
-}
+export type ApprovalRpc = PrimitiveApproval
 
 /** Primitive owner approval used for RPC simulation. */
 export type PrimitiveApproval = {
@@ -66,14 +20,10 @@ export type PrimitiveApproval = {
   keyType?: SignatureEnvelope.Type | undefined
   /** Configured owner address. */
   owner: Address.Address
-  /** Approval type. */
-  type: 'primitive'
 }
 
 /** JSON-RPC representation of a native multisig simulation spec. */
 export type Rpc = Compute<{
-  /** Account authorized by this spec. */
-  account: Address.Address
   /** Owner approvals to model. */
   approvals: readonly ApprovalRpc[]
   /** Canonical RLP-encoded applicable configuration. */
@@ -82,8 +32,6 @@ export type Rpc = Compute<{
 
 /** Native multisig spec used to construct an RPC simulation signature. */
 export type Spec = Compute<{
-  /** Account authorized by this spec. */
-  account: Address.Address
   /** Owner approvals to model. */
   approvals: readonly Approval[]
   /** Complete applicable configuration. */
@@ -105,24 +53,9 @@ export type Spec = Compute<{
  * @returns The multisig simulation spec with decoded configurations.
  */
 export function fromRpc(spec: Rpc): Spec {
-  const { account, approvals, config } = spec
-  assertApprovalCount(approvals)
-  return {
-    account,
-    approvals: approvals.map((approval) => {
-      if (approval.type === 'primitive') return approval
-      assertApprovalCount(approval.spec.approvals)
-      return {
-        spec: {
-          account: approval.spec.account,
-          approvals: approval.spec.approvals,
-          config: deserializeConfig(approval.spec.config),
-        },
-        type: 'multisig',
-      }
-    }),
-    config: deserializeConfig(config),
-  }
+  const { approvals, config } = spec
+  assertApprovals(approvals)
+  return { approvals, config: deserializeConfig(config) }
 }
 
 export declare namespace fromRpc {
@@ -151,33 +84,14 @@ export declare namespace fromRpc {
  * @returns The JSON-RPC multisig simulation spec with encoded configurations.
  */
 export function toRpc(spec: Spec): Rpc {
-  const { account, approvals, config } = spec
-  assertApprovalCount(approvals)
+  const { approvals, config } = spec
+  assertApprovals(approvals)
   return {
-    account,
-    approvals: approvals.map((approval) => {
-      if (approval.type === 'primitive')
-        return {
-          ...approval,
-          ...(typeof approval.keyData !== 'undefined'
-            ? { keyData: shimKeyData(approval.keyData) }
-            : {}),
-        }
-      assertApprovalCount(approval.spec.approvals)
-      return {
-        spec: {
-          account: approval.spec.account,
-          approvals: approval.spec.approvals.map((approval) => ({
-            ...approval,
-            ...(typeof approval.keyData !== 'undefined'
-              ? { keyData: shimKeyData(approval.keyData) }
-              : {}),
-          })),
-          config: serializeConfig(approval.spec.config),
-        },
-        type: 'multisig',
-      }
-    }),
+    approvals: approvals.map(({ keyData, keyType, owner }) => ({
+      ...(keyData !== undefined ? { keyData: shimKeyData(keyData) } : {}),
+      ...(keyType !== undefined ? { keyType } : {}),
+      owner,
+    })),
     config: serializeConfig(config),
   }
 }
@@ -193,7 +107,19 @@ export declare namespace toRpc {
 }
 
 /** @internal */
-function assertApprovalCount(approvals: readonly unknown[]) {
+function assertApprovals(approvals: readonly unknown[]) {
+  if (
+    approvals.some(
+      (approval) =>
+        typeof approval !== 'object' ||
+        approval === null ||
+        'spec' in approval ||
+        'type' in approval,
+    )
+  )
+    throw new InvalidSimulationError({
+      reason: 'only untagged primitive owner approvals are allowed',
+    })
   if (approvals.length > MultisigConfig.maxSignatures)
     throw new InvalidSimulationError({
       reason: `approval count exceeds ${MultisigConfig.maxSignatures}`,