viem 2.57.4 → 2.57.6

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
+exports.validateConfig = validateConfig;
+exports.selectApprovals = selectApprovals;
 const Address_ = require("ox/Address");
 const Hash = require("ox/Hash");
 const Hex = require("ox/Hex");
@@ -13,9 +15,9 @@ const decodeFunctionData_js_1 = require("../../../utils/abi/decodeFunctionData.j
 const isAddressEqual_js_1 = require("../../../utils/address/isAddressEqual.js");
 const Abis = require("../../Abis.js");
 const Addresses = require("../../Addresses.js");
-const multisig_js_1 = require("../../actions/multisig.js");
-const ConfigStore = require("../../multisig/Config.js");
-const OperationStore = require("../../multisig/Operation.js");
+const ConfigStore = require("../../accounts/Config.js");
+const OperationStore = require("../../accounts/Operation.js");
+const accounts_js_1 = require("../../actions/accounts.js");
 const Transaction = require("../../Transaction.js");
 const Plugin = require("./plugin.js");
 const submissionTtl = 30_000;
@@ -23,9 +25,9 @@ const pollingInterval = 100;
 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({
@@ -44,7 +46,7 @@ function create(options) {
                     request: (request, options) => next(request, { ...requestOptions, ...options }),
                 }, { retryCount: 0 }),
             });
-            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
@@ -53,10 +55,10 @@ 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 (0, getBlockNumber_js_1.getBlockNumber)(client, { cacheTime: 0 });
-                const commitment = await (0, multisig_js_1.getConfigCommitment)(client, {
+                const commitment = await (0, accounts_js_1.getConfigCommitment)(client, {
                     account: address,
                     blockNumber,
                 });
@@ -66,18 +68,18 @@ function create(options) {
                 });
                 if (!config)
                     return null;
-                return tempo_1.MultisigConfig.toRpc(config);
+                return tempo_1.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 ? tempo_1.MultisigOperation.toRpc(operation) : null;
+                return operation ? tempo_1.AccountOperation.toRpc(operation) : null;
             }
-            if (request.method === 'multisig_approveKeyAuthorization')
+            if (request.method === 'account_approveKeyAuthorization')
                 return await approveKeyAuthorization({
                     client,
                     request,
@@ -108,7 +110,7 @@ function create(options) {
                         : operation;
                     return {
                         ...receipt,
-                        multisig: tempo_1.MultisigOperation.toRpc(success),
+                        operation: tempo_1.AccountOperation.toRpc(success),
                     };
                 }
                 if (operation.status === 'pending')
@@ -127,13 +129,13 @@ function create(options) {
                     : operation;
                 return {
                     ...transaction,
-                    multisig: tempo_1.MultisigOperation.toRpc(success),
+                    operation: tempo_1.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';
@@ -142,7 +144,7 @@ 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({
@@ -170,26 +172,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 = tempo_1.TxEnvelopeTempo.from(unsigned);
     const serializedUnsigned = serializeUnsigned(envelope, options.serialized.startsWith(tempo_1.TxEnvelopeTempo.feePayerMagic));
     const blockNumber = await (0, getBlockNumber_js_1.getBlockNumber)(options.client, { cacheTime: 0 });
-    const config = tempo_1.MultisigConfig.from(signature.config);
+    const config = tempo_1.AccountConfig.from(signature.config);
     const configCommitment = await validateConfig({
         account: signature.account,
         blockNumber,
         client: options.client,
         config,
     });
-    const operationHash = tempo_1.MultisigOperation.getHash({
+    const operationHash = tempo_1.AccountOperation.getHash({
         account: signature.account,
         config,
         transaction: serializedUnsigned,
@@ -198,7 +200,7 @@ async function submit(options) {
     const incoming = signature.signatures.map((signature) => tempo_1.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();
@@ -225,7 +227,7 @@ async function submit(options) {
             hash: operationHash,
             approvals: [...(existingApprovals?.approvals ?? []), ...incoming],
         });
-        return tempo_1.MultisigOperation.from({
+        return tempo_1.AccountOperation.from({
             account: signature.account,
             approvals: approvals.approvals,
             config,
@@ -268,7 +270,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) &&
@@ -285,7 +287,7 @@ async function submit(options) {
         if (current.weight < current.threshold)
             return current;
         const now = Date.now();
-        return tempo_1.MultisigOperation.from({
+        return tempo_1.AccountOperation.from({
             ...current,
             expiresAt: Math.min(now + leaseTtl, Number.MAX_SAFE_INTEGER),
             status: 'submitting',
@@ -318,7 +320,7 @@ async function submit(options) {
                 hash: claim.hash,
                 approvals: claim.approvals,
             });
-            const final = tempo_1.MultisigOperation.serializeTransaction(claim, {
+            const final = tempo_1.AccountOperation.serializeTransaction(claim, {
                 approvals: finalApprovals.selectedApprovals,
             });
             const transactionHash = tempo_1.TxEnvelopeTempo.hash(tempo_1.TxEnvelopeTempo.deserialize(final));
@@ -344,7 +346,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) ?? [])],
@@ -392,7 +394,7 @@ async function submit(options) {
             current.submissionId !== submissionId)
             throw new OperationStore.InvalidStoreValueError();
         const { expiresAt: _, submissionId: __, ...operation } = current;
-        return tempo_1.MultisigOperation.from({
+        return tempo_1.AccountOperation.from({
             ...operation,
             status: 'success',
             transactionHash,
@@ -405,14 +407,14 @@ async function submit(options) {
     if (options.method === 'eth_sendRawTransactionSync' &&
         result &&
         typeof result === 'object')
-        return { ...result, multisig: tempo_1.MultisigOperation.toRpc(success) };
+        return { ...result, operation: tempo_1.AccountOperation.toRpc(success) };
     return await submittedResult(options, success);
 }
 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 +424,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 ||
                 !(0, isAddressEqual_js_1.isAddressEqual)(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 = tempo_1.KeyAuthorization.serialize(tempo_1.KeyAuthorization.from(unsigned));
-            const config = tempo_1.MultisigConfig.from(signature.config);
-            const hash = tempo_1.MultisigOperation.getHash({
+            const config = tempo_1.AccountConfig.from(signature.config);
+            const hash = tempo_1.AccountOperation.getHash({
                 account: signature.account,
                 config,
                 keyAuthorization,
@@ -456,12 +458,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 +473,7 @@ async function approveKeyAuthorization(options) {
                 }
                 catch {
                     throw new RpcResponse.InvalidParamsError({
-                        message: 'Invalid multisig owner signature.',
+                        message: 'Invalid owner signature.',
                     });
                 }
             })();
@@ -484,14 +486,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 tempo_1.MultisigOperation.toRpc(approval.operation);
+        return tempo_1.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 (0, getBlockNumber_js_1.getBlockNumber)(options.client, { cacheTime: 0 });
     const commitment = await validateConfig({
@@ -508,8 +510,8 @@ async function approveKeyAuthorization(options) {
             return existing;
         if (existing &&
             (existing.account.toLowerCase() !== approval.account.toLowerCase() ||
-                tempo_1.MultisigConfig.getCommitment(existing.config).toLowerCase() !==
-                    tempo_1.MultisigConfig.getCommitment(approval.config).toLowerCase() ||
+                tempo_1.AccountConfig.getCommitment(existing.config).toLowerCase() !==
+                    tempo_1.AccountConfig.getCommitment(approval.config).toLowerCase() ||
                 existing.keyAuthorization.toLowerCase() !==
                     approval.keyAuthorization.toLowerCase()))
             throw new OperationStore.InvalidStoreValueError();
@@ -548,10 +550,10 @@ async function approveKeyAuthorization(options) {
             weight: approvals.weight,
         };
         if (approvals.weight < approvals.threshold)
-            return tempo_1.MultisigOperation.from({ ...pending, status: 'pending' });
-        return tempo_1.MultisigOperation.from({
+            return tempo_1.AccountOperation.from({ ...pending, status: 'pending' });
+        return tempo_1.AccountOperation.from({
             ...pending,
-            keyAuthorization: tempo_1.MultisigOperation.serializeKeyAuthorization(approval.keyAuthorization, {
+            keyAuthorization: tempo_1.AccountOperation.serializeKeyAuthorization(approval.keyAuthorization, {
                 account: approval.account,
                 approvals: approvals.selectedApprovals,
                 config: approval.config,
@@ -566,7 +568,7 @@ async function approveKeyAuthorization(options) {
     });
     if (operation.type !== 'keyAuthorization')
         throw new OperationStore.InvalidStoreValueError();
-    return tempo_1.MultisigOperation.toRpc(operation);
+    return tempo_1.AccountOperation.toRpc(operation);
 }
 function deserialize(serialized) {
     try {
@@ -581,23 +583,23 @@ function deserialize(serialized) {
 function assertConfig(options) {
     const { account, commitment, config } = options;
     if (config.version === 0n &&
-        tempo_1.MultisigConfig.getAddress(config, {
+        tempo_1.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() !==
-        tempo_1.MultisigConfig.getCommitment(config).toLowerCase())
+        tempo_1.AccountConfig.getCommitment(config).toLowerCase())
         throw new RpcResponse.InvalidParamsError({
-            message: `Multisig config does not match account ${account}.`,
+            message: `Account config does not match account ${account}.`,
         });
 }
 async function validateConfig(options) {
     const { account, blockNumber, client, config } = options;
-    const commitment = await (0, multisig_js_1.getConfigCommitment)(client, {
+    const commitment = await (0, accounts_js_1.getConfigCommitment)(client, {
         account,
         blockNumber,
     });
@@ -624,24 +626,19 @@ async function cacheNextConfigs(options) {
         const [current, threshold, owners] = decoded.args;
         const suppliedConfig = (() => {
             try {
-                return tempo_1.MultisigConfig.from(current);
+                return tempo_1.AccountConfig.from(current);
             }
             catch {
                 return undefined;
             }
         })();
         if (!suppliedConfig ||
-            tempo_1.MultisigConfig.getCommitment(suppliedConfig).toLowerCase() !==
-                tempo_1.MultisigConfig.getCommitment(currentConfig).toLowerCase())
+            tempo_1.AccountConfig.getCommitment(suppliedConfig).toLowerCase() !==
+                tempo_1.AccountConfig.getCommitment(currentConfig).toLowerCase())
             continue;
         const config = (() => {
             try {
-                return tempo_1.MultisigConfig.from({
-                    owners,
-                    salt: suppliedConfig.salt,
-                    threshold,
-                    version: suppliedConfig.version + 1n,
-                });
+                return tempo_1.AccountConfig.update(suppliedConfig, { owners, threshold });
             }
             catch {
                 return undefined;
@@ -651,7 +648,7 @@ async function cacheNextConfigs(options) {
             continue;
         await ConfigStore.write(options.store, {
             address: options.account,
-            commitment: tempo_1.MultisigConfig.getCommitment(config),
+            commitment: tempo_1.AccountConfig.getCommitment(config),
             config,
         });
         currentConfig = config;
@@ -659,20 +656,20 @@ async function cacheNextConfigs(options) {
 }
 async function selectApprovals(options) {
     try {
-        return await tempo_1.MultisigOperation.selectApprovals(options);
+        return await tempo_1.AccountOperation.selectApprovals(options);
     }
     catch (error) {
-        if (error instanceof tempo_1.MultisigOperation.InvalidApprovalError)
+        if (error instanceof tempo_1.AccountOperation.InvalidApprovalError)
             throw new RpcResponse.InvalidParamsError({ message: error.shortMessage });
         throw error;
     }
 }
 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 tempo_1.MultisigOperation.toRpc(operation);
+    if (options.method === 'account_approveRawTransactionSync')
+        return tempo_1.AccountOperation.toRpc(operation);
     const timeout = options.request.params?.[1];
     const deadline = Date.now() +
         (typeof timeout === 'number' && timeout >= 0 ? timeout : submissionTtl);
@@ -682,15 +679,15 @@ async function submittedResult(options, operation) {
             params: [operation.transactionHash],
         }, options.requestOptions);
         if (receipt && typeof receipt === 'object')
-            return { ...receipt, multisig: tempo_1.MultisigOperation.toRpc(operation) };
+            return { ...receipt, operation: tempo_1.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));
     }
 }
 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() +
@@ -710,10 +707,10 @@ async function submittingResult(options, operation) {
 }
 function pendingResult(method, operation) {
     if (method === 'eth_sendRawTransaction' ||
-        method === 'multisig_approveRawTransaction')
+        method === 'account_approveRawTransaction')
         return operation.hash;
-    if (method === 'multisig_approveRawTransactionSync')
-        return tempo_1.MultisigOperation.toRpc(operation);
+    if (method === 'account_approveRawTransactionSync')
+        return tempo_1.AccountOperation.toRpc(operation);
     return {
         blockHash: null,
         blockNumber: null,
@@ -724,7 +721,7 @@ function pendingResult(method, operation) {
         gasUsed: null,
         logs: [],
         logsBloom: null,
-        multisig: tempo_1.MultisigOperation.toRpc(operation),
+        operation: tempo_1.AccountOperation.toRpc(operation),
         status: 'pending',
         to: null,
         transactionHash: operation.hash,
@@ -748,7 +745,7 @@ async function completeSubmission(store, operation, transactionHash) {
             current.submissionId !== operation.submissionId)
             throw new OperationStore.InvalidStoreValueError();
         const { expiresAt: _, submissionId: __, transactionHash: ___, ...value } = current;
-        return tempo_1.MultisigOperation.from({
+        return tempo_1.AccountOperation.from({
             ...value,
             status: 'success',
             transactionHash,
@@ -766,7 +763,7 @@ async function releaseSubmission(store, hash, submissionId) {
             current.submissionId !== submissionId)
             return current;
         const { expiresAt: _, submissionId: __, ...operation } = current;
-        return tempo_1.MultisigOperation.from({
+        return tempo_1.AccountOperation.from({
             ...operation,
             status: 'pending',
             updatedAt: Date.now(),
@@ -796,7 +793,7 @@ function mergeTransaction(existing, incoming) {
 async function toTransaction(client, operation) {
     const approvals = await (async () => {
         if (operation.status !== 'pending')
-            return await tempo_1.MultisigOperation.selectApprovals({
+            return await tempo_1.AccountOperation.selectApprovals({
                 account: operation.account,
                 approvals: operation.approvals,
                 config: operation.config,
@@ -817,7 +814,7 @@ async function toTransaction(client, operation) {
         });
     })();
     const current = operation.status === 'pending'
-        ? tempo_1.MultisigOperation.from({
+        ? tempo_1.AccountOperation.from({
             ...operation,
             approvals: approvals.approvals,
             signatureCount: approvals.signatureCount,
@@ -825,7 +822,7 @@ async function toTransaction(client, operation) {
             weight: approvals.weight,
         })
         : operation;
-    const serialized = tempo_1.MultisigOperation.serializeTransaction(current, {
+    const serialized = tempo_1.AccountOperation.serializeTransaction(current, {
         approvals: approvals.selectedApprovals,
     });
     const transaction = deserialize(serialized);
@@ -838,7 +835,7 @@ async function toTransaction(client, operation) {
             hash: operation.hash,
             transactionIndex: null,
         }, { pending: true }),
-        multisig: tempo_1.MultisigOperation.toRpc(current),
+        operation: tempo_1.AccountOperation.toRpc(current),
     };
 }
 async function getSubmittedTransactionHash(store, operation) {
@@ -863,7 +860,7 @@ function maintainSubmissionLease(store, hash, submissionId, leaseTtl) {
                     if (current.status !== 'submitting' ||
                         current.submissionId !== submissionId)
                         return current;
-                    return tempo_1.MultisigOperation.from({
+                    return tempo_1.AccountOperation.from({
                         ...current,
                         expiresAt: Math.min(Date.now() + leaseTtl, Number.MAX_SAFE_INTEGER),
                         updatedAt: Date.now(),
@@ -903,7 +900,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.');
 }
 async function resolveRequestOptions(options) {
     const { request, requestOptions, store } = options;
@@ -930,11 +927,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 {
@@ -944,7 +941,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) {
@@ -959,7 +956,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)
@@ -976,12 +973,12 @@ async function resolveRequestChainId(request, store) {
         return parseChainId(tempo_1.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;
 }
 function parseChainId(value) {
     const chainId = (() => {
@@ -1007,4 +1004,4 @@ function isSerializedTempoTransaction(value) {
     return (typeof value === 'string' &&
         (value.startsWith('0x76') || value.startsWith('0x78')));
 }
-//# sourceMappingURL=multisig.js.map
+//# sourceMappingURL=accounts.js.map