ox 0.14.38 → 0.14.40

package/tempo/MultisigOperation.ts

@@ -14,7 +14,7 @@ export type Base<quantity = bigint> = {
   /** Every retained serialized owner approval. */
   approvals: readonly Hex.Hex[]
   /** Root configuration used to verify approvals. */
-  config: MultisigConfig.Config
+  config: MultisigConfig.Config<quantity>
   /** Root configuration version. */
   configVersion: quantity
   /** Unix creation time in milliseconds. */
@@ -109,8 +109,8 @@ export function getHash(options: getHash.Options): Hex.Hex {
         )
   return MultisigConfig.getSignPayload({
     account,
+    config: { version: configVersion },
     payload,
-    version: configVersion,
   })
 }
 
@@ -281,20 +281,15 @@ export function serializeTransaction(
   assertRetainedApprovals(value, approvals)
   const signatures = SignatureEnvelope.sortMultisigApprovals({
     account: value.account,
+    config: value.config,
     payload: TxEnvelopeTempo.getSignPayload(envelope),
     signatures: approvals,
-    version: value.configVersion,
   })
-  const signature = value.init
-    ? SignatureEnvelope.from({
-        init: true,
-        initialConfig: value.config,
-        signatures,
-      })
-    : SignatureEnvelope.from({
-        account: value.account,
-        signatures,
-      })
+  const signature = SignatureEnvelope.from({
+    account: value.account,
+    config: value.config,
+    signatures,
+  })
   return TxEnvelopeTempo.serialize(
     envelope,
     value.transaction.startsWith(TxEnvelopeTempo.feePayerMagic)
@@ -344,6 +339,10 @@ export function from<const operation extends Operation>(
 ): from.ReturnValue<operation> {
   try {
     const config = MultisigConfig.from(operation.config)
+    if (config.version !== operation.configVersion)
+      throw new InvalidOperationError({
+        reason: 'config.version must equal configVersion',
+      })
     if (
       typeof config.threshold !== 'number' ||
       config.owners.some((owner) => typeof owner.weight !== 'number')
@@ -351,12 +350,13 @@ export function from<const operation extends Operation>(
       throw new InvalidOperationError({
         reason: 'config threshold and owner weights must be numbers',
       })
-    assertBase(operation, config)
-    if (operation.type === 'transaction') assertTransaction(operation)
-    else if (operation.type === 'keyAuthorization')
-      assertKeyAuthorization(operation, config)
+    const value = { ...operation, config } as Operation
+    assertBase(value, config)
+    if (value.type === 'transaction') assertTransaction(value)
+    else if (value.type === 'keyAuthorization')
+      assertKeyAuthorization(value, config)
     else throw new InvalidOperationError({ reason: 'unknown operation type' })
-    return { ...operation, config } as never
+    return value as never
   } catch (cause) {
     if (cause instanceof InvalidOperationError) throw cause
     throw new InvalidOperationError({ cause })
@@ -404,7 +404,11 @@ export function fromRpc<const operation extends Rpc>(
       throw new InvalidOperationError({
         reason: 'configVersion must use canonical quantity encoding',
       })
-    return from({ ...operation, configVersion } as Operation) as never
+    return from({
+      ...operation,
+      config: MultisigConfig.fromRpc(operation.config),
+      configVersion,
+    } as Operation) as never
   } catch (cause) {
     if (cause instanceof InvalidOperationError) throw cause
     throw new InvalidOperationError({ cause })
@@ -442,6 +446,7 @@ export function toRpc<const operation extends Operation>(
   const value = from(operation)
   return {
     ...value,
+    config: MultisigConfig.toRpc(value.config),
     configVersion: Hex.fromNumber(value.configVersion),
   } as never
 }
@@ -513,10 +518,6 @@ async function selectApprovals_internal(
         throw new InvalidApprovalError({
           reason: `owner ${group.address} has conflicting signature types`,
         })
-      if (nested.some((signature) => signature.init))
-        throw new InvalidApprovalError({
-          reason: `nested multisig owner ${group.address} cannot carry init`,
-        })
       if (
         path.length >= MultisigConfig.maxNestingDepth ||
         path.includes(group.address.toLowerCase())
@@ -529,6 +530,11 @@ async function selectApprovals_internal(
           reason: `nested multisig owner ${group.address} requires a config resolver`,
         })
       const resolved = await options.resolveConfig({ account: group.address })
+      const config = MultisigConfig.from(resolved.config)
+      if (config.version !== resolved.version)
+        throw new InvalidApprovalError({
+          reason: `resolved config.version must equal version for nested multisig owner ${group.address}`,
+        })
       const selected = await selectApprovals_internal(
         {
           account: group.address,
@@ -537,11 +543,11 @@ async function selectApprovals_internal(
               SignatureEnvelope.serialize(approval),
             ),
           ),
-          config: MultisigConfig.from(resolved.config),
+          config,
           hash: MultisigConfig.getSignPayload({
             account: group.address,
+            config,
             payload: options.hash,
-            version: resolved.version,
           }),
           resolveConfig: options.resolveConfig,
         },
@@ -552,6 +558,7 @@ async function selectApprovals_internal(
         signature: SignatureEnvelope.serialize(
           SignatureEnvelope.from({
             account: group.address,
+            config,
             signatures: selected.approvals.map((approval) =>
               SignatureEnvelope.from(approval),
             ),
@@ -564,6 +571,7 @@ async function selectApprovals_internal(
           signature: SignatureEnvelope.serialize(
             SignatureEnvelope.from({
               account: group.address,
+              config,
               signatures: selected.selectedApprovals.map((approval) =>
                 SignatureEnvelope.from(approval),
               ),
@@ -739,6 +747,7 @@ function assertBase(operation: Operation, config: MultisigConfig.Config): void {
     const signature = assertApproval(
       operation.account,
       approval as SignatureEnvelope.Serialized,
+      config,
     )
     const address = SignatureEnvelope.extractAddress({
       payload: operation.hash,
@@ -944,13 +953,9 @@ function assertKeyAuthorization(
         reason: 'key authorization signatureCount does not match its signature',
       })
     assertSelectedApprovals(operation, signature.signatures, authorization)
-    if (!!signature.init !== operation.init)
+    if (!sameConfig(signature.config, config))
       throw new InvalidOperationError({
-        reason: 'key authorization bootstrap state does not match',
-      })
-    if (signature.init && !sameConfig(signature.init, config))
-      throw new InvalidOperationError({
-        reason: 'key authorization bootstrap config does not match',
+        reason: 'key authorization config does not match',
       })
   }
   assertOperationHash(
@@ -974,10 +979,12 @@ function assertKeyAuthorization(
 function assertApproval(
   account: Address.Address,
   serialized: SignatureEnvelope.Serialized,
+  config: MultisigConfig.Config,
 ): SignatureEnvelope.SignatureEnvelope {
   const approval = SignatureEnvelope.deserialize(serialized)
   SignatureEnvelope.assert({
     account,
+    config,
     signatures: [approval],
     type: 'multisig',
   })
@@ -1039,8 +1046,8 @@ function assertSelectedApprovals(
 
   const digest = MultisigConfig.getSignPayload({
     account: operation.account,
+    config: operation.config,
     payload: KeyAuthorization_.getSignPayload(authorization),
-    version: operation.configVersion,
   })
   const addresses = selected.map((signature) =>
     SignatureEnvelope.extractAddress({ payload: digest, signature }),
@@ -1075,7 +1082,7 @@ function includesApproval(
     )
   if (retained.account.toLowerCase() !== selected.account.toLowerCase())
     return false
-  // Nested versions are not serialized, so selected child approvals must preserve the validated retained order.
+  if (!sameConfig(retained.config, selected.config)) return false
   let index = 0
   for (const approval of selected.signatures) {
     while (
@@ -1119,8 +1126,8 @@ function isWeightReachable(
 function assertOperationHash(operation: Operation, payload: Hex.Hex): void {
   const hash = MultisigConfig.getSignPayload({
     account: operation.account,
+    config: operation.config,
     payload,
-    version: operation.configVersion,
   })
   if (hash.toLowerCase() !== operation.hash.toLowerCase())
     throw new InvalidOperationError({
@@ -1157,6 +1164,7 @@ function sameConfig(
       configB.salt ?? MultisigConfig.zeroSalt,
     ) &&
     configA.threshold === configB.threshold &&
+    configA.version === configB.version &&
     configA.owners.length === configB.owners.length &&
     configA.owners.every((owner, index) => {
       const other = configB.owners[index]!

package/tempo/MultisigWitness/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/MultisigWitness.d.ts",
+  "main": "../../_cjs/tempo/MultisigWitness.js",
+  "module": "../../_esm/tempo/MultisigWitness.js"
+}

package/tempo/MultisigWitness.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/MultisigWitness.test-d.d.ts",
+  "main": "../../_cjs/tempo/MultisigWitness.test-d.js",
+  "module": "../../_esm/tempo/MultisigWitness.test-d.js"
+}

package/tempo/MultisigWitness.test-d.ts

@@ -0,0 +1,42 @@
+import { expectTypeOf, test } from 'vitest'
+import * as MultisigWitness from './MultisigWitness.js'
+
+const rpc = {
+  account: '0x2222222222222222222222222222222222222222',
+  approvals: [
+    {
+      owner: '0x1111111111111111111111111111111111111111',
+      type: 'primitive',
+    },
+  ],
+  config: {
+    owners: [
+      {
+        owner: '0x1111111111111111111111111111111111111111',
+        weight: 1,
+      },
+    ],
+    salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+    threshold: 1,
+    version: 0,
+  },
+} as const satisfies MultisigWitness.Rpc
+
+test('fromRpc returns a domain witness', () => {
+  const witness = MultisigWitness.fromRpc(rpc)
+
+  expectTypeOf(witness).toEqualTypeOf<MultisigWitness.MultisigWitness>()
+  expectTypeOf(witness.config.version).toEqualTypeOf<bigint>()
+})
+
+test('RPC witnesses use numeric configuration versions', () => {
+  expectTypeOf<
+    MultisigWitness.Rpc['config']['version']
+  >().toEqualTypeOf<number>()
+})
+
+test('toRpc returns an RPC witness', () => {
+  expectTypeOf(
+    MultisigWitness.toRpc(MultisigWitness.fromRpc(rpc)),
+  ).toEqualTypeOf<MultisigWitness.Rpc>()
+})

package/tempo/MultisigWitness.test.ts

@@ -0,0 +1,289 @@
+import { MultisigWitness } from 'ox/tempo'
+import { describe, expect, test } from 'vitest'
+
+const rpc = {
+  account: '0xcccccccccccccccccccccccccccccccccccccccc',
+  approvals: [
+    {
+      keyData: '0x0102030405',
+      keyType: 'webAuthn',
+      owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+      type: 'primitive',
+    },
+    {
+      type: 'multisig',
+      witness: {
+        account: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+        approvals: [
+          {
+            keyData: '0x010203040506',
+            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,
+  },
+} as const satisfies MultisigWitness.Rpc
+
+describe('fromRpc', () => {
+  test('behavior: converts numeric configuration versions to bigint', () => {
+    expect(MultisigWitness.fromRpc(rpc)).toMatchInlineSnapshot(`
+      {
+        "account": "0xcccccccccccccccccccccccccccccccccccccccc",
+        "approvals": [
+          {
+            "keyData": "0x0102030405",
+            "keyType": "webAuthn",
+            "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            "type": "primitive",
+          },
+          {
+            "type": "multisig",
+            "witness": {
+              "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+              "approvals": [
+                {
+                  "keyData": "0x010203040506",
+                  "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,
+        },
+      }
+    `)
+  })
+
+  test('error: rejects unsafe numeric configuration versions', () => {
+    expect(() =>
+      MultisigWitness.fromRpc({
+        ...rpc,
+        config: {
+          ...rpc.config,
+          version: Number.MAX_SAFE_INTEGER + 1,
+        },
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[MultisigConfig.InvalidConfigError: Invalid native multisig config: version must be an unsigned 64-bit integer.]`,
+    )
+  })
+
+  test('error: rejects excess root approvals', () => {
+    expect(() =>
+      MultisigWitness.fromRpc({
+        ...rpc,
+        approvals: Array.from({ length: 9 }, () => rpc.approvals[0]),
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[MultisigWitness.InvalidWitnessError: Invalid multisig witness: approval count exceeds 8.]`,
+    )
+  })
+
+  test('error: rejects excess nested approvals', () => {
+    expect(() =>
+      MultisigWitness.fromRpc({
+        ...rpc,
+        approvals: [
+          {
+            ...rpc.approvals[1],
+            witness: {
+              ...rpc.approvals[1].witness,
+              approvals: Array.from(
+                { length: 9 },
+                () => rpc.approvals[1].witness.approvals[0],
+              ),
+            },
+          },
+        ],
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[MultisigWitness.InvalidWitnessError: Invalid multisig witness: approval count exceeds 8.]`,
+    )
+  })
+})
+
+describe('toRpc', () => {
+  test('behavior: converts bigint configuration versions to numbers', () => {
+    expect(
+      MultisigWitness.toRpc(MultisigWitness.fromRpc(rpc)),
+    ).toMatchInlineSnapshot(`
+      {
+        "account": "0xcccccccccccccccccccccccccccccccccccccccc",
+        "approvals": [
+          {
+            "keyData": "0x0005",
+            "keyType": "webAuthn",
+            "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            "type": "primitive",
+          },
+          {
+            "type": "multisig",
+            "witness": {
+              "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+              "approvals": [
+                {
+                  "keyData": "0x0006",
+                  "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,
+        },
+      }
+    `)
+  })
+
+  test('error: rejects versions that JSON cannot represent exactly', () => {
+    const witness = MultisigWitness.fromRpc(rpc)
+    expect(() =>
+      MultisigWitness.toRpc({
+        ...witness,
+        config: {
+          ...witness.config,
+          version: BigInt(Number.MAX_SAFE_INTEGER) + 1n,
+        },
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Hex.IntegerOutOfRangeError: Number \`9007199254740992\` is not in safe unsigned integer range (\`0\` to \`9007199254740991\`)]`,
+    )
+  })
+
+  test('error: rejects excess root approvals', () => {
+    const witness = MultisigWitness.fromRpc(rpc)
+    expect(() =>
+      MultisigWitness.toRpc({
+        ...witness,
+        approvals: Array.from({ length: 9 }, () => witness.approvals[0]!),
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[MultisigWitness.InvalidWitnessError: Invalid multisig witness: approval count exceeds 8.]`,
+    )
+  })
+
+  test('error: rejects excess nested approvals', () => {
+    const witness = MultisigWitness.fromRpc(rpc)
+    const nested = witness.approvals[1]!
+    if (nested.type !== 'multisig') throw new Error('unreachable')
+    expect(() =>
+      MultisigWitness.toRpc({
+        ...witness,
+        approvals: [
+          {
+            ...nested,
+            witness: {
+              ...nested.witness,
+              approvals: Array.from(
+                { length: 9 },
+                () => nested.witness.approvals[0]!,
+              ),
+            },
+          },
+        ],
+      }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[MultisigWitness.InvalidWitnessError: Invalid multisig witness: approval count exceeds 8.]`,
+    )
+  })
+})