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

package/dist/SnapKeyringV1.mjs

@@ -0,0 +1,732 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _SnapKeyringV1_instances, _SnapKeyringV1_callbacks, _SnapKeyringV1_isAnyAccountTypeAllowed, _SnapKeyringV1_requests, _SnapKeyringV1_options, _SnapKeyringV1_selectedAccounts, _SnapKeyringV1_handleAccountCreated, _SnapKeyringV1_handleAccountUpdated, _SnapKeyringV1_handleAccountDeleted, _SnapKeyringV1_handleRequestApproved, _SnapKeyringV1_handleRequestRejected, _SnapKeyringV1_handleGetSelectedAccounts, _SnapKeyringV1_handleAccountBalancesUpdated, _SnapKeyringV1_handleAccountAssetListUpdated, _SnapKeyringV1_handleAccountTransactionsUpdated, _SnapKeyringV1_rePublishAccountEvent, _SnapKeyringV1_createSnapAccount, _SnapKeyringV1_getInternalOptions, _SnapKeyringV1_getExistingAccount, _SnapKeyringV1_createRequestPromise, _SnapKeyringV1_handleAsyncRedirect, _SnapKeyringV1_validateRedirectUrl;
+import { TransactionFactory } from "@ethereumjs/tx";
+import { SignTypedDataVersion } from "@metamask/eth-sig-util";
+import { AnyAccountType, EthMethod, KeyringEvent, EthBytesStruct, EthBaseUserOperationStruct, EthUserOperationPatchStruct, AccountBalancesUpdatedEventStruct, AccountAssetListUpdatedEventStruct, AccountTransactionsUpdatedEventStruct } from "@metamask/keyring-api";
+import { toKeyringRequestWithoutOrigin } from "@metamask/keyring-internal-api";
+import { KeyringInternalSnapClient } from "@metamask/keyring-internal-snap-client";
+import { KeyringAccountRegistry } from "@metamask/keyring-sdk";
+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, createDeferredPromise } from "@metamask/utils";
+import { v4 as uuid } from "uuid";
+import { transformAccount } from "./account.mjs";
+import { AccountCreatedEventStruct, AccountUpdatedEventStruct, AccountDeletedEventStruct, RequestApprovedEventStruct, RequestRejectedEventStruct } from "./events.mjs";
+import { projectLogger as log } from "./logger.mjs";
+import { getInternalOptionsOf } from "./options.mjs";
+import { PLATFORM_VERSION_FOR_KEYRING_REQUEST_WITH_ORIGIN } from "./platform-versions.mjs";
+import { SnapMessageStruct } from "./types.mjs";
+import { equalsIgnoreCase, normalizeAccountAddress, sanitizeUrl, throwError, toJson } from "./util.mjs";
+/**
+ * Per-snap coordinator for the v1 (event-driven) keyring flow.
+ *
+ * Each instance is scoped to exactly one `SnapId`. It handles all Snap
+ * keyring events (account lifecycle, request approval, asset updates) and
+ * owns the per-snap request / internal-options state.
+ *
+ * Designed to be subclassed: `SnapKeyringV2` extends this class and adds the
+ * `KeyringV2` interface on top, sharing the same registry and client.
+ */
+export class SnapKeyringV1 {
+    constructor({ snapId, messenger, callbacks, isAnyAccountTypeAllowed = false, }) {
+        _SnapKeyringV1_instances.add(this);
+        /** Injected callbacks for parent-level coordination. */
+        _SnapKeyringV1_callbacks.set(this, void 0);
+        /** Whether to allow the creation and update of generic accounts. */
+        _SnapKeyringV1_isAnyAccountTypeAllowed.set(this, void 0);
+        /**
+         * Pending async request promises, keyed by request ID.
+         * Plain Map is sufficient here since this instance is already snap-scoped.
+         */
+        _SnapKeyringV1_requests.set(this, void 0);
+        /**
+         * Correlation ID → internal options, used to thread options from
+         * `createAccount` through to the `AccountCreated` event handler.
+         */
+        _SnapKeyringV1_options.set(this, void 0);
+        /**
+         * The currently selected account IDs for this snap.
+         */
+        _SnapKeyringV1_selectedAccounts.set(this, void 0);
+        this.snapId = snapId;
+        this.registry = new KeyringAccountRegistry();
+        this.messenger = messenger;
+        __classPrivateFieldSet(this, _SnapKeyringV1_callbacks, callbacks, "f");
+        __classPrivateFieldSet(this, _SnapKeyringV1_isAnyAccountTypeAllowed, isAnyAccountTypeAllowed, "f");
+        this.client = new KeyringInternalSnapClient({ messenger, snapId });
+        __classPrivateFieldSet(this, _SnapKeyringV1_requests, new Map(), "f");
+        __classPrivateFieldSet(this, _SnapKeyringV1_options, new Map(), "f");
+        __classPrivateFieldSet(this, _SnapKeyringV1_selectedAccounts, [], "f");
+    }
+    // ──────────────────────────────────────────────
+    // Public API
+    // ──────────────────────────────────────────────
+    /**
+     * Create a single account using the v1 event-driven flow.
+     *
+     * Handles the reserved 'metamask' field, correlation IDs, and internal
+     * options registration. The account is ultimately added to the registry
+     * via the `AccountCreated` event handler, not the return value.
+     *
+     * @param options - Account creation options.
+     * @param internalOptions - Internal Snap keyring options.
+     * @returns The account object returned by the snap.
+     */
+    async createAccount(options, internalOptions) {
+        return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_createSnapAccount).call(this, options, internalOptions);
+    }
+    /**
+     * Handle an incoming message from the Snap.
+     *
+     * Routes the message to the appropriate private handler based on the method.
+     *
+     * @param message - The message sent by the Snap.
+     * @returns The execution result.
+     */
+    async handleKeyringSnapMessage(message) {
+        assert(message, SnapMessageStruct);
+        switch (message.method) {
+            case `${KeyringEvent.AccountCreated}`: {
+                return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleAccountCreated).call(this, message);
+            }
+            case `${KeyringEvent.AccountUpdated}`: {
+                return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleAccountUpdated).call(this, message);
+            }
+            case `${KeyringEvent.AccountDeleted}`: {
+                return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleAccountDeleted).call(this, message);
+            }
+            case `${KeyringEvent.RequestApproved}`: {
+                return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleRequestApproved).call(this, message);
+            }
+            case `${KeyringEvent.RequestRejected}`: {
+                return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleRequestRejected).call(this, message);
+            }
+            case `${KeyringEvent.AccountBalancesUpdated}`: {
+                return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleAccountBalancesUpdated).call(this, message);
+            }
+            case `${KeyringEvent.AccountAssetListUpdated}`: {
+                return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleAccountAssetListUpdated).call(this, message);
+            }
+            case `${KeyringEvent.AccountTransactionsUpdated}`: {
+                return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleAccountTransactionsUpdated).call(this, message);
+            }
+            case `${SnapManageAccountsMethod.GetSelectedAccounts}`: {
+                return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleGetSelectedAccounts).call(this, message);
+            }
+            default:
+                throw new Error(`Method not supported: ${message.method}`);
+        }
+    }
+    /**
+     * Submit a snap request for the given account.
+     *
+     * Manages the request promise lifecycle (creation, resolution, cleanup) and
+     * handles both synchronous and asynchronous (redirect) responses.
+     *
+     * @param options - The request options.
+     * @param options.origin - The sender origin.
+     * @param options.account - The account to submit the request for.
+     * @param options.method - The method to call.
+     * @param options.params - The method parameters.
+     * @param options.scope - The CAIP-2 chain ID.
+     * @param options.noPending - Whether the response is allowed to be pending.
+     * @returns A promise that resolves to the keyring response.
+     */
+    async submitSnapRequest({ origin, account, method, params, scope, noPending, }) {
+        if (!account.methods.includes(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');
+        }
+        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, _SnapKeyringV1_instances, "m", _SnapKeyringV1_createRequestPromise).call(this, requestId);
+        try {
+            const useOrigin = this.messenger.call('SnapController:isMinimumPlatformVersion', 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);
+            let response;
+            if (useOrigin) {
+                response = await this.client.submitRequest(request);
+            }
+            else {
+                response = await this.client.submitRequestWithoutOrigin(toKeyringRequestWithoutOrigin(request));
+            }
+            if (noPending && response.pending) {
+                throw new Error(`Request '${requestId}' to Snap '${this.snapId}' is pending and noPending is true.`);
+            }
+            if (!response.pending) {
+                __classPrivateFieldGet(this, _SnapKeyringV1_requests, "f").delete(requestId);
+                return response.result;
+            }
+            if (response.redirect?.message || response.redirect?.url) {
+                await __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_handleAsyncRedirect).call(this, response.redirect);
+            }
+            return requestPromise.promise;
+        }
+        catch (error) {
+            log('Snap Request failed: ', { requestId });
+            __classPrivateFieldGet(this, _SnapKeyringV1_requests, "f").delete(requestId);
+            throw error;
+        }
+    }
+    /**
+     * Update the selected accounts for this snap.
+     *
+     * @param accountIds - The account IDs to set as selected.
+     */
+    async setSelectedAccounts(accountIds) {
+        __classPrivateFieldSet(this, _SnapKeyringV1_selectedAccounts, accountIds, "f");
+        try {
+            await this.client.setSelectedAccounts(accountIds);
+        }
+        catch (error) {
+            console.error(`Failed to set selected accounts for ${this.snapId} snap: '${error.message}'`);
+        }
+    }
+    /**
+     * Resolve the account address associated with a signing request.
+     *
+     * Delegates directly to the snap-scoped client, which already has the
+     * snap ID baked in from construction time.
+     *
+     * @param scope - CAIP-2 chain ID.
+     * @param request - Signing request object.
+     * @returns The resolved address if found, `null` otherwise.
+     */
+    async resolveAccountAddress(scope, request) {
+        return this.client.resolveAccountAddress(scope, request);
+    }
+    /**
+     * Sign a transaction for the given account.
+     *
+     * @param account - The account to sign the transaction for.
+     * @param transaction - The transaction to sign.
+     * @param _opts - Transaction options (unused).
+     * @returns A promise that resolves to the signed transaction.
+     */
+    async signTransaction(account, transaction, 
+    /* istanbul ignore next */
+    _opts = {}) {
+        const chainId = transaction.common.chainId();
+        const tx = toJson({
+            ...transaction.toJSON(),
+            from: normalizeAccountAddress(account),
+            type: `0x${transaction.type.toString(16)}`,
+            chainId: bigIntToHex(chainId),
+        });
+        const signedTx = await this.submitSnapRequest({
+            origin: 'metamask',
+            account,
+            method: EthMethod.SignTransaction,
+            params: [tx],
+            scope: toCaipChainId(KnownCaipNamespace.Eip155, `${chainId}`),
+            noPending: false,
+        });
+        // ! 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,
+        });
+    }
+    /**
+     * Sign a typed data message for the given account.
+     *
+     * @param account - The account to sign the typed data for.
+     * @param data - The typed data to sign.
+     * @param opts - Signing options.
+     * @param opts.version - The typed data version to use.
+     * @returns A promise that resolves to the signature.
+     */
+    async signTypedData(account, data, opts) {
+        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;
+        const address = normalizeAccountAddress(account);
+        return strictMask(await this.submitSnapRequest({
+            origin: 'metamask',
+            account,
+            method,
+            params: toJson([address, data]),
+            scope: chainId === undefined
+                ? ''
+                : toCaipChainId(KnownCaipNamespace.Eip155, `${chainId}`),
+            noPending: false,
+        }), EthBytesStruct);
+    }
+    /**
+     * Sign a message (eth_sign) for the given account.
+     *
+     * @param account - The account to sign the message for.
+     * @param hash - The data to sign.
+     * @returns A promise that resolves to the signature.
+     */
+    async signMessage(account, hash) {
+        const address = normalizeAccountAddress(account);
+        return strictMask(await this.submitSnapRequest({
+            origin: 'metamask',
+            account,
+            method: EthMethod.Sign,
+            params: toJson([address, hash]),
+            scope: '',
+            noPending: false,
+        }), EthBytesStruct);
+    }
+    /**
+     * Sign a personal message for the given account.
+     *
+     * Note: KeyringController says this should return a Buffer but it actually
+     * expects a string.
+     *
+     * @param account - The account to sign the message for.
+     * @param data - The data to sign.
+     * @returns A promise that resolves to the signature.
+     */
+    async signPersonalMessage(account, data) {
+        const address = normalizeAccountAddress(account);
+        return strictMask(await this.submitSnapRequest({
+            origin: 'metamask',
+            account,
+            method: EthMethod.PersonalSign,
+            params: toJson([data, address]),
+            scope: '',
+            noPending: false,
+        }), EthBytesStruct);
+    }
+    /**
+     * Convert a base transaction to a base UserOperation.
+     *
+     * @param account - The account to prepare the user operation for.
+     * @param transactions - Base transactions to include in the UserOperation.
+     * @param context - Keyring execution context.
+     * @returns A pseudo-UserOperation that can be used to construct a real one.
+     */
+    async prepareUserOperation(account, transactions, context) {
+        return strictMask(await this.submitSnapRequest({
+            origin: 'metamask',
+            account,
+            method: EthMethod.PrepareUserOperation,
+            params: toJson(transactions),
+            noPending: true,
+            scope: toCaipChainId(KnownCaipNamespace.Eip155, context.chainId),
+        }), EthBaseUserOperationStruct);
+    }
+    /**
+     * Patches properties of a UserOperation. Currently, only the
+     * `paymasterAndData` can be patched.
+     *
+     * @param account - The account to patch the user operation for.
+     * @param userOp - UserOperation to patch.
+     * @param context - Keyring execution context.
+     * @returns A patch to apply to the UserOperation.
+     */
+    async patchUserOperation(account, userOp, context) {
+        return strictMask(await this.submitSnapRequest({
+            origin: 'metamask',
+            account,
+            method: EthMethod.PatchUserOperation,
+            params: toJson([userOp]),
+            noPending: true,
+            scope: toCaipChainId(KnownCaipNamespace.Eip155, context.chainId),
+        }), EthUserOperationPatchStruct);
+    }
+    /**
+     * Signs a UserOperation.
+     *
+     * @param account - The account to sign the user operation for.
+     * @param userOp - UserOperation to sign.
+     * @param context - Keyring execution context.
+     * @returns A promise that resolves to the signature.
+     */
+    async signUserOperation(account, userOp, context) {
+        return strictMask(await this.submitSnapRequest({
+            origin: 'metamask',
+            account,
+            method: EthMethod.SignUserOperation,
+            params: toJson([userOp]),
+            noPending: false,
+            scope: toCaipChainId(KnownCaipNamespace.Eip155, context.chainId),
+        }), EthBytesStruct);
+    }
+}
+_SnapKeyringV1_callbacks = new WeakMap(), _SnapKeyringV1_isAnyAccountTypeAllowed = new WeakMap(), _SnapKeyringV1_requests = new WeakMap(), _SnapKeyringV1_options = new WeakMap(), _SnapKeyringV1_selectedAccounts = new WeakMap(), _SnapKeyringV1_instances = new WeakSet(), _SnapKeyringV1_handleAccountCreated = 
+// ──────────────────────────────────────────────
+// Private handlers
+// ──────────────────────────────────────────────
+/**
+ * Handle an Account Created event from the Snap.
+ *
+ * @param message - Event message.
+ * @returns `null`.
+ */
+async function _SnapKeyringV1_handleAccountCreated(message) {
+    assert(message, AccountCreatedEventStruct);
+    const { metamask, 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, _SnapKeyringV1_instances, "m", _SnapKeyringV1_getExistingAccount).call(this, account)) {
+        // If the account already exists, we skip it.
+        return null;
+    }
+    // Make sure this new account is valid.
+    await __classPrivateFieldGet(this, _SnapKeyringV1_callbacks, "f").assertAccountCanBeUsed(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 = createDeferredPromise();
+    // Add the account to the keyring, but wait for the MetaMask client to
+    // approve the account creation first.
+    await __classPrivateFieldGet(this, _SnapKeyringV1_callbacks, "f").addAccount(address, 
+    // 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.
+            this.registry.set(account);
+            __classPrivateFieldGet(this, _SnapKeyringV1_callbacks, "f").onRegister?.(account.id);
+            // 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, _SnapKeyringV1_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(
+            /* istanbul ignore next */
+            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).
+                this.registry.delete(account.id);
+                __classPrivateFieldGet(this, _SnapKeyringV1_callbacks, "f").onUnregister?.(account.id);
+                await this.client
+                    .deleteAccount(account.id)
+                    /* istanbul ignore next */
+                    .catch(() => {
+                    // Swallow — best-effort cleanup.
+                });
+                // 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, _SnapKeyringV1_instances, "m", _SnapKeyringV1_getInternalOptions).call(this, metamask?.correlationId) ?? {},
+        // 2. We use the ones coming from the Snap.
+        {
+            displayConfirmation,
+            displayAccountNameSuggestion,
+        },
+    ]));
+    return null;
+}, _SnapKeyringV1_handleAccountUpdated = 
+/**
+ * Handle an Account Updated event from the Snap.
+ *
+ * @param message - Event message.
+ * @returns `null`.
+ */
+async function _SnapKeyringV1_handleAccountUpdated(message) {
+    assert(message, AccountUpdatedEventStruct);
+    const { account: newAccountFromEvent } = message.params;
+    const oldAccount = this.registry.get(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, _SnapKeyringV1_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}'`);
+    }
+    this.registry.set(newAccount);
+    await __classPrivateFieldGet(this, _SnapKeyringV1_callbacks, "f").saveState();
+    return null;
+}, _SnapKeyringV1_handleAccountDeleted = 
+/**
+ * Handle an Account Deleted event from the Snap.
+ *
+ * @param message - Event message.
+ * @returns `null`.
+ */
+async function _SnapKeyringV1_handleAccountDeleted(message) {
+    assert(message, AccountDeletedEventStruct);
+    const { id } = message.params;
+    const account = this.registry.get(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 (account === undefined) {
+        return null;
+    }
+    await __classPrivateFieldGet(this, _SnapKeyringV1_callbacks, "f").removeAccount(normalizeAccountAddress(account), async (accepted) => {
+        if (accepted) {
+            await __classPrivateFieldGet(this, _SnapKeyringV1_callbacks, "f").saveState();
+        }
+    });
+    return null;
+}, _SnapKeyringV1_handleRequestApproved = 
+/**
+ * Handle a Request Approved event from the Snap.
+ *
+ * @param message - Event message.
+ * @returns `null`.
+ */
+async function _SnapKeyringV1_handleRequestApproved(message) {
+    assert(message, RequestApprovedEventStruct);
+    const { id, result } = message.params;
+    const promise = __classPrivateFieldGet(this, _SnapKeyringV1_requests, "f").get(id) ?? throwError(`Request '${id}' not found`);
+    __classPrivateFieldGet(this, _SnapKeyringV1_requests, "f").delete(id);
+    promise.resolve(result);
+    return null;
+}, _SnapKeyringV1_handleRequestRejected = 
+/**
+ * Handle a Request Rejected event from the Snap.
+ *
+ * @param message - Event message.
+ * @returns `null`.
+ */
+async function _SnapKeyringV1_handleRequestRejected(message) {
+    assert(message, RequestRejectedEventStruct);
+    const { id } = message.params;
+    const promise = __classPrivateFieldGet(this, _SnapKeyringV1_requests, "f").get(id) ?? throwError(`Request '${id}' not found`);
+    __classPrivateFieldGet(this, _SnapKeyringV1_requests, "f").delete(id);
+    promise.reject(new Error(`Request rejected by user or snap.`));
+    return null;
+}, _SnapKeyringV1_handleGetSelectedAccounts = 
+/**
+ * Handle a Get Selected Accounts method call from the Snap.
+ *
+ * @param message - Method call message.
+ * @returns The selected accounts.
+ */
+async function _SnapKeyringV1_handleGetSelectedAccounts(message) {
+    assert(message, GetSelectedAccountsRequestStruct);
+    return __classPrivateFieldGet(this, _SnapKeyringV1_selectedAccounts, "f");
+}, _SnapKeyringV1_handleAccountBalancesUpdated = 
+/**
+ * Handle an Account Balances Updated event from the Snap.
+ *
+ * @param message - Event message.
+ * @returns `null`.
+ */
+async function _SnapKeyringV1_handleAccountBalancesUpdated(message) {
+    assert(message, AccountBalancesUpdatedEventStruct);
+    const event = message.params;
+    return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_rePublishAccountEvent).call(this, 'SnapKeyring:accountBalancesUpdated', (filter) => {
+        event.balances = filter(event.balances);
+        return [event];
+    });
+}, _SnapKeyringV1_handleAccountAssetListUpdated = 
+/**
+ * Handle an Account Asset List Updated event from the Snap.
+ *
+ * @param message - Event message.
+ * @returns `null`.
+ */
+async function _SnapKeyringV1_handleAccountAssetListUpdated(message) {
+    assert(message, AccountAssetListUpdatedEventStruct);
+    const event = message.params;
+    return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_rePublishAccountEvent).call(this, 'SnapKeyring:accountAssetListUpdated', (filter) => {
+        event.assets = filter(event.assets);
+        return [event];
+    });
+}, _SnapKeyringV1_handleAccountTransactionsUpdated = 
+/**
+ * Handle an Account Transactions Updated event from the Snap.
+ *
+ * @param message - Event message.
+ * @returns `null`.
+ */
+async function _SnapKeyringV1_handleAccountTransactionsUpdated(message) {
+    assert(message, AccountTransactionsUpdatedEventStruct);
+    const event = message.params;
+    return __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_rePublishAccountEvent).call(this, 'SnapKeyring:accountTransactionsUpdated', (filter) => {
+        event.transactions = filter(event.transactions);
+        return [event];
+    });
+}, _SnapKeyringV1_rePublishAccountEvent = 
+// ──────────────────────────────────────────────
+// Private helpers
+// ──────────────────────────────────────────────
+/**
+ * Re-publish an account event after filtering out accounts that don't
+ * belong to this snap.
+ *
+ * Uses the registry as the source of truth: only accounts present in
+ * this snap's registry are forwarded. This prevents a snap from emitting
+ * updates for accounts it doesn't own.
+ *
+ * @param event - The event type to re-publish.
+ * @param filteredEventCallback - Callback that receives the filter function
+ * and returns the event payload to publish.
+ * @template EventType - A Snap keyring event type.
+ * @returns `null`.
+ */
+async function _SnapKeyringV1_rePublishAccountEvent(event, filteredEventCallback) {
+    const filter = (accountMapping) => {
+        return Object.entries(accountMapping).reduce((filtered, [accountId, entry]) => {
+            if (this.registry.has(accountId)) {
+                filtered[accountId] = entry;
+            }
+            else {
+                console.warn(`SnapKeyring - ${event} - Found an unknown account ID "${accountId}" for Snap ID "${this.snapId}". Skipping.`);
+            }
+            return filtered;
+        }, {});
+    };
+    this.messenger.publish(event, ...filteredEventCallback(filter));
+    return null;
+}, _SnapKeyringV1_createSnapAccount = 
+/**
+ * Core logic for the v1 `createAccount` flow.
+ *
+ * Handles the reserved 'metamask' field, correlation IDs, and internal
+ * options registration. The account is ultimately added to the registry
+ * via the `AccountCreated` event handler, not the return value.
+ *
+ * @param options - Account creation options.
+ * @param internalOptions - Internal Snap keyring options.
+ * @returns The account object returned by the snap.
+ */
+async function _SnapKeyringV1_createSnapAccount(options, internalOptions) {
+    const reserved = 'metamask';
+    if (hasProperty(options, reserved)) {
+        throw new Error(`The '${reserved}' property is reserved for internal use`);
+    }
+    if (!internalOptions) {
+        return await this.client.createAccount(options);
+    }
+    const correlationId = uuid();
+    __classPrivateFieldGet(this, _SnapKeyringV1_options, "f").set(correlationId, internalOptions);
+    return await this.client.createAccount({
+        ...options,
+        metamask: {
+            correlationId,
+        },
+    });
+}, _SnapKeyringV1_getInternalOptions = function _SnapKeyringV1_getInternalOptions(correlationId) {
+    if (!correlationId) {
+        return undefined;
+    }
+    const options = __classPrivateFieldGet(this, _SnapKeyringV1_options, "f").get(correlationId);
+    if (options) {
+        __classPrivateFieldGet(this, _SnapKeyringV1_options, "f").delete(correlationId);
+        return options;
+    }
+    console.warn(`SnapKeyring - Received unmapped correlation ID: "${correlationId}"`);
+    return undefined;
+}, _SnapKeyringV1_getExistingAccount = function _SnapKeyringV1_getExistingAccount(account) {
+    const address = normalizeAccountAddress(account);
+    const existing = this.registry.get(account.id);
+    if (existing && normalizeAccountAddress(existing) === address) {
+        return existing;
+    }
+    return undefined;
+}, _SnapKeyringV1_createRequestPromise = function _SnapKeyringV1_createRequestPromise(requestId) {
+    const promise = createDeferredPromise();
+    __classPrivateFieldGet(this, _SnapKeyringV1_requests, "f").set(requestId, promise);
+    return promise;
+}, _SnapKeyringV1_handleAsyncRedirect = 
+/**
+ * Handle an async redirect response from the Snap.
+ *
+ * @param redirect - The redirect information.
+ * @param redirect.message - The message to show the user.
+ * @param redirect.url - The URL to redirect to.
+ */
+async function _SnapKeyringV1_handleAsyncRedirect(redirect) {
+    const { message = '', url: redirectUrl = '' } = redirect;
+    const url = redirectUrl ? sanitizeUrl(redirectUrl) : redirectUrl;
+    if (url) {
+        __classPrivateFieldGet(this, _SnapKeyringV1_instances, "m", _SnapKeyringV1_validateRedirectUrl).call(this, url);
+    }
+    await __classPrivateFieldGet(this, _SnapKeyringV1_callbacks, "f").redirectUser(url, message);
+}, _SnapKeyringV1_validateRedirectUrl = function _SnapKeyringV1_validateRedirectUrl(url) {
+    const { origin } = new URL(url);
+    const snap = this.messenger.call('SnapController:getSnap', this.snapId);
+    if (!snap) {
+        throw new Error(`Snap '${this.snapId}' not found.`);
+    }
+    const allowedOrigins = snap.manifest.initialPermissions['endowment:keyring']?.allowedOrigins ??
+        [];
+    if (!allowedOrigins.includes(origin)) {
+        throw new Error(`Redirect URL domain '${origin}' is not an allowed origin by snap '${this.snapId}'`);
+    }
+};
+//# sourceMappingURL=SnapKeyringV1.mjs.map