@metamask/multichain-account-service 7.0.0 → 8.0.0

package/dist/MultichainAccountWallet.mjs

@@ -9,21 +9,23 @@ 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 _MultichainAccountWallet_instances, _MultichainAccountWallet_lock, _MultichainAccountWallet_id, _MultichainAccountWallet_providers, _MultichainAccountWallet_entropySource, _MultichainAccountWallet_accountGroups, _MultichainAccountWallet_messenger, _MultichainAccountWallet_log, _MultichainAccountWallet_initialized, _MultichainAccountWallet_status, _MultichainAccountWallet_withLock, _MultichainAccountWallet_createNonEvmAccounts, _MultichainAccountWallet_alignAccounts;
+var _MultichainAccountWallet_instances, _MultichainAccountWallet_lock, _MultichainAccountWallet_id, _MultichainAccountWallet_providers, _MultichainAccountWallet_entropySource, _MultichainAccountWallet_accountGroups, _MultichainAccountWallet_messenger, _MultichainAccountWallet_trace, _MultichainAccountWallet_log, _MultichainAccountWallet_initialized, _MultichainAccountWallet_status, _MultichainAccountWallet_withLock, _MultichainAccountWallet_getProviders, _MultichainAccountWallet_createAccountsRangeForProvider, _MultichainAccountWallet_createOrUpdateMultichainAccountGroup, _MultichainAccountWallet_buildGroupStateForRange, _MultichainAccountWallet_createMultichainAccountGroupsRange, _MultichainAccountWallet_alignAccountsForRange, _MultichainAccountWallet_createMultichainAccountGroups;
 import { AccountWalletType, getGroupIndexFromMultichainAccountGroupId, isMultichainAccountGroupId, toDefaultAccountGroupId, toMultichainAccountWalletId } from "@metamask/account-api";
 import { AccountCreationType } from "@metamask/keyring-api";
 import { assert } from "@metamask/utils";
 import { Mutex } from "async-mutex";
+import { toProviderDataTraces, traceFallback, TraceName } from "./analytics/index.mjs";
+import { reportError } from "./errors.mjs";
 import { createModuleLogger, ERROR_PREFIX, projectLogger as log, WARNING_PREFIX } from "./logger.mjs";
 import { MultichainAccountGroup } from "./MultichainAccountGroup.mjs";
 import { EvmAccountProvider } from "./providers/EvmAccountProvider.mjs";
-import { createSentryError } from "./utils.mjs";
+import { assertGroupIndexIsValid, assertGroupIndexRangeIsValid, toErrorMessage } from "./utils.mjs";
 /**
  * A multichain account wallet that holds multiple multichain accounts (one multichain account per
  * group index).
  */
 export class MultichainAccountWallet {
-    constructor({ providers, entropySource, messenger, }) {
+    constructor({ providers, entropySource, messenger, trace, }) {
         _MultichainAccountWallet_instances.add(this);
         _MultichainAccountWallet_lock.set(this, new Mutex());
         _MultichainAccountWallet_id.set(this, void 0);
@@ -31,6 +33,7 @@ export class MultichainAccountWallet {
         _MultichainAccountWallet_entropySource.set(this, void 0);
         _MultichainAccountWallet_accountGroups.set(this, void 0);
         _MultichainAccountWallet_messenger.set(this, void 0);
+        _MultichainAccountWallet_trace.set(this, void 0);
         _MultichainAccountWallet_log.set(this, void 0);
         _MultichainAccountWallet_initialized.set(this, false);
         _MultichainAccountWallet_status.set(this, void 0);
@@ -39,6 +42,7 @@ export class MultichainAccountWallet {
         __classPrivateFieldSet(this, _MultichainAccountWallet_entropySource, entropySource, "f");
         __classPrivateFieldSet(this, _MultichainAccountWallet_messenger, messenger, "f");
         __classPrivateFieldSet(this, _MultichainAccountWallet_accountGroups, new Map(), "f");
+        __classPrivateFieldSet(this, _MultichainAccountWallet_trace, trace ?? traceFallback, "f");
         __classPrivateFieldSet(this, _MultichainAccountWallet_log, createModuleLogger(log, `[${__classPrivateFieldGet(this, _MultichainAccountWallet_id, "f")}]`), "f");
         // Initial synchronization (don't emit events during initialization).
         __classPrivateFieldSet(this, _MultichainAccountWallet_status, 'uninitialized', "f");
@@ -165,83 +169,65 @@ export class MultichainAccountWallet {
      * @param options - Options to configure the account creation.
      * @param options.waitForAllProvidersToFinishCreatingAccounts - Whether to wait for all
      * account providers to finish creating their accounts before returning. If `false`, only
-     * the EVM provider will be awaited, while all other providers will create their accounts
-     * in the background. Defaults to `false`.
-     * @throws If any of the account providers fails to create their accounts and
-     * the `waitForAllProvidersToFinishCreatingAccounts` option is set to `true`. If `false`,
-     * errors from non-EVM providers will be logged but ignored, and only errors from the
-     * EVM provider will be thrown.
+     * the EVM provider is used and non-EVM account creation is deferred via
+     * {@link MultichainAccountWallet.alignAccountsOf}. Defaults to `false`.
+     * @throws If groupIndex is greater than the next available group index.
+     * @throws If any account provider fails to create accounts.
      * @returns The multichain account group for this group index.
      */
-    async createMultichainAccountGroup(groupIndex, options = { waitForAllProvidersToFinishCreatingAccounts: false }) {
-        return await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_withLock).call(this, 'in-progress:create-accounts', async () => {
-            const nextGroupIndex = this.getNextGroupIndex();
-            if (groupIndex > nextGroupIndex) {
-                throw new Error(`You cannot use a group index that is higher than the next available one: expected <=${nextGroupIndex}, got ${groupIndex}`);
-            }
-            let group = this.getMultichainAccountGroup(groupIndex);
-            if (group) {
-                __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Trying to re-create existing group: [${group.id}] (idempotent)`);
-                return group;
-            }
-            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Creating new group for index ${groupIndex}...`);
-            // Extract the EVM provider from the list of providers.
-            // We always await EVM account creation first.
-            const [evmProvider, ...otherProviders] = __classPrivateFieldGet(this, _MultichainAccountWallet_providers, "f");
-            assert(evmProvider instanceof EvmAccountProvider, 'EVM account provider must be first');
-            const evmAccounts = await evmProvider
-                .createAccounts({
-                type: AccountCreationType.Bip44DeriveIndex,
-                entropySource: __classPrivateFieldGet(this, _MultichainAccountWallet_entropySource, "f"),
-                groupIndex,
-            })
-                .then((accounts) => accounts.map((account) => account.id))
-                .catch((error) => {
-                const errorMessage = `Unable to create some accounts for group index: ${groupIndex} with provider "${evmProvider.getName()}". Error: ${error.message}`;
-                console.warn(errorMessage);
-                __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `${ERROR_PREFIX} ${errorMessage}:`, error);
-                const sentryError = createSentryError(`Unable to create account with provider "${evmProvider.getName()}"`, error, {
-                    groupIndex,
-                    provider: evmProvider.getName(),
-                });
-                __classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f").captureException?.(sentryError);
-                throw error;
-            });
-            group = new MultichainAccountGroup({
-                wallet: this,
-                providers: __classPrivateFieldGet(this, _MultichainAccountWallet_providers, "f"),
+    async createMultichainAccountGroup(groupIndex, options = {}) {
+        // Use this to avoid having it as `boolean | undefined`.
+        const waitForAllProvidersToFinishCreatingAccounts = options.waitForAllProvidersToFinishCreatingAccounts ?? false;
+        return await __classPrivateFieldGet(this, _MultichainAccountWallet_trace, "f").call(this, {
+            name: TraceName.WalletCreateMultichainAccountGroup,
+            data: {
                 groupIndex,
-                messenger: __classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f"),
-            });
-            group.init({ [evmProvider.getName()]: evmAccounts });
-            // We then create accounts with other providers (some being throttled if configured).
-            // Depending on the options, we either await all providers or run them in background.
-            if (options?.waitForAllProvidersToFinishCreatingAccounts) {
-                await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_createNonEvmAccounts).call(this, {
-                    groupIndex,
-                    providers: otherProviders,
-                    awaitAll: true,
-                    group,
-                });
-            }
-            else {
-                // eslint-disable-next-line no-void
-                void __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_createNonEvmAccounts).call(this, {
-                    groupIndex,
-                    providers: otherProviders,
-                    awaitAll: false,
-                    group,
-                });
-            }
-            // Register the account(s) to our internal map.
-            __classPrivateFieldGet(this, _MultichainAccountWallet_accountGroups, "f").set(groupIndex, group);
-            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `New group created: [${group.id}]`);
-            if (__classPrivateFieldGet(this, _MultichainAccountWallet_initialized, "f")) {
-                __classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f").publish('MultichainAccountService:multichainAccountGroupCreated', group);
+                waitForAllProvidersToFinishCreatingAccounts,
+            },
+        }, async () => {
+            assertGroupIndexIsValid(groupIndex, this.getNextGroupIndex());
+            // If the group already exists, return it.
+            const existingGroup = this.getMultichainAccountGroup(groupIndex);
+            if (existingGroup) {
+                __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Trying to re-create existing group: [${existingGroup.id}] (idempotent)`);
+                return existingGroup;
             }
+            // Create a single group with a range of 1 (so we can reuse the batch creation logic) for the
+            // given group index.
+            const groups = await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_createMultichainAccountGroups).call(this, { from: groupIndex, to: groupIndex }, options);
+            const group = groups[0];
+            assert(group, `Expected group at index ${groupIndex} to exist`);
             return group;
         });
     }
+    /**
+     * Creates multiple multichain account groups up to maxGroupIndex.
+     *
+     * NOTE: This operation WILL lock the wallet's mutex.
+     *
+     * @param range - The range of group indices to create.
+     * @param range.from - Starting group index to create (inclusive) (defaults to 0).
+     * @param range.to - Maximum group index to create (inclusive).
+     * @param options - Options to configure the account creation.
+     * @param options.waitForAllProvidersToFinishCreatingAccounts - Whether to wait for all
+     * account providers to finish creating their accounts before returning. If `false`, only
+     * the EVM provider is used and non-EVM account creation is deferred via
+     * {@link MultichainAccountWallet.alignAccounts}. Defaults to false.
+     * @throws If range is invalid (e.g. from is greater than to, from or to is negative, etc.).
+     * @returns Array of created multichain account groups.
+     */
+    async createMultichainAccountGroups({ from = 0, to }, options = {}) {
+        // Use this to avoid having it as `boolean | undefined`.
+        const waitForAllProvidersToFinishCreatingAccounts = options.waitForAllProvidersToFinishCreatingAccounts ?? false;
+        return await __classPrivateFieldGet(this, _MultichainAccountWallet_trace, "f").call(this, {
+            name: TraceName.WalletCreateMultichainAccountGroups,
+            data: {
+                from,
+                to,
+                waitForAllProvidersToFinishCreatingAccounts,
+            },
+        }, async () => await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_createMultichainAccountGroups).call(this, { from, to }, options));
+    }
     /**
      * Creates the next multichain account group.
      *
@@ -259,9 +245,14 @@ export class MultichainAccountWallet {
      * NOTE: This operation WILL lock the wallet's mutex.
      */
     async alignAccounts() {
-        await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_withLock).call(this, 'in-progress:alignment', async () => {
-            await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_alignAccounts).call(this);
-        });
+        const nextGroupIndex = this.getNextGroupIndex();
+        if (nextGroupIndex > 0) {
+            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, 'Aligning accounts...');
+            const from = 0;
+            const to = nextGroupIndex - 1;
+            await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_withLock).call(this, 'in-progress:alignment', async () => await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_alignAccountsForRange).call(this, { from, to }, __classPrivateFieldGet(this, _MultichainAccountWallet_providers, "f")));
+            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, 'Aligned!');
+        }
     }
     /**
      * Align a specific multichain account group.
@@ -271,12 +262,12 @@ export class MultichainAccountWallet {
      * @param groupIndex - The group index to align.
      */
     async alignAccountsOf(groupIndex) {
-        await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_withLock).call(this, 'in-progress:alignment', async () => {
-            const group = this.getMultichainAccountGroup(groupIndex);
-            if (group) {
-                await group.alignAccounts();
-            }
-        });
+        const group = this.getMultichainAccountGroup(groupIndex);
+        if (group) {
+            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Aligning accounts for group "${group.id}"...`);
+            await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_withLock).call(this, 'in-progress:alignment', async () => await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_alignAccountsForRange).call(this, { from: groupIndex, to: groupIndex }, __classPrivateFieldGet(this, _MultichainAccountWallet_providers, "f"), { trace: { data: { groupIndex } } }));
+            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Aligned accounts for group "${group.id}"!`);
+        }
     }
     /**
      * Discover and create accounts for all providers.
@@ -313,13 +304,11 @@ export class MultichainAccountWallet {
                     }
                     catch (error) {
                         context.stopped = true;
-                        console.error(error);
-                        log(message(`failed (with: "${error.message}")`, targetGroupIndex), error);
-                        const sentryError = createSentryError('Unable to discover accounts', error, {
+                        log(message(`failed (with: "${toErrorMessage(error)}")`, targetGroupIndex));
+                        reportError(__classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f"), `Unable to discover accounts with provider "${providerName}"`, error, {
                             provider: providerName,
                             groupIndex: targetGroupIndex,
                         });
-                        __classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f").captureException?.(sentryError);
                         break;
                     }
                     if (!accounts.length) {
@@ -359,12 +348,21 @@ export class MultichainAccountWallet {
             }
             // Align missing accounts from group. This is required to create missing account from non-discovered
             // indexes for some providers.
-            await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_alignAccounts).call(this);
+            const nextGroupIndex = this.getNextGroupIndex();
+            if (nextGroupIndex > 0) {
+                await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_alignAccountsForRange).call(this, { from: 0, to: nextGroupIndex - 1 }, __classPrivateFieldGet(this, _MultichainAccountWallet_providers, "f"), {
+                    trace: {
+                        data: {
+                            discovery: true, // Tag to identify discovery-alignment traces in analytics.
+                        },
+                    },
+                });
+            }
             return providerContexts.flatMap((context) => context.accounts);
         });
     }
 }
-_MultichainAccountWallet_lock = new WeakMap(), _MultichainAccountWallet_id = new WeakMap(), _MultichainAccountWallet_providers = new WeakMap(), _MultichainAccountWallet_entropySource = new WeakMap(), _MultichainAccountWallet_accountGroups = new WeakMap(), _MultichainAccountWallet_messenger = new WeakMap(), _MultichainAccountWallet_log = new WeakMap(), _MultichainAccountWallet_initialized = new WeakMap(), _MultichainAccountWallet_status = new WeakMap(), _MultichainAccountWallet_instances = new WeakSet(), _MultichainAccountWallet_withLock = 
+_MultichainAccountWallet_lock = new WeakMap(), _MultichainAccountWallet_id = new WeakMap(), _MultichainAccountWallet_providers = new WeakMap(), _MultichainAccountWallet_entropySource = new WeakMap(), _MultichainAccountWallet_accountGroups = new WeakMap(), _MultichainAccountWallet_messenger = new WeakMap(), _MultichainAccountWallet_trace = new WeakMap(), _MultichainAccountWallet_log = new WeakMap(), _MultichainAccountWallet_initialized = new WeakMap(), _MultichainAccountWallet_status = new WeakMap(), _MultichainAccountWallet_instances = new WeakSet(), _MultichainAccountWallet_withLock = 
 /**
  * Set the wallet status and run the associated operation callback.
  *
@@ -387,94 +385,234 @@ async function _MultichainAccountWallet_withLock(status, operation) {
         release();
         __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Releasing wallet lock (was "${status}")`);
     }
-}, _MultichainAccountWallet_createNonEvmAccounts = 
+}, _MultichainAccountWallet_getProviders = function _MultichainAccountWallet_getProviders() {
+    const [evmProvider, ...otherProviders] = __classPrivateFieldGet(this, _MultichainAccountWallet_providers, "f");
+    assert(evmProvider instanceof EvmAccountProvider, 'EVM account provider must be first');
+    return [evmProvider, ...otherProviders];
+}, _MultichainAccountWallet_createAccountsRangeForProvider = 
 /**
- * Create accounts with non‑EVM providers. Optional throttling is managed by each provider internally.
- * When awaitAll is true, waits for all providers and throws if any failed.
- * When false, starts work in background and logs errors without throwing.
+ * Create accounts for a given provider and group index range.
  *
- * @param options - Method options.
- * @param options.groupIndex - The group index to create accounts for.
- * @param options.providers - The non‑EVM account providers.
- * @param options.awaitAll - Whether to wait for all providers to finish.
- * @param options.group - The group object pertaining to the group index to create accounts for.
- * @throws If awaitAll is true and any provider fails to create accounts.
- * @returns A promise that resolves when done (if awaitAll is true) or immediately (if false).
+ * @param provider - The provider to create accounts for.
+ * @param from - The starting group index (inclusive).
+ * @param to - The ending group index (inclusive).
+ * @returns The created accounts.
  */
-async function _MultichainAccountWallet_createNonEvmAccounts({ groupIndex, providers, awaitAll, group, }) {
-    if (awaitAll) {
-        const tasks = providers.map((provider) => provider
-            .createAccounts({
-            type: AccountCreationType.Bip44DeriveIndex,
+async function _MultichainAccountWallet_createAccountsRangeForProvider(provider, from, to) {
+    const isBatching = to > from;
+    try {
+        return await provider.createAccounts({
+            type: AccountCreationType.Bip44DeriveIndexRange,
             entropySource: __classPrivateFieldGet(this, _MultichainAccountWallet_entropySource, "f"),
-            groupIndex,
-        })
-            .catch((error) => {
-            const sentryError = createSentryError(`Unable to create account with provider "${provider.getName()}"`, error, {
-                groupIndex,
-                provider: provider.getName(),
-            });
-            __classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f").captureException?.(sentryError);
-            throw error;
-        }));
-        const results = await Promise.allSettled(tasks);
-        const providerFailures = results.reduce((acc, result, idx) => {
-            let newAcc = acc;
-            if (result.status === 'rejected') {
-                newAcc += `\n- ${providers[idx].getName()}: ${result.reason.message}`;
-            }
-            return newAcc;
-        }, '');
-        if (providerFailures.length) {
-            // We warn there's failures on some providers and thus misalignment, but we still create the group
-            const message = `Unable to create some accounts for group index: ${groupIndex}. Providers threw the following errors:${providerFailures}`;
-            console.warn(message);
-            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `${WARNING_PREFIX} ${message}`);
-        }
-        // No need to fetch the accounts list from the AccountsController since we already have the account IDs to be used in the controller
-        const groupState = results.reduce((state, result, idx) => {
-            if (result.status === 'fulfilled') {
-                state[providers[idx].getName()] = result.value.map((account) => account.id);
-            }
-            return state;
-        }, {});
+            range: {
+                from,
+                to,
+            },
+        });
+    }
+    catch (error) {
+        reportError(__classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f"), `Unable to create ${isBatching ? 'some accounts (batch)' : 'some accounts'} with provider "${provider.getName()}"`, error, {
+            range: { from, to },
+            provider: provider.getName(),
+            isBatching,
+        });
+        throw error;
+    }
+}, _MultichainAccountWallet_createOrUpdateMultichainAccountGroup = function _MultichainAccountWallet_createOrUpdateMultichainAccountGroup(groupIndex, groupState) {
+    let group = __classPrivateFieldGet(this, _MultichainAccountWallet_accountGroups, "f").get(groupIndex);
+    if (group) {
+        // NOTE: This will publish an update event automatically.
         group.update(groupState);
+        __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Group updated: [${group.id}]`);
     }
     else {
-        // Create account with other providers in the background
-        providers.forEach((provider) => {
-            provider
-                .createAccounts({
-                type: AccountCreationType.Bip44DeriveIndex,
-                entropySource: __classPrivateFieldGet(this, _MultichainAccountWallet_entropySource, "f"),
-                groupIndex,
-            })
-                .then((accounts) => {
-                const accountIds = accounts.map((account) => account.id);
-                group.update({ [provider.getName()]: accountIds });
-                return group;
-            })
-                .catch((error) => {
-                // Log errors from background providers but don't fail the operation
-                const errorMessage = `Unable to create some accounts for group index: ${groupIndex} with provider "${provider.getName()}". Error: ${error.message}`;
-                console.warn(errorMessage);
-                __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `${WARNING_PREFIX} ${errorMessage}:`, error);
-                const sentryError = createSentryError(`Unable to create account with provider "${provider.getName()}"`, error, {
-                    groupIndex,
-                    provider: provider.getName(),
-                });
-                __classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f").captureException?.(sentryError);
-            });
+        group = new MultichainAccountGroup({
+            wallet: this,
+            providers: __classPrivateFieldGet(this, _MultichainAccountWallet_providers, "f"),
+            groupIndex,
+            messenger: __classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f"),
         });
+        group.init(groupState);
+        __classPrivateFieldGet(this, _MultichainAccountWallet_accountGroups, "f").set(groupIndex, group);
+        __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Group created: [${group.id}]`);
+        if (__classPrivateFieldGet(this, _MultichainAccountWallet_initialized, "f")) {
+            __classPrivateFieldGet(this, _MultichainAccountWallet_messenger, "f").publish('MultichainAccountService:multichainAccountGroupCreated', group);
+        }
     }
-}, _MultichainAccountWallet_alignAccounts = 
+    return group;
+}, _MultichainAccountWallet_buildGroupStateForRange = 
 /**
- * Align all multichain account groups.
+ * Build group state for a range of group indices by calling all providers in parallel.
+ *
+ * This is a non-locking shared core used by both creation and alignment paths.
  *
- * NOTE: This operation WILL NOT lock the wallet's mutex.
+ * @param from - Starting group index (inclusive).
+ * @param to - Ending group index (inclusive).
+ * @param providers - The providers to create accounts for.
+ * @returns The collected group state and any provider failure messages.
  */
-async function _MultichainAccountWallet_alignAccounts() {
-    const groups = this.getMultichainAccountGroups();
-    await Promise.all(groups.map((group) => group.alignAccounts()));
+async function _MultichainAccountWallet_buildGroupStateForRange(from, to, providers) {
+    const groupStateByGroupIndex = new Map();
+    const results = await Promise.allSettled(providers.map(async (provider) => {
+        const providerName = provider.getName();
+        const accounts = await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_createAccountsRangeForProvider).call(this, provider, from, to);
+        accounts.forEach((account) => {
+            const { groupIndex } = account.options.entropy;
+            let groupState = groupStateByGroupIndex.get(groupIndex);
+            if (!groupState) {
+                groupState = {};
+                groupStateByGroupIndex.set(groupIndex, groupState);
+            }
+            if (!groupState[providerName]) {
+                groupState[providerName] = [];
+            }
+            groupState[providerName].push(account.id);
+        });
+    }));
+    const failures = providers.reduce((messages, provider, index) => {
+        const result = results[index];
+        if (result?.status === 'rejected') {
+            messages.push(`[${provider.getName()}] ${toErrorMessage(result.reason)}`);
+        }
+        return messages;
+    }, []);
+    return { groupStateByGroupIndex, failures };
+}, _MultichainAccountWallet_createMultichainAccountGroupsRange = 
+/**
+ * Internal method to create a range of multichain account groups.
+ *
+ * This method acquires the wallet lock internally and creates accounts for all
+ * given providers synchronously. Callers decide which providers to pass.
+ *
+ * @param range - The range of group indices to create.
+ * @param range.from - Starting group index to create (inclusive).
+ * @param range.to - Maximum group index to create (inclusive).
+ * @param providers - The providers to create accounts for.
+ * @returns Array of created multichain account groups.
+ */
+async function _MultichainAccountWallet_createMultichainAccountGroupsRange({ from: rangeFrom, to }, providers) {
+    return await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_withLock).call(this, 'in-progress:create-accounts', async () => {
+        const groups = [];
+        // Get existing groups (fromGroupIndex to nextGroupIndex - 1).
+        let from = rangeFrom;
+        for (; from <= to; from++) {
+            const group = this.getMultichainAccountGroup(from);
+            if (group) {
+                groups.push(group);
+            }
+            else {
+                break; // Assuming we have no gap, if the group does not exist, we can stop and create the remaining ones.
+            }
+        }
+        // Create new groups now.
+        if (from <= to) {
+            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Creating groups from index ${from} to ${to}...`);
+            const { groupStateByGroupIndex, failures } = await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_buildGroupStateForRange).call(this, from, to, providers);
+            // Check for provider failures — always treated as hard errors.
+            if (failures.length) {
+                throw new Error(failures.reduce((message, failure) => `${message}\n- ${failure}`, 'Unable to create some accounts. Providers threw the following errors:'));
+            }
+            // Create or update groups from the collected state.
+            for (let groupIndex = from; groupIndex <= to; groupIndex++) {
+                const groupState = groupStateByGroupIndex.get(groupIndex);
+                if (groupState) {
+                    const group = __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_createOrUpdateMultichainAccountGroup).call(this, groupIndex, groupState);
+                    groups.push(group);
+                }
+                else {
+                    __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `${WARNING_PREFIX} Failed to create new group for group index: ${groupIndex} because no accounts were created for it`);
+                }
+            }
+        }
+        return groups;
+    });
+}, _MultichainAccountWallet_alignAccountsForRange = 
+/**
+ * Align accounts for a range of group indices (non-locking).
+ *
+ * Calls all providers in parallel via the batch API. Provider failures are
+ * logged as warnings (best-effort); no error is thrown.
+ *
+ * @param range - The range of group indices to align.
+ * @param range.from - Starting group index (inclusive).
+ * @param range.to - Ending group index (inclusive).
+ * @param providers - The providers to align accounts for.
+ * @param options - Options.
+ * @param options.trace - Trace options.
+ * @param options.trace.data - Optional trace data.
+ */
+async function _MultichainAccountWallet_alignAccountsForRange({ from, to }, providers, options = {}) {
+    await __classPrivateFieldGet(this, _MultichainAccountWallet_trace, "f").call(this, {
+        name: TraceName.WalletAlignment,
+        data: {
+            from,
+            to,
+            ...toProviderDataTraces(providers),
+            ...options.trace?.data,
+        },
+    }, async () => {
+        const { groupStateByGroupIndex, failures } = await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_buildGroupStateForRange).call(this, from, to, providers);
+        if (failures.length) {
+            const error = failures.reduce((message, failure) => `${message}\n- ${failure}`, 'Unable to align some accounts. Providers threw the following errors:');
+            console.warn(error);
+            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `${WARNING_PREFIX} ${error}`);
+        }
+        for (let groupIndex = from; groupIndex <= to; groupIndex++) {
+            const groupState = groupStateByGroupIndex.get(groupIndex);
+            if (groupState) {
+                __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_createOrUpdateMultichainAccountGroup).call(this, groupIndex, groupState);
+            }
+        }
+    });
+}, _MultichainAccountWallet_createMultichainAccountGroups = 
+/**
+ * Creates multiple multichain account groups up to maxGroupIndex.
+ *
+ * NOTE: This operation WILL lock the wallet's mutex.
+ *
+ * @param range - The range of group indices to create.
+ * @param range.from - Starting group index to create (inclusive).
+ * @param range.to - Maximum group index to create (inclusive).
+ * @param options - Options to configure the account creation.
+ * @param options.waitForAllProvidersToFinishCreatingAccounts - Whether to wait for all
+ * account providers to finish creating their accounts before returning. If `false`, only
+ * the EVM provider is used and non-EVM account creation is deferred via
+ * {@link MultichainAccountWallet.alignAccounts}. Defaults to false.
+ * @throws If range is invalid (e.g. from is greater than to, from or to is negative, etc.).
+ * @returns Array of created multichain account groups.
+ */
+async function _MultichainAccountWallet_createMultichainAccountGroups({ from, to }, options) {
+    assertGroupIndexRangeIsValid({ from, to });
+    assertGroupIndexIsValid(from, this.getNextGroupIndex());
+    const waitForAllProvidersToFinishCreatingAccounts = options.waitForAllProvidersToFinishCreatingAccounts ?? false;
+    const [evmProvider, ...otherProviders] = __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_getProviders).call(this);
+    const providers = waitForAllProvidersToFinishCreatingAccounts
+        ? __classPrivateFieldGet(this, _MultichainAccountWallet_providers, "f")
+        : [evmProvider];
+    const groups = await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_createMultichainAccountGroupsRange).call(this, { from, to }, providers);
+    // We need to run a post-alignment since non-EVM accounts have not
+    // been created yet.
+    if (!waitForAllProvidersToFinishCreatingAccounts) {
+        const alignOtherAccounts = async () => {
+            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `Aligning accounts... (post)`);
+            await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_withLock).call(this, 'in-progress:alignment', async () => {
+                await __classPrivateFieldGet(this, _MultichainAccountWallet_instances, "m", _MultichainAccountWallet_alignAccountsForRange).call(this, { from, to }, otherProviders, {
+                    trace: {
+                        data: {
+                            post: true, // Tag to identify post-alignment traces in analytics.
+                        },
+                    },
+                });
+            });
+            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, 'Aligned accounts! (post)');
+        };
+        // eslint-disable-next-line no-void
+        void alignOtherAccounts().catch((error) => {
+            const errorMessage = `Unable to align non-EVM accounts from group index ${from} to ${to}`;
+            __classPrivateFieldGet(this, _MultichainAccountWallet_log, "f").call(this, `${ERROR_PREFIX} ${errorMessage}: ${toErrorMessage(error)} (post)`);
+            console.error(errorMessage, error);
+        });
+    }
+    return groups;
 };
 //# sourceMappingURL=MultichainAccountWallet.mjs.map