@metamask-previews/eth-snap-keyring 18.0.2-feb98c5 → 19.0.0-fd40efd

package/CHANGELOG.md

@@ -7,11 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [19.0.0]
+
+### Added
+
+- Add `SnapKeyring.createAccounts` method ([#448](https://github.com/MetaMask/accounts/pull/448))
+  - This method can be used to create one or more accounts using the new keyring v2 account creation typed options.
+  - Generic accounts will be filtered out if they are not allowed by the keyring configuration.
+
 ### Changed
 
-- Bump `@metamask/snaps-controllers` from `^14.0.1` to `^17.2.0` ([#422](https://github.com/MetaMask/accounts/pull/422))
-- Bump `@metamask/snaps-sdk` from `^9.0.0` to `^10.3.0` ([#422](https://github.com/MetaMask/accounts/pull/422))
-- Bump `@metamask/snaps-utils` from `^11.0.0` to `^11.7.0` ([#422](https://github.com/MetaMask/accounts/pull/422))
+- **BREAKING:** Bump `@metamask/keyring-internal-api` from `^9.1.2` to `^10.0.0` ([#460](https://github.com/MetaMask/accounts/pull/460))
+- **BREAKING:** Bump `@metamask/keyring-internal-snap-client` from `^8.0.2` to `^9.0.0` ([#460](https://github.com/MetaMask/accounts/pull/460))
+- Bump `@metamask/keyring-api` from `^21.2.0` to `^21.4.0` ([#460](https://github.com/MetaMask/accounts/pull/460))
+- Bump `@metamask/snaps-controllers` from `^14.0.1` to `^18.0.0` ([#422](https://github.com/MetaMask/accounts/pull/422)), ([#461](https://github.com/MetaMask/accounts/pull/461))
+- Bump `@metamask/snaps-sdk` from `^9.0.0` to `^10.4.0` ([#422](https://github.com/MetaMask/accounts/pull/422)), ([#461](https://github.com/MetaMask/accounts/pull/461))
+- Bump `@metamask/snaps-utils` from `^11.0.0` to `^12.1.0` ([#422](https://github.com/MetaMask/accounts/pull/422)), ([#424](https://github.com/MetaMask/accounts/pull/424)), ([#461](https://github.com/MetaMask/accounts/pull/461))
 
 ### Removed
 
@@ -621,7 +632,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Initial release.
 
-[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@18.0.2...HEAD
+[Unreleased]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@19.0.0...HEAD
+[19.0.0]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@18.0.2...@metamask/eth-snap-keyring@19.0.0
 [18.0.2]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@18.0.1...@metamask/eth-snap-keyring@18.0.2
 [18.0.1]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@18.0.0...@metamask/eth-snap-keyring@18.0.1
 [18.0.0]: https://github.com/MetaMask/accounts/compare/@metamask/eth-snap-keyring@17.3.0...@metamask/eth-snap-keyring@18.0.0

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_accounts, _SnapKeyring_selectedAccounts, _SnapKeyring_requests, _SnapKeyring_options, _SnapKeyring_callbacks, _SnapKeyring_isAnyAccountTypeAllowed, _SnapKeyring_isMinimumPlatformVersion, _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_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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnapKeyring = exports.SNAP_KEYRING_TYPE = void 0;
 const tx_1 = require("@ethereumjs/tx");
@@ -22,6 +22,7 @@ const keyring_snap_sdk_1 = require("@metamask/keyring-snap-sdk");
 const keyring_utils_1 = require("@metamask/keyring-utils");
 const superstruct_1 = require("@metamask/superstruct");
 const utils_1 = require("@metamask/utils");
+const async_mutex_1 = require("async-mutex");
 const uuid_1 = require("uuid");
 const account_1 = require("./account.cjs");
 const DeferredPromise_1 = require("./DeferredPromise.cjs");
@@ -102,6 +103,11 @@ 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 keyring_internal_snap_client_1.KeyringInternalSnapClient({ messenger }), "f");
@@ -111,6 +117,7 @@ class SnapKeyring {
         __classPrivateFieldSet(this, _SnapKeyring_callbacks, callbacks, "f");
         __classPrivateFieldSet(this, _SnapKeyring_isAnyAccountTypeAllowed, isAnyAccountTypeAllowed, "f");
         __classPrivateFieldSet(this, _SnapKeyring_selectedAccounts, new Map(), "f");
+        __classPrivateFieldSet(this, _SnapKeyring_lock, new async_mutex_1.Mutex(), "f");
     }
     /**
      * Handle a message from a Snap.
@@ -260,6 +267,84 @@ class SnapKeyring {
             },
         });
     }
+    /**
+     * 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.
+     *
+     * @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, 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;
+            }
+        });
+    }
     /**
      * Checks if a Snap ID is known from the keyring.
      *
@@ -540,8 +625,57 @@ class SnapKeyring {
     }
 }
 exports.SnapKeyring = SnapKeyring;
-_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_instances = new WeakSet(), _SnapKeyring_isMinimumPlatformVersion = function _SnapKeyring_isMinimumPlatformVersion(snapId, platformVersion) {
+_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_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) {
+    const address = 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") &&
+        account.type === keyring_api_1.AnyAccountType.Account) {
+        throw new Error(`Cannot create generic account '${account.id}'`);
+    }
+    // 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)) {
+        throw new Error(`Account '${account.id}' already exists`);
+    }
+    // The UI still uses the account address to identify accounts, so we need
+    // to block the creation of duplicate accounts for now to prevent accounts
+    // from being overwritten.
+    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
@@ -577,32 +711,12 @@ async function _SnapKeyring_handleAccountCreated(snapId, message) {
     // Potentially migrate the account.
     const account = (0, account_1.transformAccount)(newAccountFromEvent);
     const address = 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") &&
-        account.type === keyring_api_1.AnyAccountType.Account) {
-        throw new Error(`Cannot create generic account '${account.id}'`);
-    }
-    // This is idempotent, so we need to check whether the account already exists
-    // and that the right Snap is trying to "create" it again.
-    const accountEntry = __classPrivateFieldGet(this, _SnapKeyring_accounts, "f").get(snapId, account.id);
-    if (accountEntry &&
-        normalizeAccountAddress(accountEntry.account) === address) {
-        // NOTE: We are not checking account object equality here. If a Snap
-        // re-send this event with different account data, we will ignore it.
+    if (__classPrivateFieldGet(this, _SnapKeyring_instances, "m", _SnapKeyring_getExistingAccount).call(this, snapId, account)) {
+        // If the account already exists, we skip it.
         return null;
     }
-    // The UI still uses the account address to identify accounts, so we need
-    // to block the creation of duplicate accounts for now to prevent accounts
-    // from being overwritten.
-    if (await __classPrivateFieldGet(this, _SnapKeyring_callbacks, "f").addressExists(address)) {
-        throw new Error(`Account address '${address}' already exists`);
-    }
-    // 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)) {
-        throw new Error(`Account '${account.id}' already exists`);
-    }
+    // 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