viem 3.0.0-next.13 → 3.0.0-next.14

package/dist/tempo/internal/relay/{multisig.js → accounts.js}

@@ -1,22 +1,22 @@
 import { AbiFunction, Address as Address_, Hash, Hex, RpcResponse } from 'ox';
-import { KeyAuthorization, MultisigConfig, MultisigOperation, Transaction as ox_Transaction, SignatureEnvelope, TxEnvelopeTempo, } from 'ox/tempo';
+import { KeyAuthorization, AccountConfig, AccountOperation, Transaction as ox_Transaction, SignatureEnvelope, TxEnvelopeTempo, } from 'ox/tempo';
 import { getNumber as getBlockNumber } from '../../../core/actions/block/getNumber.js';
 import { create as createClient } from '../../../core/Client.js';
 import * as Abis from '../../Abis.js';
 import * as Addresses from '../../Addresses.js';
-import { getConfigCommitment } from '../../actions/multisig/getConfigCommitment.js';
-import * as ConfigStore from '../../multisig/Config.js';
-import * as OperationStore from '../../multisig/Operation.js';
+import { getConfigCommitment } from '../../actions/accounts/getConfigCommitment.js';
+import * as ConfigStore from '../../accounts/Config.js';
+import * as OperationStore from '../../accounts/Operation.js';
 import * as Plugin from './plugin.js';
 const submissionTtl = 30_000;
 const pollingInterval = 100;
-/** Creates middleware for multisig approval coordination. @internal */
+/** Creates middleware for owner approval coordination. @internal */
 export function create(options) {
     if (!options.store.compareAndSet)
         throw new RpcResponse.InvalidParamsError({
-            message: 'Multisig coordination requires a store with atomic `compareAndSet`.',
+            message: 'Account coordination requires a store with atomic `compareAndSet`.',
         });
-    return Plugin.multisig({
+    return Plugin.accounts({
         async handleRequest(context, forward) {
             const { request, options: requestOptions_ } = context;
             const requestOptions = await resolveRequestOptions({
@@ -32,15 +32,15 @@ export function create(options) {
             };
             const client = createClient({
                 transport: {
-                    key: 'multisig-forward',
-                    name: 'Multisig Forwarding',
-                    type: 'multisig-forward',
+                    key: 'accounts-forward',
+                    name: 'Accounts Forwarding',
+                    type: 'accounts-forward',
                     setup: () => ({
                         request: ((request, options) => next(request, { ...requestOptions, ...options })),
                     }),
                 },
             });
-            if (request.method === 'multisig_getConfig') {
+            if (request.method === 'account_getConfig') {
                 const value = request.params?.[0];
                 const address = value && typeof value === 'object' && 'address' in value
                     ? value.address
@@ -49,7 +49,7 @@ export function create(options) {
                     !Address_.validate(address) ||
                     Hex.toBigInt(address) === 0n)
                     throw new RpcResponse.InvalidParamsError({
-                        message: 'Expected a multisig account address.',
+                        message: 'Expected a configurable account address.',
                     });
                 const blockNumber = await getBlockNumber(client, { cacheTime: 0 });
                 const commitment = await getConfigCommitment(client, {
@@ -62,18 +62,18 @@ export function create(options) {
                 });
                 if (!config)
                     return null;
-                return MultisigConfig.toRpc(config);
+                return AccountConfig.toRpc(config);
             }
-            if (request.method === 'multisig_getOperation') {
+            if (request.method === 'account_getOperation') {
                 const hash = request.params?.[0];
                 if (typeof hash !== 'string' || !Hash.validate(hash))
                     throw new RpcResponse.InvalidParamsError({
-                        message: 'Expected a multisig operation hash.',
+                        message: 'Expected an account operation hash.',
                     });
                 const operation = await OperationStore.read(options.store, hash);
-                return operation ? MultisigOperation.toRpc(operation) : null;
+                return operation ? AccountOperation.toRpc(operation) : null;
             }
-            if (request.method === 'multisig_approveKeyAuthorization')
+            if (request.method === 'account_approveKeyAuthorization')
                 return await approveKeyAuthorization({
                     client,
                     request,
@@ -104,7 +104,7 @@ export function create(options) {
                         : operation;
                     return {
                         ...receipt,
-                        multisig: MultisigOperation.toRpc(success),
+                        operation: AccountOperation.toRpc(success),
                     };
                 }
                 if (operation.status === 'pending')
@@ -123,13 +123,13 @@ export function create(options) {
                     : operation;
                 return {
                     ...transaction,
-                    multisig: MultisigOperation.toRpc(success),
+                    operation: AccountOperation.toRpc(success),
                 };
             }
             if (request.method !== 'eth_sendRawTransaction' &&
                 request.method !== 'eth_sendRawTransactionSync' &&
-                request.method !== 'multisig_approveRawTransaction' &&
-                request.method !== 'multisig_approveRawTransactionSync')
+                request.method !== 'account_approveRawTransaction' &&
+                request.method !== 'account_approveRawTransactionSync')
                 return forward();
             const standard = request.method === 'eth_sendRawTransaction' ||
                 request.method === 'eth_sendRawTransactionSync';
@@ -138,7 +138,7 @@ export function create(options) {
                 if (standard)
                     return forward();
                 throw new RpcResponse.InvalidParamsError({
-                    message: 'Expected a serialized Tempo multisig transaction.',
+                    message: 'Expected a serialized Tempo configurable account transaction.',
                 });
             }
             return await submit({
@@ -168,26 +168,26 @@ async function submit(options) {
         }
     })();
     const signature = transaction?.signature;
-    if (!transaction || signature?.type !== 'multisig') {
+    if (!transaction || signature?.type !== 'configurable') {
         if (options.method === 'eth_sendRawTransaction' ||
             options.method === 'eth_sendRawTransactionSync')
             return await options.next(options.request, options.requestOptions);
         throw new RpcResponse.InvalidParamsError({
-            message: 'Expected a multisig transaction signature.',
+            message: 'Expected a configurable account transaction signature.',
         });
     }
     const { signature: _, ...unsigned } = transaction;
     const envelope = TxEnvelopeTempo.from(unsigned);
     const serializedUnsigned = serializeUnsigned(envelope, options.serialized.startsWith(TxEnvelopeTempo.feePayerMagic));
     const blockNumber = await getBlockNumber(options.client, { cacheTime: 0 });
-    const config = MultisigConfig.from(signature.config);
+    const config = AccountConfig.from(signature.config);
     const configCommitment = await validateConfig({
         account: signature.account,
         blockNumber,
         client: options.client,
         config,
     });
-    const operationHash = MultisigOperation.getHash({
+    const operationHash = AccountOperation.getHash({
         account: signature.account,
         config,
         transaction: serializedUnsigned,
@@ -196,7 +196,7 @@ async function submit(options) {
     const incoming = signature.signatures.map((signature) => SignatureEnvelope.serialize(signature));
     if (incoming.length === 0)
         throw new RpcResponse.InvalidParamsError({
-            message: 'A multisig approval envelope must include a signature.',
+            message: 'A owner approval envelope must include a signature.',
         });
     const now = Date.now();
     const expiredSubmissionIds = new Set();
@@ -223,7 +223,7 @@ async function submit(options) {
             hash: operationHash,
             approvals: [...(existingApprovals?.approvals ?? []), ...incoming],
         });
-        return MultisigOperation.from({
+        return AccountOperation.from({
             account: signature.account,
             approvals: approvals.approvals,
             config,
@@ -266,7 +266,7 @@ async function submit(options) {
     const submissionId = Hex.random(32);
     const timeout = options.request.params?.[1];
     const synchronous = options.method === 'eth_sendRawTransactionSync' ||
-        options.method === 'multisig_approveRawTransactionSync';
+        options.method === 'account_approveRawTransactionSync';
     const leaseTtl = synchronous &&
         typeof timeout === 'number' &&
         Number.isSafeInteger(timeout) &&
@@ -283,7 +283,7 @@ async function submit(options) {
         if (current.weight < current.threshold)
             return current;
         const now = Date.now();
-        return MultisigOperation.from({
+        return AccountOperation.from({
             ...current,
             expiresAt: Math.min(now + leaseTtl, Number.MAX_SAFE_INTEGER),
             status: 'submitting',
@@ -316,7 +316,7 @@ async function submit(options) {
                 hash: claim.hash,
                 approvals: claim.approvals,
             });
-            const final = MultisigOperation.serializeTransaction(claim, {
+            const final = AccountOperation.serializeTransaction(claim, {
                 approvals: finalApprovals.selectedApprovals,
             });
             const transactionHash = TxEnvelopeTempo.hash(TxEnvelopeTempo.deserialize(final));
@@ -342,7 +342,7 @@ async function submit(options) {
         try {
             result = await options.next({
                 method: options.method === 'eth_sendRawTransaction' ||
-                    options.method === 'multisig_approveRawTransaction'
+                    options.method === 'account_approveRawTransaction'
                     ? 'eth_sendRawTransaction'
                     : 'eth_sendRawTransactionSync',
                 params: [final, ...(options.request.params?.slice(1) ?? [])],
@@ -390,7 +390,7 @@ async function submit(options) {
             current.submissionId !== submissionId)
             throw new OperationStore.InvalidStoreValueError();
         const { expiresAt: _, submissionId: __, ...operation } = current;
-        return MultisigOperation.from({
+        return AccountOperation.from({
             ...operation,
             status: 'success',
             transactionHash,
@@ -403,16 +403,16 @@ async function submit(options) {
     if (options.method === 'eth_sendRawTransactionSync' &&
         result &&
         typeof result === 'object')
-        return { ...result, multisig: MultisigOperation.toRpc(success) };
+        return { ...result, operation: AccountOperation.toRpc(success) };
     return await submittedResult(options, success);
 }
-/** Collects approvals for a multisig key authorization. @internal */
+/** Collects approvals for a configurable account key authorization. @internal */
 // biome-ignore lint/correctness/noUnusedVariables: declaration merge
 async function approveKeyAuthorization(options) {
     const value = options.request.params?.[0];
     if (!value || typeof value !== 'object')
         throw new RpcResponse.InvalidParamsError({
-            message: 'Expected a multisig key authorization approval.',
+            message: 'Expected a configurable account key authorization approval.',
         });
     const approval = await (async () => {
         if ('keyAuthorization' in value) {
@@ -422,24 +422,24 @@ async function approveKeyAuthorization(options) {
                 }
                 catch {
                     throw new RpcResponse.InvalidParamsError({
-                        message: 'Invalid multisig key authorization.',
+                        message: 'Invalid configurable account key authorization.',
                     });
                 }
             })();
             const signature = authorization.signature;
-            if (signature?.type !== 'multisig')
+            if (signature?.type !== 'configurable')
                 throw new RpcResponse.InvalidParamsError({
-                    message: 'Expected a multisig key authorization signature.',
+                    message: 'Expected a configurable account key authorization signature.',
                 });
             if (!authorization.account ||
                 !Address_.isEqual(authorization.account, signature.account))
                 throw new RpcResponse.InvalidParamsError({
-                    message: 'Multisig key authorization account does not match its signature.',
+                    message: 'Configurable account key authorization account does not match its signature.',
                 });
             const { signature: _, ...unsigned } = authorization;
             const keyAuthorization = KeyAuthorization.serialize(KeyAuthorization.from(unsigned));
-            const config = MultisigConfig.from(signature.config);
-            const hash = MultisigOperation.getHash({
+            const config = AccountConfig.from(signature.config);
+            const hash = AccountOperation.getHash({
                 account: signature.account,
                 config,
                 keyAuthorization,
@@ -456,12 +456,12 @@ async function approveKeyAuthorization(options) {
         if ('hash' in value && 'signature' in value) {
             if (typeof value.hash !== 'string' || !Hash.validate(value.hash))
                 throw new RpcResponse.InvalidParamsError({
-                    message: 'Expected a multisig operation hash.',
+                    message: 'Expected an account operation hash.',
                 });
             const operation = await OperationStore.read(options.store, value.hash);
             if (!operation || operation.type !== 'keyAuthorization')
                 throw new RpcResponse.InvalidParamsError({
-                    message: 'Multisig key authorization operation was not found.',
+                    message: 'Configurable account key authorization operation was not found.',
                 });
             if (operation.status === 'success')
                 return { operation };
@@ -471,7 +471,7 @@ async function approveKeyAuthorization(options) {
                 }
                 catch {
                     throw new RpcResponse.InvalidParamsError({
-                        message: 'Invalid multisig owner signature.',
+                        message: 'Invalid owner signature.',
                     });
                 }
             })();
@@ -484,14 +484,14 @@ async function approveKeyAuthorization(options) {
             };
         }
         throw new RpcResponse.InvalidParamsError({
-            message: 'Expected a multisig key authorization approval.',
+            message: 'Expected a configurable account key authorization approval.',
         });
     })();
     if ('operation' in approval)
-        return MultisigOperation.toRpc(approval.operation);
+        return AccountOperation.toRpc(approval.operation);
     if (approval.approvals.length === 0)
         throw new RpcResponse.InvalidParamsError({
-            message: 'A multisig approval envelope must include a signature.',
+            message: 'A owner approval envelope must include a signature.',
         });
     const blockNumber = await getBlockNumber(options.client, { cacheTime: 0 });
     const commitment = await validateConfig({
@@ -508,8 +508,8 @@ async function approveKeyAuthorization(options) {
             return existing;
         if (existing &&
             (existing.account.toLowerCase() !== approval.account.toLowerCase() ||
-                MultisigConfig.getCommitment(existing.config).toLowerCase() !==
-                    MultisigConfig.getCommitment(approval.config).toLowerCase() ||
+                AccountConfig.getCommitment(existing.config).toLowerCase() !==
+                    AccountConfig.getCommitment(approval.config).toLowerCase() ||
                 existing.keyAuthorization.toLowerCase() !==
                     approval.keyAuthorization.toLowerCase()))
             throw new OperationStore.InvalidStoreValueError();
@@ -548,10 +548,10 @@ async function approveKeyAuthorization(options) {
             weight: approvals.weight,
         };
         if (approvals.weight < approvals.threshold)
-            return MultisigOperation.from({ ...pending, status: 'pending' });
-        return MultisigOperation.from({
+            return AccountOperation.from({ ...pending, status: 'pending' });
+        return AccountOperation.from({
             ...pending,
-            keyAuthorization: MultisigOperation.serializeKeyAuthorization(approval.keyAuthorization, {
+            keyAuthorization: AccountOperation.serializeKeyAuthorization(approval.keyAuthorization, {
                 account: approval.account,
                 approvals: approvals.selectedApprovals,
                 config: approval.config,
@@ -566,7 +566,7 @@ async function approveKeyAuthorization(options) {
     });
     if (operation.type !== 'keyAuthorization')
         throw new OperationStore.InvalidStoreValueError();
-    return MultisigOperation.toRpc(operation);
+    return AccountOperation.toRpc(operation);
 }
 /** Deserializes a Tempo transaction or throws an RPC parameter error. */
 function deserialize(serialized) {
@@ -583,22 +583,22 @@ function deserialize(serialized) {
 function assertConfig(options) {
     const { account, commitment, config } = options;
     if (config.version === 0n &&
-        MultisigConfig.getAddress(config, {
+        AccountConfig.getAddress(config, {
             factory: Addresses.nativeMultisigFactory,
         }).toLowerCase() !== account.toLowerCase())
         throw new RpcResponse.InvalidParamsError({
-            message: 'Initial multisig config does not match the multisig account.',
+            message: 'Initial account config does not match the configurable account.',
         });
     if (config.version === 0n && Hex.toBigInt(commitment) === 0n)
         return;
     if (commitment.toLowerCase() !==
-        MultisigConfig.getCommitment(config).toLowerCase())
+        AccountConfig.getCommitment(config).toLowerCase())
         throw new RpcResponse.InvalidParamsError({
-            message: `Multisig config does not match account ${account}.`,
+            message: `Account config does not match account ${account}.`,
         });
 }
-/** Reads and validates a config commitment at one block. */
-async function validateConfig(options) {
+/** Reads and validates a config commitment at one block. @internal */
+export async function validateConfig(options) {
     const { account, blockNumber, client, config } = options;
     const commitment = await getConfigCommitment(client, {
         account,
@@ -635,24 +635,19 @@ async function cacheNextConfigs(options) {
         const [current, threshold, owners] = decoded.args;
         const suppliedConfig = (() => {
             try {
-                return MultisigConfig.from(current);
+                return AccountConfig.from(current);
             }
             catch {
                 return undefined;
             }
         })();
         if (!suppliedConfig ||
-            MultisigConfig.getCommitment(suppliedConfig).toLowerCase() !==
-                MultisigConfig.getCommitment(currentConfig).toLowerCase())
+            AccountConfig.getCommitment(suppliedConfig).toLowerCase() !==
+                AccountConfig.getCommitment(currentConfig).toLowerCase())
             continue;
         const config = (() => {
             try {
-                return MultisigConfig.from({
-                    owners,
-                    salt: suppliedConfig.salt,
-                    threshold,
-                    version: suppliedConfig.version + 1n,
-                });
+                return AccountConfig.update(suppliedConfig, { owners, threshold });
             }
             catch {
                 return undefined;
@@ -662,19 +657,19 @@ async function cacheNextConfigs(options) {
             continue;
         await ConfigStore.write(options.store, {
             address: options.account,
-            commitment: MultisigConfig.getCommitment(config),
+            commitment: AccountConfig.getCommitment(config),
             config,
         });
         currentConfig = config;
     }
 }
-/** Validates primitive approvals and translates invalid input into an RPC error. */
-async function selectApprovals(options) {
+/** Validates primitive approvals and translates invalid input into an RPC error. @internal */
+export async function selectApprovals(options) {
     try {
-        return await MultisigOperation.selectApprovals(options);
+        return await AccountOperation.selectApprovals(options);
     }
     catch (error) {
-        if (error instanceof MultisigOperation.InvalidApprovalError)
+        if (error instanceof AccountOperation.InvalidApprovalError)
             throw new RpcResponse.InvalidParamsError({ message: error.shortMessage });
         throw error;
     }
@@ -682,10 +677,10 @@ async function selectApprovals(options) {
 /** Returns an existing successful operation through the requested send method. */
 async function submittedResult(options, operation) {
     if (options.method === 'eth_sendRawTransaction' ||
-        options.method === 'multisig_approveRawTransaction')
+        options.method === 'account_approveRawTransaction')
         return operation.hash;
-    if (options.method === 'multisig_approveRawTransactionSync')
-        return MultisigOperation.toRpc(operation);
+    if (options.method === 'account_approveRawTransactionSync')
+        return AccountOperation.toRpc(operation);
     const timeout = options.request.params?.[1];
     const deadline = Date.now() +
         (typeof timeout === 'number' && timeout >= 0 ? timeout : submissionTtl);
@@ -695,16 +690,16 @@ async function submittedResult(options, operation) {
             params: [operation.transactionHash],
         }, options.requestOptions);
         if (receipt && typeof receipt === 'object')
-            return { ...receipt, multisig: MultisigOperation.toRpc(operation) };
+            return { ...receipt, operation: AccountOperation.toRpc(operation) };
         if (Date.now() >= deadline)
-            throw new Error('Timed out while waiting for the multisig transaction.');
+            throw new Error('Timed out while waiting for the configurable account transaction.');
         await new Promise((resolve) => setTimeout(resolve, pollingInterval));
     }
 }
 /** Waits for the relay that owns a live submission lease. */
 async function submittingResult(options, operation) {
     if (options.method === 'eth_sendRawTransaction' ||
-        options.method === 'multisig_approveRawTransaction')
+        options.method === 'account_approveRawTransaction')
         return operation.hash;
     const timeout = options.request.params?.[1];
     const deadline = Date.now() +
@@ -725,10 +720,10 @@ async function submittingResult(options, operation) {
 /** Returns a pending result for an operation that has not reached quorum. */
 function pendingResult(method, operation) {
     if (method === 'eth_sendRawTransaction' ||
-        method === 'multisig_approveRawTransaction')
+        method === 'account_approveRawTransaction')
         return operation.hash;
-    if (method === 'multisig_approveRawTransactionSync')
-        return MultisigOperation.toRpc(operation);
+    if (method === 'account_approveRawTransactionSync')
+        return AccountOperation.toRpc(operation);
     return {
         blockHash: null,
         blockNumber: null,
@@ -739,7 +734,7 @@ function pendingResult(method, operation) {
         gasUsed: null,
         logs: [],
         logsBloom: null,
-        multisig: MultisigOperation.toRpc(operation),
+        operation: AccountOperation.toRpc(operation),
         status: 'pending',
         to: null,
         transactionHash: operation.hash,
@@ -764,7 +759,7 @@ async function completeSubmission(store, operation, transactionHash) {
             current.submissionId !== operation.submissionId)
             throw new OperationStore.InvalidStoreValueError();
         const { expiresAt: _, submissionId: __, transactionHash: ___, ...value } = current;
-        return MultisigOperation.from({
+        return AccountOperation.from({
             ...value,
             status: 'success',
             transactionHash,
@@ -783,7 +778,7 @@ async function releaseSubmission(store, hash, submissionId) {
             current.submissionId !== submissionId)
             return current;
         const { expiresAt: _, submissionId: __, ...operation } = current;
-        return MultisigOperation.from({
+        return AccountOperation.from({
             ...operation,
             status: 'pending',
             updatedAt: Date.now(),
@@ -816,7 +811,7 @@ function mergeTransaction(existing, incoming) {
 async function toTransaction(client, operation) {
     const approvals = await (async () => {
         if (operation.status !== 'pending')
-            return await MultisigOperation.selectApprovals({
+            return await AccountOperation.selectApprovals({
                 account: operation.account,
                 approvals: operation.approvals,
                 config: operation.config,
@@ -837,7 +832,7 @@ async function toTransaction(client, operation) {
         });
     })();
     const current = operation.status === 'pending'
-        ? MultisigOperation.from({
+        ? AccountOperation.from({
             ...operation,
             approvals: approvals.approvals,
             signatureCount: approvals.signatureCount,
@@ -845,7 +840,7 @@ async function toTransaction(client, operation) {
             weight: approvals.weight,
         })
         : operation;
-    const serialized = MultisigOperation.serializeTransaction(current, {
+    const serialized = AccountOperation.serializeTransaction(current, {
         approvals: approvals.selectedApprovals,
     });
     const transaction = deserialize(serialized);
@@ -858,7 +853,7 @@ async function toTransaction(client, operation) {
             hash: operation.hash,
             transactionIndex: null,
         }, { pending: true }),
-        multisig: MultisigOperation.toRpc(current),
+        operation: AccountOperation.toRpc(current),
     };
 }
 /** Returns the persisted transaction hash for a submitting or successful operation. */
@@ -885,7 +880,7 @@ function maintainSubmissionLease(store, hash, submissionId, leaseTtl) {
                     if (current.status !== 'submitting' ||
                         current.submissionId !== submissionId)
                         return current;
-                    return MultisigOperation.from({
+                    return AccountOperation.from({
                         ...current,
                         expiresAt: Math.min(Date.now() + leaseTtl, Number.MAX_SAFE_INTEGER),
                         updatedAt: Date.now(),
@@ -927,7 +922,7 @@ function getTransactionHash(result) {
         typeof result.transactionHash === 'string' &&
         Hash.validate(result.transactionHash))
         return result.transactionHash;
-    throw new Error('Expected transaction hash in multisig broadcast result.');
+    throw new Error('Expected transaction hash in account broadcast result.');
 }
 /** Resolves and validates the chain used by a handled request. */
 async function resolveRequestOptions(options) {
@@ -956,11 +951,11 @@ async function resolveRequestChainId(request, store) {
     const chainId_body = value && typeof value === 'object' && 'chainId' in value
         ? parseChainId(value.chainId)
         : undefined;
-    const chainId_multisig = await (async () => {
+    const chainId_operation = await (async () => {
         if (request.method === 'eth_sendRawTransaction' ||
             request.method === 'eth_sendRawTransactionSync' ||
-            request.method === 'multisig_approveRawTransaction' ||
-            request.method === 'multisig_approveRawTransactionSync') {
+            request.method === 'account_approveRawTransaction' ||
+            request.method === 'account_approveRawTransactionSync') {
             if (!isSerializedTempoTransaction(value))
                 return undefined;
             try {
@@ -971,7 +966,7 @@ async function resolveRequestChainId(request, store) {
                 return undefined;
             }
         }
-        if (request.method === 'multisig_approveKeyAuthorization' &&
+        if (request.method === 'account_approveKeyAuthorization' &&
             value &&
             typeof value === 'object' &&
             'keyAuthorization' in value) {
@@ -986,7 +981,7 @@ async function resolveRequestChainId(request, store) {
             if (request.method === 'eth_getTransactionByHash' ||
                 request.method === 'eth_getTransactionReceipt')
                 return value;
-            if (request.method === 'multisig_approveKeyAuthorization' &&
+            if (request.method === 'account_approveKeyAuthorization' &&
                 value &&
                 typeof value === 'object' &&
                 'hash' in value)
@@ -1003,12 +998,12 @@ async function resolveRequestChainId(request, store) {
         return parseChainId(KeyAuthorization.deserialize(operation.keyAuthorization).chainId);
     })();
     if (chainId_body !== undefined &&
-        chainId_multisig !== undefined &&
-        chainId_body !== chainId_multisig)
+        chainId_operation !== undefined &&
+        chainId_body !== chainId_operation)
         throw new RpcResponse.InvalidParamsError({
             message: 'Conflicting chain ids.',
         });
-    return chainId_body ?? chainId_multisig;
+    return chainId_body ?? chainId_operation;
 }
 /** Parses a supported chain ID representation. */
 function parseChainId(value) {
@@ -1036,4 +1031,4 @@ function isSerializedTempoTransaction(value) {
     return (typeof value === 'string' &&
         (value.startsWith('0x76') || value.startsWith('0x78')));
 }
-//# sourceMappingURL=multisig.js.map
+//# sourceMappingURL=accounts.js.map