@metamask-previews/eth-snap-keyring 20.0.0-018fb62 → 20.0.0-d23a1b9

package/CHANGELOG.md

@@ -9,12 +9,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
-- Add `SnapKeyringV2` class, a per-snap keyring wrapper with O(1) account lookups by ID and address ([#501](https://github.com/MetaMask/accounts/pull/501))
+- Add `SnapKeyringV2` class, a per-snap keyring wrapper that implements `KeyringV2` with `createAccount`, `createAccounts`, `deleteAccount`, `submitRequest`, `getAccount`, and `getAccounts` ([#501](https://github.com/MetaMask/accounts/pull/501))
+- Add `@metamask/keyring-sdk` `^1.1.0` as a new dependency ([#501](https://github.com/MetaMask/accounts/pull/501))
 
 ### Changed
 
 - Refactor `SnapKeyring` to store accounts in per-snap `SnapKeyringV2` wrappers instead of a single flat map ([#501](https://github.com/MetaMask/accounts/pull/501))
-- Bump `@metamask/keyring-sdk` from none to `^1.1.0`
 - Bump `@metamask/messenger` from `^0.3.0` to `^1.1.1` ([#489](https://github.com/MetaMask/accounts/pull/489), [#500](https://github.com/MetaMask/accounts/pull/500))
 - Bump `@metamask/snaps-controllers` from `^19.0.0` to `^19.0.1` ([#500](https://github.com/MetaMask/accounts/pull/500))
 - Bump `@metamask/snaps-utils` from `^12.1.2` to `^12.1.3` ([#500](https://github.com/MetaMask/accounts/pull/500))

package/dist/SnapKeyring.cjs

@@ -10,7 +10,7 @@ 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_snapKeyrings, _SnapKeyring_accountIndex, _SnapKeyring_selectedAccounts, _SnapKeyring_requests, _SnapKeyring_options, _SnapKeyring_callbacks, _SnapKeyring_isAnyAccountTypeAllowed, _SnapKeyring_lock, _SnapKeyring_withLock, _SnapKeyring_getOrCreateKeyringV2, _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;
+var _SnapKeyring_instances, _SnapKeyring_messenger, _SnapKeyring_snapClient, _SnapKeyring_snapKeyrings, _SnapKeyring_accountIndex, _SnapKeyring_selectedAccounts, _SnapKeyring_requests, _SnapKeyring_options, _SnapKeyring_callbacks, _SnapKeyring_isAnyAccountTypeAllowed, _SnapKeyring_lock, _SnapKeyring_withLock, _SnapKeyring_getOrCreateKeyringV2, _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_createSnapAccount, _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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnapKeyring = exports.SNAP_KEYRING_TYPE = void 0;
 const tx_1 = require("@ethereumjs/tx");
@@ -36,20 +36,6 @@ const SnapKeyringV2_1 = require("./SnapKeyringV2.cjs");
 const types_1 = require("./types.cjs");
 const util_1 = require("./util.cjs");
 exports.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 (0, keyring_api_1.isEvmAccountType)(account.type)
-        ? account.address.toLowerCase()
-        : account.address;
-}
 /**
  * Keyring bridge implementation to support Snaps.
  */
@@ -218,7 +204,7 @@ class SnapKeyring {
         // Rebuild per-snap wrappers. Migrations run inside wrapper.deserialize().
         for (const [snapId, accounts] of bySnap) {
             const wrapper = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getOrCreateKeyringV2).call(this, snapId);
-            wrapper.deserialize({ snapId, accounts });
+            await wrapper.deserialize({ snapId, accounts });
             // onRegister callbacks fired above have repopulated #accountIndex.
         }
     }
@@ -231,7 +217,7 @@ class SnapKeyring {
         const addresses = [];
         for (const wrapper of __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").values()) {
             for (const account of wrapper.accounts()) {
-                addresses.push(normalizeAccountAddress(account));
+                addresses.push((0, util_1.normalizeAccountAddress)(account));
             }
         }
         return (0, util_1.unique)(addresses);
@@ -243,10 +229,12 @@ class SnapKeyring {
      * @returns The addresses of the accounts associated with the given Snap.
      */
     async getAccountsBySnapId(snapId) {
-        return (0, util_1.unique)((__classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId)?.accounts() ?? []).map(normalizeAccountAddress));
+        return (0, util_1.unique)((__classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId)?.accounts() ?? []).map(util_1.normalizeAccountAddress));
     }
     /**
-     * Create an account.
+     * Create an account (v1 event-driven flow).
+     *
+     * Delegates to the per-snap `SnapKeyringV2` wrapper.
      *
      * @param snapId - Snap ID to create the account for.
      * @param options - Account creation options. Differs between keyrings.
@@ -254,120 +242,20 @@ class SnapKeyring {
      * @returns The account object.
      */
     async createAccount(snapId, options, internalOptions) {
-        const client = new keyring_internal_snap_client_1.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 ((0, utils_1.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 = (0, uuid_1.v4)();
-        // 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_getOrCreateKeyringV2).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` wrapper 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 keyring_internal_snap_client_1.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 = (0, account_1.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, 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) {
-                    const wrapper = __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getOrCreateKeyringV2).call(this, snapId);
-                    for (const account of newAccounts) {
-                        wrapper.setAccount(account);
-                    }
-                    // 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_getOrCreateKeyringV2).call(this, snapId).createAccounts(options);
     }
     /**
      * Checks if a Snap ID is known from the keyring.
@@ -670,6 +558,10 @@ async function _SnapKeyring_withLock(callback) {
 }, _SnapKeyring_getOrCreateKeyringV2 = function _SnapKeyring_getOrCreateKeyringV2(snapId) {
     let keyring = __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId);
     if (!keyring) {
+        const client = new keyring_internal_snap_client_1.KeyringInternalSnapClient({
+            messenger: __classPrivateFieldGet(this, _SnapKeyring_messenger, "f"),
+            snapId,
+        });
         keyring = new SnapKeyringV2_1.SnapKeyringV2({
             snapId,
             onRegister: (id) => {
@@ -678,6 +570,30 @@ async function _SnapKeyring_withLock(callback) {
             onUnregister: (id) => {
                 __classPrivateFieldGet(this, _SnapKeyring_accountIndex, "f").delete(id);
             },
+            callbacks: {
+                createSnapAccount: async (options, internalOptions) => __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_createSnapAccount).call(this, snapId, client, options, internalOptions),
+                createSnapAccounts: async (options) => client.createAccounts(options),
+                deleteSnapAccount: async (id) => client.deleteAccount(id),
+                // This callback is only invoked via SnapKeyringV2.submitRequest,
+                // which is not called through SnapKeyring's public API today.
+                // SnapKeyring.submitRequest routes through #submitSnapRequest directly.
+                // Coverage is excluded until consumers interact with SnapKeyringV2 directly.
+                submitSnapRequest: /* istanbul ignore next */ async (request) => __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_submitSnapRequest).call(this, {
+                    origin: request.origin,
+                    snapId,
+                    account: __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f")
+                        .get(snapId)
+                        ?.lookupAccount(request.account) ??
+                        (0, util_1.throwError)(`Account '${request.account}' not found for snap '${snapId}'`),
+                    method: request.request.method,
+                    params: request.request.params,
+                    scope: request.scope,
+                    noPending: false,
+                }),
+                assertAccountCanBeUsed: async (account) => __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_assertAccountCanBeUsed).call(this, account),
+                saveState: async () => __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").saveState(),
+                withLock: async (callback) => __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_withLock).call(this, callback),
+            },
         });
         __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").set(snapId, keyring);
     }
@@ -693,7 +609,7 @@ async function _SnapKeyring_withLock(callback) {
  * @throws If the account cannot be used.
  */
 async function _SnapKeyring_assertAccountCanBeUsed(account) {
-    const address = normalizeAccountAddress(account);
+    const address = (0, util_1.normalizeAccountAddress)(account);
     // The `AnyAccountType.Account` generic account type is allowed only during
     // development, so we check whether it's allowed before continuing.
     if (!__classPrivateFieldGet(this, _SnapKeyring_isAnyAccountTypeAllowed, "f") &&
@@ -713,7 +629,7 @@ async function _SnapKeyring_assertAccountCanBeUsed(account) {
         throw new Error(`Account address '${address}' already exists`);
     }
 }, _SnapKeyring_getExistingAccount = function _SnapKeyring_getExistingAccount(snapId, account) {
-    const address = normalizeAccountAddress(account);
+    const address = (0, util_1.normalizeAccountAddress)(account);
     // Account 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
@@ -721,7 +637,7 @@ async function _SnapKeyring_assertAccountCanBeUsed(account) {
     const wrapper = __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId);
     const existing = wrapper?.lookupAccount(account.id);
     if (existing !== undefined &&
-        normalizeAccountAddress(existing) === address) {
+        (0, util_1.normalizeAccountAddress)(existing) === address) {
         return existing;
     }
     return undefined; // Not a known account.
@@ -759,7 +675,7 @@ async function _SnapKeyring_handleAccountCreated(snapId, message) {
     // first create the account data and then fire the "AccountCreated" event.
     // Potentially migrate the account.
     const account = (0, account_1.transformAccount)(newAccountFromEvent);
-    const address = normalizeAccountAddress(account);
+    const address = (0, util_1.normalizeAccountAddress)(account);
     if (__classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getExistingAccount).call(this, snapId, account)) {
         // If the account already exists, we skip it.
         return null;
@@ -879,7 +795,7 @@ async function _SnapKeyring_handleAccountDeleted(snapId, message) {
     if (account === undefined) {
         return null;
     }
-    await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").removeAccount(normalizeAccountAddress(account), snapId, async (accepted) => {
+    await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").removeAccount((0, util_1.normalizeAccountAddress)(account), snapId, async (accepted) => {
         if (accepted) {
             await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").saveState();
         }
@@ -1009,6 +925,53 @@ async function _SnapKeyring_handleAccountTransactionsUpdated(snapId, message) {
         throw new Error(`Unable to get account: unknown account ID: '${id}'`);
     }
     return { account, snapId };
+}, _SnapKeyring_createSnapAccount = 
+/**
+ * Core logic for the v1 `createAccount` flow. Called via the injected
+ * callback in each `SnapKeyringV2` wrapper.
+ *
+ * Handles the reserved 'metamask' field, correlation IDs, and internal
+ * options registration. The account is ultimately added to the wrapper
+ * via the `AccountCreated` event handler, not the return value.
+ *
+ * @param snapId - Snap ID.
+ * @param client - Snap client for this snap.
+ * @param options - Account creation options.
+ * @param internalOptions - Internal Snap keyring options.
+ * @returns The account object returned by the snap.
+ */
+async function _SnapKeyring_createSnapAccount(snapId, client, options, internalOptions) {
+    // The 'metamask' field is reserved, so we have to prevent use of it on
+    // the "normal options".
+    const reserved = 'metamask';
+    if ((0, utils_1.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 = (0, uuid_1.v4)();
+    // 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,
+            },
+        },
+    });
 }, _SnapKeyring_submitRequest = 
 /**
  * Submit a request to a Snap from an account address.
@@ -1158,22 +1121,14 @@ async function _SnapKeyring_handleAsyncResponse(redirect, snapId) {
 /**
  * Removes an account.
  *
+ * Delegates to the per-snap `SnapKeyringV2` wrapper which handles
+ * registry removal, index cleanup, and snap communication.
+ *
  * @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. removeAccount fires onUnregister to clean #accountIndex.
-    __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").get(snapId)?.removeAccount(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);
-    }
+    await __classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getOrCreateKeyringV2).call(this, snapId).deleteAccount(account.id);
 }, _SnapKeyring_resolveAddress = function _SnapKeyring_resolveAddress(address) {
     for (const wrapper of __classPrivateFieldGet(this, _SnapKeyring_snapKeyrings, "f").values()) {
         const account = wrapper.lookupByAddress(address);
@@ -1217,7 +1172,7 @@ async function _SnapKeyring_deleteAccount(snapId, account) {
         //
         // NOTE: We convert the address only for EVM accounts, see
         // `normalizeAccountAddress`.
-        address: normalizeAccountAddress(account),
+        address: (0, util_1.normalizeAccountAddress)(account),
         metadata: {
             name: '',
             importTime: 0,