ox 0.14.55 → 0.14.56

package/tempo/{MultisigOperation.test.ts → AccountOperation.test.ts}

@@ -1,13 +1,13 @@
 import { Address, Hash, P256 } from 'ox'
 import {
+  AccountConfig,
+  AccountOperation,
   KeyAuthorization,
-  MultisigConfig,
-  MultisigOperation,
   SignatureEnvelope,
   TxEnvelopeTempo,
 } from 'ox/tempo'
 import { describe, expect, test } from 'vitest'
-import { factory } from '../../test/tempo/multisig.js'
+import { factory } from '../../test/tempo/configurableAccounts.js'
 
 const owners = [1n, 2n, 3n]
   .map((value, index) => {
@@ -30,15 +30,15 @@ const owners = [1n, 2n, 3n]
   .sort((a, b) => a.address.localeCompare(b.address))
 const owner_1 = owners[0]!.address
 const owner_2 = owners[1]!.address
-const config = MultisigConfig.from({
+const config = AccountConfig.from({
   owners: [
     { owner: owner_1, weight: 1 },
     { owner: owner_2, weight: 1 },
   ],
   threshold: 2,
 })
-const currentConfig = MultisigConfig.from({ ...config, version: 1n })
-const account = MultisigConfig.getAddress(config, { factory })
+const currentConfig = AccountConfig.from({ ...config, version: 1n })
+const account = AccountConfig.getAddress(config, { factory })
 const ownerSignature_1 = owners[0]!.signature
 const approval_1 = SignatureEnvelope.serialize(ownerSignature_1)
 const approval_2 = SignatureEnvelope.serialize(owners[1]!.signature)
@@ -62,14 +62,14 @@ const keyAuthorization = KeyAuthorization.serialize(
   }),
 )
 
-const transactionHash_ = MultisigConfig.getSignPayload({
+const transactionHash_ = AccountConfig.getSignPayload({
   account,
   config: currentConfig,
   payload: TxEnvelopeTempo.getSignPayload(
     TxEnvelopeTempo.deserialize(transaction),
   ),
 })
-const keyAuthorizationHash = MultisigConfig.getSignPayload({
+const keyAuthorizationHash = AccountConfig.getSignPayload({
   account,
   config: currentConfig,
   payload: KeyAuthorization.getSignPayload(
@@ -136,13 +136,13 @@ function approvalAddresses(
 describe('getHash', () => {
   test('transaction and key authorization', () => {
     expect({
-      keyAuthorization: MultisigOperation.getHash({
+      keyAuthorization: AccountOperation.getHash({
         account,
         config: currentConfig,
         keyAuthorization,
         type: 'keyAuthorization',
       }),
-      transaction: MultisigOperation.getHash({
+      transaction: AccountOperation.getHash({
         account,
         config: currentConfig,
         transaction,
@@ -159,7 +159,7 @@ describe('getHash', () => {
 
 describe('selectApprovals', () => {
   test('selects a deterministic weighted quorum', async () => {
-    const config = MultisigConfig.from({
+    const config = AccountConfig.from({
       owners: [
         { owner: owners[0]!.address, weight: 2 },
         { owner: owners[1]!.address, weight: 1 },
@@ -167,8 +167,8 @@ describe('selectApprovals', () => {
       ],
       threshold: 3,
     })
-    const account = MultisigConfig.getAddress(config, { factory })
-    const hash = MultisigOperation.getHash({
+    const account = AccountConfig.getAddress(config, { factory })
+    const hash = AccountOperation.getHash({
       account,
       config: { ...config, version: 1n },
       transaction,
@@ -176,7 +176,7 @@ describe('selectApprovals', () => {
     })
     const approvals = owners.map((owner) => signApproval(owner, hash))
     const alternate = signApproval(owners[0]!, hash, `0x${'01'.repeat(32)}`)
-    const selection = await MultisigOperation.selectApprovals({
+    const selection = await AccountOperation.selectApprovals({
       account,
       approvals: [
         approvals[2]!,
@@ -188,7 +188,7 @@ describe('selectApprovals', () => {
       config,
       hash,
     })
-    const reversed = await MultisigOperation.selectApprovals({
+    const reversed = await AccountOperation.selectApprovals({
       account,
       approvals: [
         approvals[0]!,
@@ -224,7 +224,7 @@ describe('selectApprovals', () => {
     `)
   })
   test('accepts an explicit account from a chain-configured factory', async () => {
-    const selected = await MultisigOperation.selectApprovals({
+    const selected = await AccountOperation.selectApprovals({
       account,
       approvals: [],
       config,
@@ -232,7 +232,7 @@ describe('selectApprovals', () => {
     })
     expect(selected.weight).toMatchInlineSnapshot(`0`)
   })
-  test('rejects keychain and multisig owner approvals', async () => {
+  test('rejects keychain and configurable owner approvals', async () => {
     for (const signature of [
       SignatureEnvelope.from({
         inner: ownerSignature_1,
@@ -247,19 +247,19 @@ describe('selectApprovals', () => {
       }),
     ])
       await expect(
-        MultisigOperation.selectApprovals({
+        AccountOperation.selectApprovals({
           account,
           approvals: [SignatureEnvelope.serialize(signature)],
           config,
           hash: transactionHash_,
         }),
       ).rejects.toThrowErrorMatchingInlineSnapshot(
-        `[MultisigOperation.InvalidApprovalError: Invalid multisig approval: only primitive signatures can approve a multisig operation.]`,
+        `[AccountOperation.InvalidApprovalError: Invalid operation approval: only primitive signatures can approve an account operation.]`,
       )
   })
 
   test('rejects invalid and non-owner approvals', async () => {
-    const hash = MultisigOperation.getHash({
+    const hash = AccountOperation.getHash({
       account,
       config: currentConfig,
       transaction,
@@ -272,24 +272,24 @@ describe('selectApprovals', () => {
     const nonOwner = signApproval(owners[2]!, hash)
 
     await expect(
-      MultisigOperation.selectApprovals({
+      AccountOperation.selectApprovals({
         account,
         approvals: [invalid],
         config,
         hash,
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[MultisigOperation.InvalidApprovalError: Invalid multisig approval: signature from owner 0x07e1ed8ea0e9601e5546b0a03aed683df3601407 is invalid.]`,
+      `[AccountOperation.InvalidApprovalError: Invalid operation approval: signature from owner 0x07e1ed8ea0e9601e5546b0a03aed683df3601407 is invalid.]`,
     )
     await expect(
-      MultisigOperation.selectApprovals({
+      AccountOperation.selectApprovals({
         account,
         approvals: [nonOwner],
         config,
         hash,
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(
-      `[MultisigOperation.InvalidApprovalError: Invalid multisig approval: signature is from non-owner 0xd3a9f047ad43d7e2e4e7e491f1fe2e657a2651b6.]`,
+      `[AccountOperation.InvalidApprovalError: Invalid operation approval: signature is from non-owner 0xd3a9f047ad43d7e2e4e7e491f1fe2e657a2651b6.]`,
     )
   })
 })
@@ -298,13 +298,13 @@ describe('serializeKeyAuthorization', () => {
   test('behavior: current and initial authorizations', async () => {
     const results = []
     for (const applicableConfig of [currentConfig, config]) {
-      const hash = MultisigOperation.getHash({
+      const hash = AccountOperation.getHash({
         account,
         config: applicableConfig,
         keyAuthorization,
         type: 'keyAuthorization',
       })
-      const selection = await MultisigOperation.selectApprovals({
+      const selection = await AccountOperation.selectApprovals({
         account,
         approvals: [
           signApproval(owners[1]!, hash),
@@ -313,7 +313,7 @@ describe('serializeKeyAuthorization', () => {
         config: applicableConfig,
         hash,
       })
-      const serialized = MultisigOperation.serializeKeyAuthorization(
+      const serialized = AccountOperation.serializeKeyAuthorization(
         keyAuthorization,
         {
           account,
@@ -324,16 +324,16 @@ describe('serializeKeyAuthorization', () => {
       const value = KeyAuthorization.deserialize(serialized)
       results.push({
         account:
-          value.signature?.type === 'multisig'
+          value.signature?.type === 'configurable'
             ? value.signature.account
             : undefined,
         hash: Hash.keccak256(serialized),
         signatureCount:
-          value.signature?.type === 'multisig'
+          value.signature?.type === 'configurable'
             ? value.signature.signatures.length
             : 0,
         version:
-          value.signature?.type === 'multisig'
+          value.signature?.type === 'configurable'
             ? value.signature.config.version
             : undefined,
       })
@@ -358,7 +358,7 @@ describe('serializeKeyAuthorization', () => {
   })
 
   test('error: signed authorization', async () => {
-    const selection = await MultisigOperation.selectApprovals({
+    const selection = await AccountOperation.selectApprovals({
       account,
       approvals: [
         signApproval(owners[0]!, keyAuthorizationHash),
@@ -367,7 +367,7 @@ describe('serializeKeyAuthorization', () => {
       config: currentConfig,
       hash: keyAuthorizationHash,
     })
-    const signed = MultisigOperation.serializeKeyAuthorization(
+    const signed = AccountOperation.serializeKeyAuthorization(
       keyAuthorization,
       {
         account,
@@ -377,13 +377,13 @@ describe('serializeKeyAuthorization', () => {
     )
 
     expect(() =>
-      MultisigOperation.serializeKeyAuthorization(signed, {
+      AccountOperation.serializeKeyAuthorization(signed, {
         account,
         approvals: selection.selectedApprovals,
         config: currentConfig,
       }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigOperation.InvalidOperationError: Invalid multisig operation: keyAuthorization must not contain a signature.]`,
+      `[AccountOperation.InvalidOperationError: Invalid account operation: keyAuthorization must not contain a signature.]`,
     )
   })
 })
@@ -392,13 +392,13 @@ describe('serializeTransaction', () => {
   test('current and initial transactions', async () => {
     const results = []
     for (const applicableConfig of [currentConfig, config]) {
-      const hash = MultisigOperation.getHash({
+      const hash = AccountOperation.getHash({
         account,
         config: applicableConfig,
         transaction,
         type: 'transaction',
       })
-      const selection = await MultisigOperation.selectApprovals({
+      const selection = await AccountOperation.selectApprovals({
         account,
         approvals: [
           signApproval(owners[1]!, hash),
@@ -407,7 +407,7 @@ describe('serializeTransaction', () => {
         config: applicableConfig,
         hash,
       })
-      const operation = MultisigOperation.from({
+      const operation = AccountOperation.from({
         account,
         approvals: selection.approvals,
         config: applicableConfig,
@@ -421,19 +421,19 @@ describe('serializeTransaction', () => {
         updatedAt: 1,
         weight: selection.weight,
       })
-      const serialized = MultisigOperation.serializeTransaction(operation, {
+      const serialized = AccountOperation.serializeTransaction(operation, {
         approvals: selection.selectedApprovals,
       })
       const value = TxEnvelopeTempo.deserialize(serialized)
       results.push({
         account: value.signature?.account,
         version:
-          value.signature?.type === 'multisig'
+          value.signature?.type === 'configurable'
             ? value.signature.config.version
             : undefined,
         hash: Hash.keccak256(serialized),
         signatureCount:
-          value.signature?.type === 'multisig'
+          value.signature?.type === 'configurable'
             ? value.signature.signatures.length
             : 0,
         type: serialized.slice(0, 4),
@@ -480,13 +480,13 @@ describe('serializeTransaction', () => {
     ] as const
     const results = []
     for (const transaction of transactions) {
-      const hash = MultisigOperation.getHash({
+      const hash = AccountOperation.getHash({
         account,
         config: currentConfig,
         transaction,
         type: 'transaction',
       })
-      const selection = await MultisigOperation.selectApprovals({
+      const selection = await AccountOperation.selectApprovals({
         account,
         approvals: [
           signApproval(owners[0]!, hash),
@@ -495,8 +495,8 @@ describe('serializeTransaction', () => {
         config: currentConfig,
         hash,
       })
-      const serialized = MultisigOperation.serializeTransaction(
-        MultisigOperation.from({
+      const serialized = AccountOperation.serializeTransaction(
+        AccountOperation.from({
           account,
           approvals: selection.approvals,
           config: currentConfig,
@@ -517,7 +517,7 @@ describe('serializeTransaction', () => {
         feePayerSignature: value.feePayerSignature,
         from: value.from,
         signatureCount:
-          value.signature?.type === 'multisig'
+          value.signature?.type === 'configurable'
             ? value.signature.signatures.length
             : 0,
         type: serialized.slice(0, 4),
@@ -547,7 +547,7 @@ describe('serializeTransaction', () => {
   })
 
   test('rejects an approval not retained by the operation', async () => {
-    const hash = MultisigOperation.getHash({
+    const hash = AccountOperation.getHash({
       account,
       config: currentConfig,
       transaction,
@@ -555,13 +555,13 @@ describe('serializeTransaction', () => {
     })
     const approval_1 = signApproval(owners[0]!, hash)
     const approval_2 = signApproval(owners[1]!, hash)
-    const selection = await MultisigOperation.selectApprovals({
+    const selection = await AccountOperation.selectApprovals({
       account,
       approvals: [approval_1],
       config: currentConfig,
       hash,
     })
-    const operation = MultisigOperation.from({
+    const operation = AccountOperation.from({
       account,
       approvals: selection.approvals,
       config: currentConfig,
@@ -577,19 +577,19 @@ describe('serializeTransaction', () => {
     })
 
     expect(() =>
-      MultisigOperation.serializeTransaction(operation, {
+      AccountOperation.serializeTransaction(operation, {
         approvals: [approval_2],
       }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[MultisigOperation.InvalidOperationError: Invalid multisig operation: transaction signature is not a retained approval.]`,
+      `[AccountOperation.InvalidOperationError: Invalid account operation: transaction signature is not a retained approval.]`,
     )
   })
 })
 
 describe('from', () => {
   test('transaction states', () => {
-    const pending = MultisigOperation.from(transactionPending)
-    const submitting = MultisigOperation.from({
+    const pending = AccountOperation.from(transactionPending)
+    const submitting = AccountOperation.from({
       ...transactionPending,
       approvals: [approval_1, approval_2],
       expiresAt: 10,
@@ -598,7 +598,7 @@ describe('from', () => {
       submissionId,
       weight: 2,
     })
-    const success = MultisigOperation.from({
+    const success = AccountOperation.from({
       ...transactionPending,
       approvals: [approval_1, approval_2],
       signatureCount: 2,
@@ -716,9 +716,9 @@ describe('from', () => {
       }),
       { format: 'feePayer', sender: account },
     )
-    const operation = MultisigOperation.from({
+    const operation = AccountOperation.from({
       ...transactionPending,
-      hash: MultisigConfig.getSignPayload({
+      hash: AccountConfig.getSignPayload({
         account,
         config: currentConfig,
         payload: TxEnvelopeTempo.getSignPayload(
@@ -777,9 +777,9 @@ describe('from', () => {
       }),
       { format: 'feePayer' },
     )
-    const operation = MultisigOperation.from({
+    const operation = AccountOperation.from({
       ...transactionPending,
-      hash: MultisigConfig.getSignPayload({
+      hash: AccountConfig.getSignPayload({
         account,
         config: currentConfig,
         payload: TxEnvelopeTempo.getSignPayload(
@@ -793,10 +793,10 @@ describe('from', () => {
   })
 
   test('initial transaction', () => {
-    const operation = MultisigOperation.from({
+    const operation = AccountOperation.from({
       ...transactionPending,
       config,
-      hash: MultisigConfig.getSignPayload({
+      hash: AccountConfig.getSignPayload({
         account,
         config,
         payload: TxEnvelopeTempo.getSignPayload(
@@ -846,9 +846,9 @@ describe('from', () => {
   })
 
   test('key authorization states', () => {
-    const pending = MultisigOperation.from(keyAuthorizationPending)
+    const pending = AccountOperation.from(keyAuthorizationPending)
     const authorization = KeyAuthorization.deserialize(keyAuthorization)
-    const success = MultisigOperation.from({
+    const success = AccountOperation.from({
       ...keyAuthorizationPending,
       approvals: [approval_1, approval_2],
       keyAuthorization: KeyAuthorization.serialize(
@@ -857,7 +857,7 @@ describe('from', () => {
             account,
             config: currentConfig,
             signatures: [ownerSignature_1, owners[1]!.signature],
-            type: 'multisig',
+            type: 'configurable',
           },
         }),
       ),
@@ -941,15 +941,15 @@ describe('from', () => {
           account,
           config,
           signatures: [ownerSignature_1, owners[1]!.signature],
-          type: 'multisig',
+          type: 'configurable',
         },
       }),
     )
-    const operation = MultisigOperation.from({
+    const operation = AccountOperation.from({
       ...keyAuthorizationPending,
       approvals: [approval_1, approval_2],
       config,
-      hash: MultisigConfig.getSignPayload({
+      hash: AccountConfig.getSignPayload({
         account,
         config,
         payload: KeyAuthorization.getSignPayload(authorization),
@@ -1004,8 +1004,8 @@ describe('from', () => {
 
 describe('RPC conversion', () => {
   test('round-trips transaction and key authorization operations', () => {
-    const transactionRpc = MultisigOperation.toRpc(transactionPending)
-    const keyAuthorizationRpc = MultisigOperation.toRpc(keyAuthorizationPending)
+    const transactionRpc = AccountOperation.toRpc(transactionPending)
+    const keyAuthorizationRpc = AccountOperation.toRpc(keyAuthorizationPending)
 
     expect(() =>
       JSON.stringify({ keyAuthorizationRpc, transactionRpc }),
@@ -1074,11 +1074,11 @@ describe('RPC conversion', () => {
         },
       }
     `)
-    expect(MultisigOperation.fromRpc(transactionRpc)).toStrictEqual(
-      MultisigOperation.from(transactionPending),
+    expect(AccountOperation.fromRpc(transactionRpc)).toStrictEqual(
+      AccountOperation.from(transactionPending),
     )
-    expect(MultisigOperation.fromRpc(keyAuthorizationRpc)).toStrictEqual(
-      MultisigOperation.from(keyAuthorizationPending),
+    expect(AccountOperation.fromRpc(keyAuthorizationRpc)).toStrictEqual(
+      AccountOperation.from(keyAuthorizationPending),
     )
   })
 })
@@ -1175,7 +1175,7 @@ describe('validation', () => {
       name: 'weight unreachable by the retained owner approvals',
       operation: {
         ...transactionPending,
-        config: MultisigConfig.from({
+        config: AccountConfig.from({
           owners: [
             { owner: owner_1, weight: 1 },
             { owner: owner_2, weight: 2 },
@@ -1194,7 +1194,7 @@ describe('validation', () => {
       operation: {
         ...transactionPending,
         account: '0x0000000000000000000000000000000000000000',
-        hash: MultisigConfig.getSignPayload({
+        hash: AccountConfig.getSignPayload({
           account: '0x0000000000000000000000000000000000000000',
           config: currentConfig,
           payload: TxEnvelopeTempo.getSignPayload(
@@ -1271,21 +1271,21 @@ describe('validation', () => {
             account,
             config,
             signatures: [ownerSignature_1],
-            type: 'multisig',
+            type: 'configurable',
           }),
         ],
       },
     },
   ])('rejects $name', ({ operation }) => {
     expect(() =>
-      MultisigOperation.from(operation as MultisigOperation.Operation),
-    ).toThrowError(MultisigOperation.InvalidOperationError)
+      AccountOperation.from(operation as AccountOperation.Operation),
+    ).toThrowError(AccountOperation.InvalidOperationError)
   })
   test('accepts initial accounts validated by the chain', () => {
-    const value = MultisigOperation.from({
+    const value = AccountOperation.from({
       ...transactionPending,
       config,
-      hash: MultisigOperation.getHash({
+      hash: AccountOperation.getHash({
         account,
         config,
         transaction,
@@ -1297,14 +1297,14 @@ describe('validation', () => {
   })
 
   test('rejects noncanonical RPC quantities', () => {
-    const operation = MultisigOperation.toRpc(transactionPending)
+    const operation = AccountOperation.toRpc(transactionPending)
     expect(() =>
-      MultisigOperation.fromRpc({
+      AccountOperation.fromRpc({
         ...operation,
         config: { ...operation.config, version: '0x01' },
       }),
     ).toThrowError(
-      'Invalid multisig operation: config.version must use canonical quantity encoding.',
+      'Invalid account operation: config.version must use canonical quantity encoding.',
     )
   })
 
@@ -1319,7 +1319,7 @@ describe('validation', () => {
             account,
             config: currentConfig,
             signatures: [ownerSignature_1, owners[2]!.signature],
-            type: 'multisig',
+            type: 'configurable',
           },
         }),
       ),
@@ -1328,15 +1328,15 @@ describe('validation', () => {
       weight: 2,
     } as const
 
-    expect(() => MultisigOperation.from(operation)).toThrowError(
-      'Invalid multisig operation: key authorization signature is not a retained approval.',
+    expect(() => AccountOperation.from(operation)).toThrowError(
+      'Invalid account operation: key authorization signature is not a retained approval.',
     )
   })
 
   test('rejects unordered key authorization approvals', () => {
     const authorization = KeyAuthorization.deserialize(keyAuthorization)
     const signatures = [
-      ...SignatureEnvelope.sortMultisigApprovals({
+      ...SignatureEnvelope.sortApprovals({
         account,
         config: currentConfig,
         payload: KeyAuthorization.getSignPayload(authorization),
@@ -1352,7 +1352,7 @@ describe('validation', () => {
             account,
             config: currentConfig,
             signatures,
-            type: 'multisig',
+            type: 'configurable',
           },
         }),
       ),
@@ -1361,8 +1361,8 @@ describe('validation', () => {
       weight: 2,
     } as const
 
-    expect(() => MultisigOperation.from(operation)).toThrowError(
-      'Invalid multisig operation: key authorization approvals are not canonically ordered.',
+    expect(() => AccountOperation.from(operation)).toThrowError(
+      'Invalid account operation: key authorization approvals are not canonically ordered.',
     )
   })
 
@@ -1377,7 +1377,7 @@ describe('validation', () => {
             account,
             config: currentConfig,
             signatures: [ownerSignature_1, ownerSignature_1],
-            type: 'multisig',
+            type: 'configurable',
           },
         }),
       ),
@@ -1386,13 +1386,13 @@ describe('validation', () => {
       weight: 2,
     } as const
 
-    expect(() => MultisigOperation.from(operation)).toThrowError(
-      'Invalid multisig operation: key authorization contains duplicate owner approvals.',
+    expect(() => AccountOperation.from(operation)).toThrowError(
+      'Invalid account operation: key authorization contains duplicate owner approvals.',
     )
   })
 
   test('accepts case-insensitive initial configs', () => {
-    const config = MultisigConfig.from({
+    const config = AccountConfig.from({
       owners: [
         {
           owner: Address.checksum(owner_1),
@@ -1406,7 +1406,7 @@ describe('validation', () => {
       salt: `0x${'AB'.repeat(32)}`,
       threshold: 2,
     })
-    const account = MultisigConfig.getAddress(config, { factory })
+    const account = AccountConfig.getAddress(config, { factory })
     const authorization = KeyAuthorization.from({
       account,
       address: '0x3333333333333333333333333333333333333333',
@@ -1415,7 +1415,7 @@ describe('validation', () => {
       isAdmin: false,
       type: 'secp256k1',
     })
-    const signatures = SignatureEnvelope.sortMultisigApprovals({
+    const signatures = SignatureEnvelope.sortApprovals({
       account,
       config,
       payload: KeyAuthorization.getSignPayload(authorization),
@@ -1425,12 +1425,12 @@ describe('validation', () => {
       SignatureEnvelope.serialize(signature),
     )
 
-    const operation = MultisigOperation.from({
+    const operation = AccountOperation.from({
       account,
       approvals,
       config,
       createdAt: 1,
-      hash: MultisigConfig.getSignPayload({
+      hash: AccountConfig.getSignPayload({
         account,
         config,
         payload: KeyAuthorization.getSignPayload(authorization),
@@ -1441,7 +1441,7 @@ describe('validation', () => {
             account,
             config,
             signatures,
-            type: 'multisig',
+            type: 'configurable',
           },
         }),
       ),