@metamask-previews/eth-snap-keyring 19.0.0-fd40efd → 20.0.0-5c366be

package/dist/SnapKeyring.mjs

@@ -9,44 +9,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _SnapKeyring_instances, _SnapKeyring_messenger, _SnapKeyring_snapClient, _SnapKeyring_accounts, _SnapKeyring_selectedAccounts, _SnapKeyring_requests, _SnapKeyring_options, _SnapKeyring_callbacks, _SnapKeyring_isAnyAccountTypeAllowed, _SnapKeyring_lock, _SnapKeyring_withLock, _SnapKeyring_isMinimumPlatformVersion, _SnapKeyring_assertAccountCanBeUsed, _SnapKeyring_getExistingAccount, _SnapKeyring_getInternalOptions, _SnapKeyring_handleAccountCreated, _SnapKeyring_handleAccountUpdated, _SnapKeyring_handleAccountDeleted, _SnapKeyring_handleGetSelectedAccounts, _SnapKeyring_handleRequestApproved, _SnapKeyring_handleRequestRejected, _SnapKeyring_rePublishAccountEvent, _SnapKeyring_handleAccountBalancesUpdated, _SnapKeyring_handleAccountAssetListUpdated, _SnapKeyring_handleAccountTransactionsUpdated, _SnapKeyring_getAccount, _SnapKeyring_submitRequest, _SnapKeyring_submitSnapRequest, _SnapKeyring_hasMethod, _SnapKeyring_createRequestPromise, _SnapKeyring_clearRequestPromise, _SnapKeyring_handleSyncResponse, _SnapKeyring_handleAsyncResponse, _SnapKeyring_sanitizeRedirectUrl, _SnapKeyring_validateRedirectUrl, _SnapKeyring_deleteAccount, _SnapKeyring_resolveAddress, _SnapKeyring_updateSelectedAccountsMap, _SnapKeyring_getSnap, _SnapKeyring_getSnapMetadata, _SnapKeyring_getSnapAllowedOrigins, _SnapKeyring_transformToInternalAccount;
-import { TransactionFactory } from "@ethereumjs/tx";
+var _SnapKeyring_instances, _SnapKeyring_messenger, _SnapKeyring_snapKeyrings, _SnapKeyring_accountIndex, _SnapKeyring_callbacks, _SnapKeyring_isAnyAccountTypeAllowed, _SnapKeyring_getOrCreateKeyring, _SnapKeyring_removeSnapKeyringIfEmpty, _SnapKeyring_assertAccountCanBeUsed, _SnapKeyring_getAccount, _SnapKeyring_resolveAddress, _SnapKeyring_getSnap, _SnapKeyring_getSnapMetadata, _SnapKeyring_transformToInternalAccount;
 import { SignTypedDataVersion } from "@metamask/eth-sig-util";
-import { EthBytesStruct, EthMethod, EthBaseUserOperationStruct, EthUserOperationPatchStruct, isEvmAccountType, KeyringEvent, AccountAssetListUpdatedEventStruct, AccountBalancesUpdatedEventStruct, AccountTransactionsUpdatedEventStruct, AnyAccountType } from "@metamask/keyring-api";
-import { toKeyringRequestWithoutOrigin } from "@metamask/keyring-internal-api";
-import { KeyringInternalSnapClient } from "@metamask/keyring-internal-snap-client";
-import { GetSelectedAccountsRequestStruct, SnapManageAccountsMethod } from "@metamask/keyring-snap-sdk";
-import { strictMask } from "@metamask/keyring-utils";
-import { assert, mask, object, string } from "@metamask/superstruct";
-import { bigIntToHex, hasProperty, KnownCaipNamespace, toCaipChainId } from "@metamask/utils";
-import { Mutex } from "async-mutex";
-import { v4 as uuid } from "uuid";
-import { transformAccount } from "./account.mjs";
-import { DeferredPromise } from "./DeferredPromise.mjs";
-import { AccountCreatedEventStruct, AccountUpdatedEventStruct, AccountDeletedEventStruct, RequestApprovedEventStruct, RequestRejectedEventStruct } from "./events.mjs";
-import { projectLogger as log } from "./logger.mjs";
-import { isAccountV1, migrateAccountV1 } from "./migrations/index.mjs";
-import { getInternalOptionsOf } from "./options.mjs";
-import { PLATFORM_VERSION_FOR_KEYRING_REQUEST_WITH_ORIGIN } from "./platform-versions.mjs";
-import { SnapIdMap } from "./SnapIdMap.mjs";
+import { AnyAccountType } from "@metamask/keyring-api";
 import { SNAP_KEYRING_NAME } from "./SnapKeyringMessenger.mjs";
-import { SnapMessageStruct } from "./types.mjs";
-import { equalsIgnoreCase, sanitizeUrl, throwError, toJson, unique } from "./util.mjs";
+import { SnapKeyringV2 } from "./SnapKeyringV2.mjs";
+import { normalizeAccountAddress, throwError, unique } from "./util.mjs";
 export const SNAP_KEYRING_TYPE = 'Snap Keyring';
-/**
- * Normalize account's address.
- *
- * @param account - The account.
- * @returns The normalized account address.
- */
-function normalizeAccountAddress(account) {
-    // FIXME: Is it required to lowercase the address here? For now we'll keep this behavior
-    // only for Ethereum addresses and use the original address for other non-EVM accounts.
-    // For example, Solana addresses are case-sensitives.
-    return isEvmAccountType(account.type)
-        ? account.address.toLowerCase()
-        : account.address;
-}
 /**
  * Keyring bridge implementation to support Snaps.
  */
@@ -70,26 +39,19 @@ export class SnapKeyring {
          */
         _SnapKeyring_messenger.set(this, void 0);
         /**
-         * Client used to call the Snap keyring.
-         */
-        _SnapKeyring_snapClient.set(this, void 0);
-        /**
-         * Mapping between account IDs and an object that contains the associated
-         * account object and Snap ID.
-         */
-        _SnapKeyring_accounts.set(this, void 0);
-        /**
-         * Mapping between Snap IDs and the selected accounts.
-         */
-        _SnapKeyring_selectedAccounts.set(this, void 0);
-        /**
-         * Mapping between request IDs and their deferred promises.
+         * Per-snap keyring instances. Each `SnapKeyringV2` (which extends
+         * `SnapKeyringV1`) owns a single `KeyringAccountRegistry` and handles
+         * both the event-driven v1 flow and the `KeyringV2` batch interface.
          */
-        _SnapKeyring_requests.set(this, void 0);
+        _SnapKeyring_snapKeyrings.set(this, void 0);
         /**
-         * Mapping between internal options, a correlation ID and a Snap ID.
+         * Reverse index from account ID to the owning Snap ID.
+         *
+         * Populated and kept in sync via the `onRegister` / `onUnregister`
+         * callbacks injected into each entry. Enables O(1) routing for
+         * any "which snap owns this account?" query.
          */
-        _SnapKeyring_options.set(this, void 0);
+        _SnapKeyring_accountIndex.set(this, void 0);
         /**
          * Callbacks used to interact with other components.
          */
@@ -100,77 +62,49 @@ export class SnapKeyring {
          * Account deletion is not affected by this flag and is always allowed.
          */
         _SnapKeyring_isAnyAccountTypeAllowed.set(this, void 0);
-        /**
-         * Mutex to ensure exclusive access to the inner keyring during
-         * operations that mutate its state.
-         */
-        _SnapKeyring_lock.set(this, void 0);
         this.type = SnapKeyring.type;
         __classPrivateFieldSet(this, _SnapKeyring_messenger, messenger, "f");
-        __classPrivateFieldSet(this, _SnapKeyring_snapClient, new KeyringInternalSnapClient({ messenger }), "f");
-        __classPrivateFieldSet(this, _SnapKeyring_requests, new SnapIdMap(), "f");
-        __classPrivateFieldSet(this, _SnapKeyring_accounts, new SnapIdMap(), "f");
-        __classPrivateFieldSet(this, _SnapKeyring_options, new SnapIdMap(), "f");
+        __classPrivateFieldSet(this, _SnapKeyring_snapKeyrings, new Map(), "f");
+        __classPrivateFieldSet(this, _SnapKeyring_accountIndex, new Map(), "f");
         __classPrivateFieldSet(this, _SnapKeyring_callbacks, callbacks, "f");
         __classPrivateFieldSet(this, _SnapKeyring_isAnyAccountTypeAllowed, isAnyAccountTypeAllowed, "f");
-        __classPrivateFieldSet(this, _SnapKeyring_selectedAccounts, new Map(), "f");
-        __classPrivateFieldSet(this, _SnapKeyring_lock, new Mutex(), "f");
     }
     /**
      * Handle a message from a Snap.
      *
+     * Delegates to the per-snap SnapKeyringV1 handler.
+     *
      * @param snapId - ID of the Snap.
      * @param message - Message sent by the Snap.
      * @returns The execution result.
      */
     async handleKeyringSnapMessage(snapId, message) {
-        assert(message, SnapMessageStruct);
-        switch (message.method) {
-            case `${KeyringEvent.AccountCreated}`: {
-                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleAccountCreated).call(this, snapId, message);
-            }
-            case `${KeyringEvent.AccountUpdated}`: {
-                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleAccountUpdated).call(this, snapId, message);
-            }
-            case `${KeyringEvent.AccountDeleted}`: {
-                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleAccountDeleted).call(this, snapId, message);
-            }
-            case `${KeyringEvent.RequestApproved}`: {
-                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleRequestApproved).call(this, snapId, message);
-            }
-            case `${KeyringEvent.RequestRejected}`: {
-                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleRequestRejected).call(this, snapId, message);
-            }
-            // Assets related events:
-            case `${KeyringEvent.AccountBalancesUpdated}`: {
-                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleAccountBalancesUpdated).call(this, snapId, message);
-            }
-            case `${KeyringEvent.AccountAssetListUpdated}`: {
-                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleAccountAssetListUpdated).call(this, snapId, message);
-            }
-            case `${KeyringEvent.AccountTransactionsUpdated}`: {
-                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleAccountTransactionsUpdated).call(this, snapId, message);
-            }
-            case `${SnapManageAccountsMethod.GetSelectedAccounts}`: {
-                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleGetSelectedAccounts).call(this, snapId, message);
-            }
-            default:
-                throw new Error(`Method not supported: ${message.method}`);
-        }
+        return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getOrCreateKeyring).call(this, snapId).handleKeyringSnapMessage(message);
     }
     /**
      * Serialize the keyring state.
      *
+     * Delegates to each per-snap v2 keyring and flattens back into the original
+     * external format so that `KeyringController` sees no change.
+     *
      * @returns Serialized keyring state.
      */
     async serialize() {
-        return {
-            accounts: __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").toObject(),
-        };
+        const accounts = {};
+        for (const keyring of __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").values()) {
+            for (const account of keyring.accounts()) {
+                accounts[account.id] = { account, snapId: keyring.snapId };
+            }
+        }
+        return { accounts };
     }
     /**
      * Deserialize the keyring state into this keyring.
      *
+     * Groups the flat persisted state by `snapId`, clears both indexes, then
+     * rebuilds each per-snap entry. The `onRegister` callbacks fired during
+     * `v2.deserialize()` automatically repopulate `#accountIndex`.
+     *
      * @param state - Serialized keyring state.
      */
     async deserialize(state) {
@@ -179,26 +113,25 @@ export class SnapKeyring {
         if (state === undefined) {
             return;
         }
-        // Running Snap keyring migrations. We might have some accounts that have a
-        // different "version" than the one we expect.
-        //
-        // In this case, we "transform" then directly when deserializing to convert
-        // them in the final account version.
-        const accounts = {};
-        for (const [snapId, entry] of Object.entries(state.accounts)) {
-            // V1 accounts are missing the scopes.
-            if (isAccountV1(entry.account)) {
-                console.info(`SnapKeyring - Found a KeyringAccountV1, migrating to V2: ${entry.account.id}`);
-                accounts[snapId] = {
-                    ...entry,
-                    account: migrateAccountV1(entry.account),
-                };
-            }
-            else {
-                accounts[snapId] = entry;
-            }
+        // Group flat state by snapId. Migrations and migration logging are handled
+        // inside v2.deserialize().
+        const bySnap = new Map();
+        for (const entry of Object.values(state.accounts)) {
+            const snapAccounts = bySnap.get(entry.snapId) ?? {};
+            snapAccounts[entry.account.id] = entry.account;
+            bySnap.set(entry.snapId, snapAccounts);
+        }
+        // Clear both indexes before rebuilding — they must always be consistent.
+        __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").clear();
+        __classPrivateFieldGet(this, _SnapKeyring_accountIndex, "f").clear();
+        // Rebuild per-snap keyrings. Each keyrings handles its own validation
+        // and migration internally.
+        for (const [snapId, accounts] of bySnap) {
+            const keyring = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getOrCreateKeyring).call(this, snapId);
+            await keyring.deserialize({ snapId, accounts });
+            // onRegister callbacks fired above have repopulated #accountIndex.
+            __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_removeSnapKeyringIfEmpty).call(this, snapId);
         }
-        __classPrivateFieldSet(this, _SnapKeyring_accounts, SnapIdMap.fromObject(accounts), "f");
     }
     /**
      * Get the addresses of the accounts in this keyring.
@@ -206,7 +139,13 @@ export class SnapKeyring {
      * @returns The addresses of the accounts in this keyring.
      */
     async getAccounts() {
-        return unique([...__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").values()].map(({ account }) => normalizeAccountAddress(account)));
+        const addresses = [];
+        for (const keyring of __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").values()) {
+            for (const account of keyring.accounts()) {
+                addresses.push(normalizeAccountAddress(account));
+            }
+        }
+        return unique(addresses);
     }
     /**
      * Get the addresses of the accounts associated with a given Snap.
@@ -215,12 +154,12 @@ export class SnapKeyring {
      * @returns The addresses of the accounts associated with the given Snap.
      */
     async getAccountsBySnapId(snapId) {
-        return unique([...__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").values()]
-            .filter(({ snapId: accountSnapId }) => accountSnapId === snapId)
-            .map(({ account }) => normalizeAccountAddress(account)));
+        return unique((__classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId)?.accounts() ?? []).map(normalizeAccountAddress));
     }
     /**
-     * Create an account.
+     * Create an account (v1 event-driven flow).
+     *
+     * Delegates to the per-snap SnapKeyringV1 instance.
      *
      * @param snapId - Snap ID to create the account for.
      * @param options - Account creation options. Differs between keyrings.
@@ -228,119 +167,20 @@ export class SnapKeyring {
      * @returns The account object.
      */
     async createAccount(snapId, options, internalOptions) {
-        const client = new KeyringInternalSnapClient({
-            messenger: __classPrivateFieldGet(this, _SnapKeyring_messenger, "f"),
-            snapId,
-        });
-        // The 'metamask' field is reserved, so we have to prevent use of it on
-        // the "normal options".
-        const reserved = 'metamask';
-        if (hasProperty(options, reserved)) {
-            throw new Error(`The '${reserved}' property is reserved for internal use`);
-        }
-        // Those internal options are optional. If not set, we avoid registering anything
-        // to internal map (to avoid holding resources for nothing). In this case, it's
-        // just a normal `keyring_createAccount`.
-        if (!internalOptions) {
-            return await client.createAccount(options);
-        }
-        // A unique ID to identify this execution flow which allows to associate the
-        // internal options and the current `keyring_createAccount` flow for that Snap.
-        const correlationId = uuid();
-        // Register those internal options to use them during the `keyring_createAccount`
-        // flow.
-        __classPrivateFieldGet(this, _SnapKeyring_options, "f").set(correlationId, {
-            snapId,
-            options: internalOptions,
-        });
-        return await client.createAccount({
-            ...options,
-            // Create internal options context.
-            // NOTE: Those options HAVE TO be re-emitted during the `notify:accountCreated` event.
-            ...{
-                metamask: {
-                    correlationId,
-                },
-            },
-        });
+        return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getOrCreateKeyring).call(this, snapId).createAccount(options, internalOptions);
     }
     /**
      * Creates one or more new accounts according to the provided options.
      *
-     * Deterministic account creation MUST be idempotent, meaning that for
-     * deterministic algorithms, like BIP-44, calling this method with the same
-     * options should always return the same accounts, even if the accounts
-     * already exist in the keyring.
-     *
-     * NOTE: If some accounts are not allowed (non-unique address, unsupported
-     * generic account), this method will skip their creation and ask the Snap
-     * to remove them from its state.
+     * Delegates to the per-snap SnapKeyringV2 instance which handles
+     * idempotency, validation, batch tracking, state persistence, and rollback.
      *
      * @param snapId - Snap ID to create the account(s) for.
      * @param options - Options describing how to create the account(s).
      * @returns An array of the created account objects.
      */
     async createAccounts(snapId, options) {
-        return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_withLock).call(this, async () => {
-            const client = new KeyringInternalSnapClient({
-                messenger: __classPrivateFieldGet(this, _SnapKeyring_messenger, "f"),
-                snapId,
-            });
-            // Keep track of address/account ID part of this batch, to avoid having duplicates.
-            const accountAddresses = new Set();
-            const accountIds = new Set();
-            const accounts = [];
-            const newAccounts = [];
-            const snapAccounts = await client.createAccounts(options);
-            try {
-                for (const snapAccount of snapAccounts) {
-                    let account = transformAccount(snapAccount);
-                    const address = normalizeAccountAddress(account);
-                    // Check for idempotency.
-                    const existingAccount = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getExistingAccount).call(this, snapId, account);
-                    if (existingAccount) {
-                        // NOTE: We re-use the account from the internal state to avoid having the Snap
-                        // mutating the account object without updating the map.
-                        account = existingAccount;
-                    }
-                    else {
-                        await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_assertAccountCanBeUsed).call(this, snapId, account);
-                        // Also check for transient accounts that are not yet part of the keyring
-                        // state.
-                        if (accountAddresses.has(address) || accountIds.has(account.id)) {
-                            throw new Error(`Account '${account.id}' is already part of this batch (same address or account ID)`);
-                        }
-                        accountAddresses.add(address);
-                        accountIds.add(account.id);
-                        // NOTE: This method does not rely on the `AccountCreated` event to add
-                        // accounts to the keyring, so we have to add them to the state manually.
-                        newAccounts.push(account);
-                    }
-                    // New AND existing accounts are returned to the caller no matter what.
-                    accounts.push(account);
-                }
-                // We update the keyring state only if needed.
-                if (newAccounts.length > 0) {
-                    for (const account of newAccounts) {
-                        __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").set(account.id, { account, snapId });
-                    }
-                    // NOTE: We assume this will never fail, thus, we don't need to rollback the
-                    // keyring state if anything goes wrong here.
-                    await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").saveState();
-                }
-                return accounts;
-            }
-            catch (error) {
-                // Rollback Snap state.
-                for (const account of snapAccounts) {
-                    // Make sure to only delete accounts that were not part of the keyring state.
-                    if (!__classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getExistingAccount).call(this, snapId, account)) {
-                        await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_deleteAccount).call(this, snapId, account);
-                    }
-                }
-                throw error;
-            }
-        });
+        return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getOrCreateKeyring).call(this, snapId).createAccounts(options);
     }
     /**
      * Checks if a Snap ID is known from the keyring.
@@ -349,7 +189,8 @@ export class SnapKeyring {
      * @returns `true` if the Snap ID is known, `false` otherwise.
      */
     hasSnapId(snapId) {
-        return __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").hasSnapId(snapId);
+        const keyring = __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId);
+        return keyring !== undefined && keyring.accounts().length > 0;
     }
     /**
      * Resolve the Snap account's address associated from a signing request.
@@ -365,9 +206,7 @@ export class SnapKeyring {
         if (!this.hasSnapId(snapId)) {
             throw new Error(`Unable to resolve account address: unknown Snap ID: ${snapId}`);
         }
-        return await __classPrivateFieldGet(this, _SnapKeyring_snapClient, "f")
-            .withSnapId(snapId)
-            .resolveAccountAddress(scope, request);
+        return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getOrCreateKeyring).call(this, snapId).resolveAccountAddress(scope, request);
     }
     /**
      * Submit a request to a Snap from an account ID.
@@ -384,9 +223,11 @@ export class SnapKeyring {
      */
     async submitRequest({ origin, account: accountId, method, params, scope, }) {
         const { account, snapId } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getAccount).call(this, accountId);
-        return await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitSnapRequest).call(this, {
+        /* istanbul ignore next */
+        const keyring = __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId) ??
+            throwError(`No keyring found for snap '${snapId}'`);
+        return await keyring.submitSnapRequest({
             origin,
-            snapId,
             account,
             method: method,
             params,
@@ -405,33 +246,8 @@ export class SnapKeyring {
      * @returns A promise that resolves to the signed transaction.
      */
     async signTransaction(address, transaction, _opts = {}) {
-        const chainId = transaction.common.chainId();
-        const tx = toJson({
-            ...transaction.toJSON(),
-            from: address,
-            type: `0x${transaction.type.toString(16)}`,
-            chainId: bigIntToHex(chainId),
-        });
-        const signedTx = await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitRequest).call(this, {
-            origin: 'metamask',
-            address,
-            method: EthMethod.SignTransaction,
-            params: [tx],
-            scope: toCaipChainId(KnownCaipNamespace.Eip155, `${chainId}`),
-        });
-        // ! It's *** CRITICAL *** that we mask the signature here, otherwise the
-        // ! Snap could overwrite the transaction.
-        const signature = mask(signedTx, object({
-            r: string(),
-            s: string(),
-            v: string(),
-        }));
-        return TransactionFactory.fromTxData({
-            ...tx,
-            r: signature.r,
-            s: signature.s,
-            v: signature.v,
-        });
+        const { account, keyring } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
+        return keyring.signTransaction(account, transaction, _opts);
     }
     /**
      * Sign a typed data message.
@@ -442,28 +258,8 @@ export class SnapKeyring {
      * @returns The signature.
      */
     async signTypedData(address, data, opts = { version: SignTypedDataVersion.V1 }) {
-        const methods = {
-            [SignTypedDataVersion.V1]: EthMethod.SignTypedDataV1,
-            [SignTypedDataVersion.V3]: EthMethod.SignTypedDataV3,
-            [SignTypedDataVersion.V4]: EthMethod.SignTypedDataV4,
-        };
-        // Use 'V1' by default to match other keyring implementations. V1 will be
-        // used if the version is not specified or not supported.
-        const method = methods[opts.version] || EthMethod.SignTypedDataV1;
-        // Extract chain ID as if it was a typed message (as defined by EIP-712), if
-        // input is not a typed message, then chain ID will be undefined!
-        const chainId = data.domain?.chainId;
-        return strictMask(await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitRequest).call(this, {
-            origin: 'metamask',
-            address,
-            method,
-            params: toJson([address, data]),
-            ...(chainId === undefined
-                ? {}
-                : {
-                    scope: toCaipChainId(KnownCaipNamespace.Eip155, `${chainId}`),
-                }),
-        }), EthBytesStruct);
+        const { account, keyring } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
+        return keyring.signTypedData(account, data, opts);
     }
     /**
      * Sign a message.
@@ -473,12 +269,8 @@ export class SnapKeyring {
      * @returns The signature.
      */
     async signMessage(address, hash) {
-        return strictMask(await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitRequest).call(this, {
-            origin: 'metamask',
-            address,
-            method: EthMethod.Sign,
-            params: toJson([address, hash]),
-        }), EthBytesStruct);
+        const { account, keyring } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
+        return keyring.signMessage(account, hash);
     }
     /**
      * Sign a personal message.
@@ -491,12 +283,8 @@ export class SnapKeyring {
      * @returns Promise of the signature.
      */
     async signPersonalMessage(address, data) {
-        return strictMask(await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitRequest).call(this, {
-            origin: 'metamask',
-            address,
-            method: EthMethod.PersonalSign,
-            params: toJson([data, address]),
-        }), EthBytesStruct);
+        const { account, keyring } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
+        return keyring.signPersonalMessage(account, data);
     }
     /**
      * Convert a base transaction to a base UserOperation.
@@ -507,15 +295,8 @@ export class SnapKeyring {
      * @returns A pseudo-UserOperation that can be used to construct a real.
      */
     async prepareUserOperation(address, transactions, context) {
-        return strictMask(await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitRequest).call(this, {
-            origin: 'metamask',
-            address,
-            method: EthMethod.PrepareUserOperation,
-            params: toJson(transactions),
-            noPending: true,
-            // We assume the chain ID is already well formatted
-            scope: toCaipChainId(KnownCaipNamespace.Eip155, context.chainId),
-        }), EthBaseUserOperationStruct);
+        const { account, keyring } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
+        return keyring.prepareUserOperation(account, transactions, context);
     }
     /**
      * Patches properties of a UserOperation. Currently, only the
@@ -527,33 +308,20 @@ export class SnapKeyring {
      * @returns A patch to apply to the UserOperation.
      */
     async patchUserOperation(address, userOp, context) {
-        return strictMask(await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitRequest).call(this, {
-            origin: 'metamask',
-            address,
-            method: EthMethod.PatchUserOperation,
-            params: toJson([userOp]),
-            noPending: true,
-            // We assume the chain ID is already well formatted
-            scope: toCaipChainId(KnownCaipNamespace.Eip155, context.chainId),
-        }), EthUserOperationPatchStruct);
+        const { account, keyring } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
+        return keyring.patchUserOperation(account, userOp, context);
     }
     /**
-     * Signs an UserOperation.
+     * Signs a UserOperation.
      *
      * @param address - Address of the sender.
      * @param userOp - UserOperation to sign.
-     * @param context - Leyring execution context.
+     * @param context - Keyring execution context.
      * @returns The signature of the UserOperation.
      */
     async signUserOperation(address, userOp, context) {
-        return strictMask(await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitRequest).call(this, {
-            origin: 'metamask',
-            address,
-            method: EthMethod.SignUserOperation,
-            params: toJson([userOp]),
-            // We assume the chain ID is already well formatted
-            scope: toCaipChainId(KnownCaipNamespace.Eip155, context.chainId),
-        }), EthBytesStruct);
+        const { account, keyring } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
+        return keyring.signUserOperation(account, userOp, context);
     }
     /**
      * Gets the private data associated with the given address so
@@ -572,30 +340,39 @@ export class SnapKeyring {
     /**
      * Removes the account matching the given address.
      *
+     * Delegates to the per-snap SnapKeyringV2 keyring which handles
+     * registry removal, index cleanup, and snap communication.
+     *
      * @param address - Address of the account to remove.
      */
     async removeAccount(address) {
-        const { account, snapId } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
-        await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_deleteAccount).call(this, snapId, account);
+        const { account, keyring } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
+        await keyring.deleteAccount(account.id);
+        __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_removeSnapKeyringIfEmpty).call(this, keyring.snapId);
     }
     /**
      * Set the selected accounts.
      *
+     * Distributes the global list by snap and forwards to each v1 instance.
+     *
      * @param accounts - The accounts to set as selected.
      */
     async setSelectedAccounts(accounts) {
-        __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_updateSelectedAccountsMap).call(this, accounts);
-        const entries = [...__classPrivateFieldGet(this, _SnapKeyring_selectedAccounts, "f").entries()];
-        await Promise.all(entries.map(async ([snapId, accountIds]) => {
-            try {
-                await __classPrivateFieldGet(this, _SnapKeyring_snapClient, "f")
-                    .withSnapId(snapId)
-                    .setSelectedAccounts(accountIds);
+        // Build per-snap distribution using the account index.
+        const bySnap = new Map();
+        for (const accountId of accounts) {
+            const snapId = __classPrivateFieldGet(this, _SnapKeyring_accountIndex, "f").get(accountId);
+            if (!snapId) {
+                continue;
             }
-            catch (error) {
-                console.error(`Failed to set selected accounts for ${snapId} snap: '${error.message}'`);
-            }
-        }));
+            const snapAccounts = bySnap.get(snapId) ?? [];
+            snapAccounts.push(accountId);
+            bySnap.set(snapId, snapAccounts);
+        }
+        await Promise.all([...__classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").entries()].map(async ([snapId, keyring]) => keyring.setSelectedAccounts(
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        /* istanbul ignore next */
+        bySnap.get(snapId) ?? [])));
     }
     /**
      * Return an internal account object for a given address.
@@ -604,11 +381,13 @@ export class SnapKeyring {
      * @returns An internal account object for the given address.
      */
     getAccountByAddress(address) {
-        const accounts = [...__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").values()];
-        const account = accounts.find(({ account: { address: accountAddress } }) => equalsIgnoreCase(accountAddress, address));
-        return account
-            ? __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_transformToInternalAccount).call(this, account.account, account.snapId)
-            : undefined;
+        for (const [snapId, keyring] of __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f")) {
+            const account = keyring.lookupByAddress(address);
+            if (account) {
+                return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_transformToInternalAccount).call(this, account, snapId);
+            }
+        }
+        return undefined;
     }
     /**
      * List all Snap keyring accounts.
@@ -618,30 +397,53 @@ export class SnapKeyring {
      * @returns An array containing all Snap keyring accounts.
      */
     listAccounts() {
-        return [...__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").values()].map(({ account, snapId }) => __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_transformToInternalAccount).call(this, account, snapId));
+        const accounts = [];
+        for (const [snapId, keyring] of __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f")) {
+            for (const account of keyring.accounts()) {
+                accounts.push(__classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_transformToInternalAccount).call(this, account, snapId));
+            }
+        }
+        return accounts;
     }
 }
-_SnapKeyring_messenger = new WeakMap(), _SnapKeyring_snapClient = new WeakMap(), _SnapKeyring_accounts = new WeakMap(), _SnapKeyring_selectedAccounts = new WeakMap(), _SnapKeyring_requests = new WeakMap(), _SnapKeyring_options = new WeakMap(), _SnapKeyring_callbacks = new WeakMap(), _SnapKeyring_isAnyAccountTypeAllowed = new WeakMap(), _SnapKeyring_lock = new WeakMap(), _SnapKeyring_instances = new WeakSet(), _SnapKeyring_withLock = 
-/**
- * Execute an operation behind a lock.
- *
- * @param callback - A function that performs the operation.
- * @returns The result of the callback.
- */
-async function _SnapKeyring_withLock(callback) {
-    return __classPrivateFieldGet(this, _SnapKeyring_lock, "f").runExclusive(callback);
-}, _SnapKeyring_isMinimumPlatformVersion = function _SnapKeyring_isMinimumPlatformVersion(snapId, platformVersion) {
-    return __classPrivateFieldGet(this, _SnapKeyring_messenger, "f").call('SnapController:isMinimumPlatformVersion', snapId, platformVersion);
+_SnapKeyring_messenger = new WeakMap(), _SnapKeyring_snapKeyrings = new WeakMap(), _SnapKeyring_accountIndex = new WeakMap(), _SnapKeyring_callbacks = new WeakMap(), _SnapKeyring_isAnyAccountTypeAllowed = new WeakMap(), _SnapKeyring_instances = new WeakSet(), _SnapKeyring_getOrCreateKeyring = function _SnapKeyring_getOrCreateKeyring(snapId) {
+    let keyring = __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId);
+    if (!keyring) {
+        keyring = new SnapKeyringV2({
+            snapId,
+            messenger: __classPrivateFieldGet(this, _SnapKeyring_messenger, "f"),
+            isAnyAccountTypeAllowed: __classPrivateFieldGet(this, _SnapKeyring_isAnyAccountTypeAllowed, "f"),
+            callbacks: {
+                onRegister: (id) => {
+                    __classPrivateFieldGet(this, _SnapKeyring_accountIndex, "f").set(id, snapId);
+                },
+                onUnregister: (id) => {
+                    __classPrivateFieldGet(this, _SnapKeyring_accountIndex, "f").delete(id);
+                },
+                addAccount: async (address, handleUserInput, onceSaved, accountNameSuggestion, internalOptions) => __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").addAccount(address, snapId, handleUserInput, onceSaved, accountNameSuggestion, internalOptions),
+                removeAccount: async (address, handleUserInput) => __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").removeAccount(address, snapId, handleUserInput),
+                saveState: async () => __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").saveState(),
+                redirectUser: async (url, message) => __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").redirectUser(snapId, url, message),
+                assertAccountCanBeUsed: async (account) => __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_assertAccountCanBeUsed).call(this, account),
+            },
+        });
+        __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").set(snapId, keyring);
+    }
+    return keyring;
+}, _SnapKeyring_removeSnapKeyringIfEmpty = function _SnapKeyring_removeSnapKeyringIfEmpty(snapId) {
+    const keyring = __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId);
+    if (keyring !== undefined && keyring.accounts().length === 0) {
+        __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").delete(snapId);
+    }
 }, _SnapKeyring_assertAccountCanBeUsed = 
 /**
  * Asserts that an account can be used within the Snap keyring. (e.g. generic accounts, unique
  * addresses, etc...).
  *
- * @param snapId - The account's Snap ID.
  * @param account - The account to check.
  * @throws If the account cannot be used.
  */
-async function _SnapKeyring_assertAccountCanBeUsed(snapId, account) {
+async function _SnapKeyring_assertAccountCanBeUsed(account) {
     const address = normalizeAccountAddress(account);
     // The `AnyAccountType.Account` generic account type is allowed only during
     // development, so we check whether it's allowed before continuing.
@@ -651,7 +453,8 @@ async function _SnapKeyring_assertAccountCanBeUsed(snapId, account) {
     }
     // A Snap could try to create an account with a different address but with
     // an existing ID, so the above test only is not enough.
-    if (__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").has(snapId, account.id)) {
+    // Account IDs are globally unique across all snaps.
+    if (__classPrivateFieldGet(this, _SnapKeyring_accountIndex, "f").has(account.id)) {
         throw new Error(`Account '${account.id}' already exists`);
     }
     // The UI still uses the account address to identify accounts, so we need
@@ -660,490 +463,30 @@ async function _SnapKeyring_assertAccountCanBeUsed(snapId, account) {
     if (await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").addressExists(address)) {
         throw new Error(`Account address '${address}' already exists`);
     }
-}, _SnapKeyring_getExistingAccount = function _SnapKeyring_getExistingAccount(snapId, account) {
-    const address = normalizeAccountAddress(account);
-    // Acount creation is idempotent, so we need to check whether the account already exists
-    // and that the right Snap is trying to "create" it again.
-    // NOTE: We are not checking account object equality here. If a Snap
-    // re-send this event with different account data, we will ignore it.
-    const accountEntry = __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").get(snapId, account.id);
-    if (accountEntry !== undefined &&
-        normalizeAccountAddress(accountEntry.account) === address) {
-        return accountEntry.account;
-    }
-    return undefined; // Not a known account.
-}, _SnapKeyring_getInternalOptions = function _SnapKeyring_getInternalOptions(snapId, correlationId) {
-    if (correlationId) {
-        // We still need to check if the correlation ID is valid and associated to
-        // some internal options.
-        //
-        // NOTE: `found` will be `undefined` if a Snap tried to use a correlation ID that
-        // belongs to another Snap ID. However, if a Snap starts 2 parallel flow (which
-        // will results in 2 different correlation IDs), we won't be able to prevent
-        // the Snap from swapping/mixing up those correlation IDs he owns.
-        const found = __classPrivateFieldGet(this, _SnapKeyring_options, "f").pop(snapId, correlationId);
-        if (found) {
-            return found.options;
-        }
-        console.warn(`SnapKeyring - Received unmapped correlation ID: "${correlationId}"`);
-    }
-    return undefined;
-}, _SnapKeyring_handleAccountCreated = 
-/**
- * Handle an Account Created event from a Snap.
- *
- * @param snapId - Snap ID.
- * @param message - Event message.
- * @returns `null`.
- */
-async function _SnapKeyring_handleAccountCreated(snapId, message) {
-    assert(message, AccountCreatedEventStruct);
-    const { metamask, // Used for internal options.
-    account: newAccountFromEvent, accountNameSuggestion, displayAccountNameSuggestion, displayConfirmation, } = message.params;
-    // READ THIS CAREFULLY:
-    // ------------------------------------------------------------------------
-    // The account creation flow is now asynchronous. We expect the Snap to
-    // first create the account data and then fire the "AccountCreated" event.
-    // Potentially migrate the account.
-    const account = transformAccount(newAccountFromEvent);
-    const address = normalizeAccountAddress(account);
-    if (__classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getExistingAccount).call(this, snapId, account)) {
-        // If the account already exists, we skip it.
-        return null;
-    }
-    // Make sure this new account is valid.
-    await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_assertAccountCanBeUsed).call(this, snapId, account);
-    // A deferred promise that will be resolved once the Snap keyring has saved
-    // its internal state.
-    // This part of the flow is run asynchronously, so we have no other way of
-    // letting the MetaMask client that this "save" has been run.
-    // NOTE: Another way of fixing that could be to rely on events through the
-    // messenger maybe?
-    const onceSaved = new DeferredPromise();
-    // Add the account to the keyring, but wait for the MetaMask client to
-    // approve the account creation first.
-    await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").addAccount(address, snapId, 
-    // This callback is passed to the MetaMask client, it will be called whenever
-    // the end user will accept or not the account creation.
-    async (accepted) => {
-        if (accepted) {
-            // We consider the account to be created on the Snap keyring only if
-            // the user accepted it. Meaning that the Snap MIGHT HAVE created the
-            // account on its own state, but the Snap keyring MIGHT NOT HAVE it yet.
-            //
-            // e.g The account creation dialog crashed on MetaMask, this callback
-            // will never be called, but the Snap still has the account.
-            __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").set(account.id, { account, snapId });
-            // This is the "true async part". We do not `await` for this call, mainly
-            // because this callback will persist the account on the client side
-            // (through the `AccountsController`).
-            //
-            // Since this will happen after the Snap account creation and Snap
-            // event, if anything goes wrong, we will delete the account by
-            // calling `deleteAccount` on the Snap.
-            // eslint-disable-next-line no-void
-            void __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f")
-                .saveState()
-                .then(() => {
-                // This allows the MetaMask client to be "notified" when then
-                // Snap keyring has truly persisted its state. From there, we should
-                // be able to use the account (e.g. to display account creation
-                // confirmation dialogs).
-                onceSaved.resolve(account.id);
-            })
-                .catch(async (error) => {
-                // FIXME: There's a potential race condition here, if the Snap did
-                // not persist the account yet (this should mostly be for older Snaps).
-                await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_deleteAccount).call(this, snapId, account);
-                // This allows the MetaMask client to be "notified" that something went
-                // wrong with the Snap keyring. (e.g. useful to display account creation
-                // error dialogs).
-                onceSaved.reject(error);
-            });
-        }
-    }, onceSaved.promise, accountNameSuggestion, getInternalOptionsOf([
-        // 1. We use the internal options from the Snap keyring.
-        __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getInternalOptions).call(this, snapId, metamask?.correlationId) ?? {},
-        // 2. We use the ones coming from the Snap.
-        {
-            displayConfirmation,
-            displayAccountNameSuggestion,
-        },
-    ]));
-    return null;
-}, _SnapKeyring_handleAccountUpdated = 
-/**
- * Handle an Account Updated event from a Snap.
- *
- * @param snapId - Snap ID.
- * @param message - Event message.
- * @returns `null`.
- */
-async function _SnapKeyring_handleAccountUpdated(snapId, message) {
-    assert(message, AccountUpdatedEventStruct);
-    const { account: newAccountFromEvent } = message.params;
-    const { account: oldAccount } = __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").get(snapId, newAccountFromEvent.id) ??
-        throwError(`Account '${newAccountFromEvent.id}' not found`);
-    // Potentially migrate the account.
-    const newAccount = transformAccount(newAccountFromEvent);
-    // The `AnyAccountType.Account` generic account type is allowed only during
-    // development, so we check whether it's allowed before continuing.
-    //
-    // An account cannot be updated if the `isAnyAccountTypeAllowed` flag is
-    // set to `false` and the new or old account is a generic account.
-    const isGenericAccountInvolved = newAccount.type === AnyAccountType.Account ||
-        oldAccount.type === AnyAccountType.Account;
-    if (!__classPrivateFieldGet(this, _SnapKeyring_isAnyAccountTypeAllowed, "f") && isGenericAccountInvolved) {
-        throw new Error(`Cannot update generic account '${newAccount.id}'`);
-    }
-    // The address of the account cannot be changed. In the future, we will
-    // support changing the address of an account since it will be required to
-    // support UTXO-based chains.
-    if (!equalsIgnoreCase(oldAccount.address, newAccount.address)) {
-        throw new Error(`Cannot change address of account '${newAccount.id}'`);
-    }
-    __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").set(newAccount.id, { account: newAccount, snapId });
-    await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").saveState();
-    return null;
-}, _SnapKeyring_handleAccountDeleted = 
-/**
- * Handle an Account Deleted event from a Snap.
- *
- * @param snapId - Snap ID.
- * @param message - Event message.
- * @returns `null`.
- */
-async function _SnapKeyring_handleAccountDeleted(snapId, message) {
-    assert(message, AccountDeletedEventStruct);
-    const { id } = message.params;
-    const entry = __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").get(snapId, id);
-    // We can ignore the case where the account was already removed from the
-    // keyring, making the deletion idempotent.
-    //
-    // This happens when the keyring calls the Snap to delete an account, and
-    // the Snap calls the keyring back with an `AccountDeleted` event.
-    if (entry === undefined) {
-        return null;
-    }
-    // At this point we know that the account exists, so we can safely
-    // destructure it.
-    const { account } = entry;
-    await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").removeAccount(normalizeAccountAddress(account), snapId, async (accepted) => {
-        if (accepted) {
-            await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").saveState();
-        }
-    });
-    return null;
-}, _SnapKeyring_handleGetSelectedAccounts = 
-/**
- * Handle a Get Selected Accounts method call from a Snap.
- *
- * @param snapId - Snap ID.
- * @param message - Method call message.
- * @returns The selected accounts.
- */
-async function _SnapKeyring_handleGetSelectedAccounts(snapId, message) {
-    assert(message, GetSelectedAccountsRequestStruct);
-    return __classPrivateFieldGet(this, _SnapKeyring_selectedAccounts, "f").get(snapId) ?? [];
-}, _SnapKeyring_handleRequestApproved = 
-/**
- * Handle an Request Approved event from a Snap.
- *
- * @param snapId - Snap ID.
- * @param message - Event message.
- * @returns `null`.
- */
-async function _SnapKeyring_handleRequestApproved(snapId, message) {
-    assert(message, RequestApprovedEventStruct);
-    const { id, result } = message.params;
-    const { promise } = __classPrivateFieldGet(this, _SnapKeyring_requests, "f").get(snapId, id) ?? throwError(`Request '${id}' not found`);
-    __classPrivateFieldGet(this, _SnapKeyring_requests, "f").delete(snapId, id);
-    promise.resolve(result);
-    return null;
-}, _SnapKeyring_handleRequestRejected = 
-/**
- * Handle an Request Rejected event from a Snap.
- *
- * @param snapId - Snap ID.
- * @param message - Event message.
- * @returns `null`.
- */
-async function _SnapKeyring_handleRequestRejected(snapId, message) {
-    assert(message, RequestRejectedEventStruct);
-    const { id } = message.params;
-    const { promise } = __classPrivateFieldGet(this, _SnapKeyring_requests, "f").get(snapId, id) ?? throwError(`Request '${id}' not found`);
-    __classPrivateFieldGet(this, _SnapKeyring_requests, "f").delete(snapId, id);
-    promise.reject(new Error(`Request rejected by user or snap.`));
-    return null;
-}, _SnapKeyring_rePublishAccountEvent = 
-/**
- * Re-publish an account event.
- *
- * @param snapId - Snap ID.
- * @param event - The event type. This is a unique identifier for this event.
- * @param filteredEventCallback - A callback that returns the event to re-publish. This callback takes a filtering
- * function as parameter that can be used to filter out account ID that do not belong to this Snap ID.
- * @template EventType - A Snap keyring event type.
- * @returns `null`.
- */
-async function _SnapKeyring_rePublishAccountEvent(snapId, event, filteredEventCallback) {
-    // This callback can be used to filter out the accounts that no longer exists on the Snap (fail-safe) or to
-    // prevent other Snaps from updating accounts they do not own.
-    const filter = (accountMapping) => {
-        return Object.entries(accountMapping).reduce((filtered, [accountId, entry]) => {
-            if (__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").has(snapId, accountId)) {
-                // If the Snap owns this account, we can use it.
-                filtered[accountId] = entry;
-            }
-            else {
-                // Otherwise, we just filter it out and log it (for debugging/tracking purposes).
-                console.warn(`SnapKeyring - ${event} - Found an unknown account ID "${accountId}" for Snap ID "${snapId}". Skipping.`);
-            }
-            return filtered;
-        }, {});
-    };
-    __classPrivateFieldGet(this, _SnapKeyring_messenger, "f").publish(event, ...filteredEventCallback(filter));
-    return null;
-}, _SnapKeyring_handleAccountBalancesUpdated = 
-/**
- * Handle a balances updated event from a Snap.
- *
- * @param snapId - ID of the Snap.
- * @param message - Event message.
- * @returns `null`.
- */
-async function _SnapKeyring_handleAccountBalancesUpdated(snapId, message) {
-    assert(message, AccountBalancesUpdatedEventStruct);
-    const event = message.params;
-    return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_rePublishAccountEvent).call(this, snapId, 'SnapKeyring:accountBalancesUpdated', (filter) => {
-        event.balances = filter(event.balances);
-        return [event];
-    });
-}, _SnapKeyring_handleAccountAssetListUpdated = 
-/**
- * Handle a asset list updated event from a Snap.
- *
- * @param snapId - ID of the Snap.
- * @param message - Event message.
- * @returns `null`.
- */
-async function _SnapKeyring_handleAccountAssetListUpdated(snapId, message) {
-    assert(message, AccountAssetListUpdatedEventStruct);
-    const event = message.params;
-    return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_rePublishAccountEvent).call(this, snapId, 'SnapKeyring:accountAssetListUpdated', (filter) => {
-        event.assets = filter(event.assets);
-        return [event];
-    });
-}, _SnapKeyring_handleAccountTransactionsUpdated = 
-/**
- * Handle a transactions updated event from a Snap.
- *
- * @param snapId - ID of the Snap.
- * @param message - Event message.
- * @returns `null`.
- */
-async function _SnapKeyring_handleAccountTransactionsUpdated(snapId, message) {
-    assert(message, AccountTransactionsUpdatedEventStruct);
-    const event = message.params;
-    return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_rePublishAccountEvent).call(this, snapId, 'SnapKeyring:accountTransactionsUpdated', (filter) => {
-        event.transactions = filter(event.transactions);
-        return [event];
-    });
 }, _SnapKeyring_getAccount = function _SnapKeyring_getAccount(id) {
-    const found = [...__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").values()].find((entry) => entry.account.id === id);
-    if (!found) {
+    const snapId = __classPrivateFieldGet(this, _SnapKeyring_accountIndex, "f").get(id);
+    const account = snapId
+        ? __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId)?.lookupAccount(id)
+        : undefined;
+    if (!snapId || !account) {
         throw new Error(`Unable to get account: unknown account ID: '${id}'`);
     }
-    return found;
-}, _SnapKeyring_submitRequest = 
-/**
- * Submit a request to a Snap from an account address.
- *
- * @param opts - Request options.
- * @param opts.origin - Sender origin.
- * @param opts.address - Account address.
- * @param opts.method - Method to call.
- * @param opts.params - Method parameters.
- * @param opts.scope - Selected chain ID (CAIP-2).
- * @param opts.noPending - Whether the response is allowed to be pending.
- * @returns Promise that resolves to the result of the method call.
- */
-async function _SnapKeyring_submitRequest({ origin, address, method, params, scope = '', noPending = false, }) {
-    const { account, snapId } = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_resolveAddress).call(this, address);
-    return await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitSnapRequest).call(this, {
-        origin,
-        snapId,
-        account,
-        method: method,
-        params,
-        scope,
-        noPending,
-    });
-}, _SnapKeyring_submitSnapRequest = 
-/**
- * Submits a request to a Snap.
- *
- * @param options - The options for the Snap request.
- * @param options.origin - The sender origin.
- * @param options.snapId - The Snap ID to submit the request to.
- * @param options.account - The account to use for the request.
- * @param options.method - The Ethereum method to call.
- * @param options.params - The parameters to pass to the method, can be undefined.
- * @param options.scope - The chain ID to use for the request, can be an empty string.
- * @param options.noPending - Whether the response is allowed to be pending.
- * @returns A promise that resolves to the keyring response from the Snap.
- * @throws An error if the Snap fails to respond or if there's an issue with the request submission.
- */
-async function _SnapKeyring_submitSnapRequest({ origin, snapId, account, method, params, scope, noPending, }) {
-    if (!__classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_hasMethod).call(this, account, method)) {
-        throw new Error(`Method '${method}' not supported for account ${account.address}`);
-    }
-    // Will both catch `undefined` and "empty" origins.
-    if (!origin?.trim()) {
-        throw new Error('An `origin` is required');
-    }
-    // Generate a new random request ID to keep track of the request execution flow.
-    const requestId = uuid();
-    // Create the promise before calling the Snap to prevent a race condition
-    // where the Snap responds before we have a chance to create it.
-    const requestPromise = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_createRequestPromise).call(this, requestId, snapId);
-    try {
-        // Snaps are expecting to receive the `origin` field after a specific
-        // platform version.
-        //
-        // We need to check the Snap platform version to know whether we can
-        // include it or not.
-        const useOrigin = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_isMinimumPlatformVersion).call(this, snapId, PLATFORM_VERSION_FOR_KEYRING_REQUEST_WITH_ORIGIN);
-        const request = {
-            id: requestId,
-            origin,
-            scope,
-            account: account.id,
-            request: {
-                method,
-                ...(params !== undefined && { params }),
-            },
-        };
-        log('Submit Snap request: ', request);
-        // Get specific client for that Snap.
-        const client = __classPrivateFieldGet(this, _SnapKeyring_snapClient, "f").withSnapId(snapId);
-        let response;
-        if (useOrigin) {
-            response = await client.submitRequest(request);
-        }
-        else {
-            // Legacy keyring request did not support the `origin` field.
-            response = await client.submitRequestWithoutOrigin(toKeyringRequestWithoutOrigin(request));
-        }
-        // Some methods, like the ones used to prepare and patch user operations,
-        // require the Snap to answer synchronously in order to work with the
-        // confirmation flow. This check lets the caller enforce this behavior.
-        if (noPending && response.pending) {
-            throw new Error(`Request '${requestId}' to Snap '${snapId}' is pending and noPending is true.`);
-        }
-        // If the Snap answers synchronously, the promise must be removed from the
-        // map to prevent a leak.
-        if (!response.pending) {
-            return __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleSyncResponse).call(this, response, requestId, snapId);
-        }
-        // If the Snap answers asynchronously, we will inform the user with a redirect
-        if (response.redirect?.message || response.redirect?.url) {
-            await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_handleAsyncResponse).call(this, response.redirect, snapId);
-        }
-        return requestPromise.promise;
-    }
-    catch (error) {
-        log('Snap Request failed: ', { requestId });
-        // If the Snap failed to respond, delete the promise to prevent a leak.
-        __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_clearRequestPromise).call(this, requestId, snapId);
-        throw error;
-    }
-}, _SnapKeyring_hasMethod = function _SnapKeyring_hasMethod(account, method) {
-    return account.methods.includes(method);
-}, _SnapKeyring_createRequestPromise = function _SnapKeyring_createRequestPromise(requestId, snapId) {
-    const promise = new DeferredPromise();
-    __classPrivateFieldGet(this, _SnapKeyring_requests, "f").set(requestId, { promise, snapId });
-    return promise;
-}, _SnapKeyring_clearRequestPromise = function _SnapKeyring_clearRequestPromise(requestId, snapId) {
-    __classPrivateFieldGet(this, _SnapKeyring_requests, "f").delete(snapId, requestId);
-}, _SnapKeyring_handleSyncResponse = function _SnapKeyring_handleSyncResponse(response, requestId, snapId) {
-    __classPrivateFieldGet(this, _SnapKeyring_requests, "f").delete(snapId, requestId);
-    // We consider `Response` to be compatible with `result` here.
-    return response.result;
-}, _SnapKeyring_handleAsyncResponse = 
-/**
- * Handles the async redirect and response from a Snap. Validates the redirect URL and informs the user with a message and URL if provided.
- *
- * @param redirect - The redirect information including message and URL.
- * @param redirect.message - The message to show to the user if provided.
- * @param redirect.url - The URL to redirect the user to if provided.
- * @param snapId - The Snap ID associated with the request.
- * @throws An error if the redirect URL is not an allowed origin for the Snap.
- */
-async function _SnapKeyring_handleAsyncResponse(redirect, snapId) {
-    const { message = '', url: redirectUrl = '' } = redirect;
-    const url = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_sanitizeRedirectUrl).call(this, redirectUrl);
-    if (url) {
-        __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_validateRedirectUrl).call(this, url, snapId);
-    }
-    await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").redirectUser(snapId, url, message);
-}, _SnapKeyring_sanitizeRedirectUrl = function _SnapKeyring_sanitizeRedirectUrl(url) {
-    // We do check if the URL is empty or not since the Snap might not returns any URL at all.
-    return url ? sanitizeUrl(url) : url;
-}, _SnapKeyring_validateRedirectUrl = function _SnapKeyring_validateRedirectUrl(url, snapId) {
-    const { origin } = new URL(url);
-    const snap = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getSnap).call(this, snapId);
-    if (!snap) {
-        throw new Error(`Snap '${snapId}' not found.`);
-    }
-    const allowedOrigins = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getSnapAllowedOrigins).call(this, snap);
-    if (!allowedOrigins.includes(origin)) {
-        throw new Error(`Redirect URL domain '${origin}' is not an allowed origin by snap '${snapId}'`);
-    }
-}, _SnapKeyring_deleteAccount = 
-/**
- * Removes an account.
- *
- * @param snapId - Snap ID.
- * @param account - Account to delete.
- */
-async function _SnapKeyring_deleteAccount(snapId, account) {
-    // Always remove the account from the maps, even if the Snap is going to
-    // fail to delete it.
-    __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").delete(snapId, account.id);
-    try {
-        await __classPrivateFieldGet(this, _SnapKeyring_snapClient, "f").withSnapId(snapId).deleteAccount(account.id);
-    }
-    catch (error) {
-        // If the Snap failed to delete the account, log the error and continue
-        // with the account deletion, otherwise the account will be stuck in the
-        // keyring.
-        console.error(`Account '${account.address}' may not have been removed from snap '${snapId}':`, error);
-    }
+    return { account, snapId };
 }, _SnapKeyring_resolveAddress = function _SnapKeyring_resolveAddress(address) {
-    return ([...__classPrivateFieldGet(this, _SnapKeyring_accounts, "f").values()].find(({ account }) => equalsIgnoreCase(account.address, address)) ?? throwError(`Account '${address}' not found`));
-}, _SnapKeyring_updateSelectedAccountsMap = function _SnapKeyring_updateSelectedAccountsMap(accounts) {
-    const selectedAccounts = __classPrivateFieldGet(this, _SnapKeyring_selectedAccounts, "f");
-    selectedAccounts.clear();
-    for (const account of accounts) {
-        const snapId = __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").getSnapId(account);
-        if (!snapId) {
-            continue;
+    for (const keyring of __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").values()) {
+        const account = keyring.lookupByAddress(address);
+        if (account) {
+            return { account, keyring };
         }
-        const snapAccounts = selectedAccounts.get(snapId) ?? [];
-        snapAccounts.push(account);
-        selectedAccounts.set(snapId, snapAccounts);
     }
+    return throwError(`Account '${address}' not found`);
 }, _SnapKeyring_getSnap = function _SnapKeyring_getSnap(snapId) {
-    return __classPrivateFieldGet(this, _SnapKeyring_messenger, "f").call('SnapController:get', snapId);
+    return __classPrivateFieldGet(this, _SnapKeyring_messenger, "f").call('SnapController:getSnap', snapId);
 }, _SnapKeyring_getSnapMetadata = function _SnapKeyring_getSnapMetadata(snapId) {
     const snap = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getSnap).call(this, snapId);
     return snap
         ? { id: snapId, name: snap.manifest.proposedName, enabled: snap.enabled }
         : undefined;
-}, _SnapKeyring_getSnapAllowedOrigins = function _SnapKeyring_getSnapAllowedOrigins(snap) {
-    return (snap.manifest.initialPermissions['endowment:keyring']?.allowedOrigins ??
-        []);
 }, _SnapKeyring_transformToInternalAccount = function _SnapKeyring_transformToInternalAccount(account, snapId) {
     const snap = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getSnapMetadata).call(this, snapId);
     return {