@metamask-previews/assets-controllers 106.0.0-preview-beaf51362 → 106.0.0-preview-55fbbe681

package/CHANGELOG.md

@@ -18,14 +18,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `MultichainAssetsController`: after `addAssets`, re-fetch the Snap `listAccountAssets` list for Stellar classic (`asset:`) ids and clear `stellarClassicTrustlineInactiveAssetIds` when the keyring already reports the same CAIP-19 id (e.g. hide token then re-add while trustline is still active) ([#TODO](https://github.com/MetaMask/core/pull/TODO))
 - `MultichainBalancesController`: when `MultichainAssetsController:accountAssetListUpdated` fires while the vault is locked, balance fetches are skipped and were never retried after unlock, leaving multichain token lists empty despite assets in state; subscribe to `KeyringController:stateChange` and refetch balances for snap-backed accounts that still have no cached balances after unlock. ([#TODO](https://github.com/MetaMask/core/pull/TODO))
 
-### Changed
-
-- Bump `@metamask/account-tree-controller` from `^7.2.0` to `^7.3.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
-- Bump `@metamask/keyring-controller` from `^25.4.0` to `^25.5.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
-- Bump `@metamask/multichain-account-service` from `^8.0.1` to `^9.0.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
-- Bump `@metamask/permission-controller` from `^13.0.0` to `^13.1.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
-- Bump `@metamask/transaction-controller` from `^65.1.0` to `^65.2.0` ([#8722](https://github.com/MetaMask/core/pull/8722))
-
 ## [106.0.0]
 
 ### Added

package/dist/MultichainAssetsController/MultichainAssetsController.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 _MultichainAssetsController_instances, _MultichainAssetsController_snaps, _MultichainAssetsController_controllerOperationMutex, _MultichainAssetsController_backfillStellarTrustlineInactiveIfNeeded, _MultichainAssetsController_handleAccountAssetListUpdatedEvent, _MultichainAssetsController_handleOnAccountAddedEvent, _MultichainAssetsController_isAssetIgnored, _MultichainAssetsController_reconcileStellarClassicTrustlineInactiveWithSnap, _MultichainAssetsController_removeStellarTrustlineInactiveAssetIds, _MultichainAssetsController_handleAccountAssetListUpdated, _MultichainAssetsController_isNonEvmAccount, _MultichainAssetsController_handleOnAccountAdded, _MultichainAssetsController_handleOnAccountRemovedEvent, _MultichainAssetsController_refreshAssetsMetadata, _MultichainAssetsController_updateAssetsMetadata, _MultichainAssetsController_getAssetSnaps, _MultichainAssetsController_getAssetSnapFor, _MultichainAssetsController_getAllSnaps, _MultichainAssetsController_getSnapsPermissions, _MultichainAssetsController_getAssetsMetadataFrom, _MultichainAssetsController_groupTokenAssetsByChain, _MultichainAssetsController_runBatchedBulkTokenScans, _MultichainAssetsController_filterBlockaidSpamTokensOnAdd, _MultichainAssetsController_findMaliciousTokensAmong, _MultichainAssetsController_getAssetsList, _MultichainAssetsController_getClient, _MultichainAssetsController_assertControllerMutexIsLocked, _MultichainAssetsController_withControllerLock;
+var _MultichainAssetsController_instances, _MultichainAssetsController_snaps, _MultichainAssetsController_controllerOperationMutex, _MultichainAssetsController_handleAccountAssetListUpdatedEvent, _MultichainAssetsController_handleOnAccountAddedEvent, _MultichainAssetsController_isAssetIgnored, _MultichainAssetsController_handleAccountAssetListUpdated, _MultichainAssetsController_isNonEvmAccount, _MultichainAssetsController_handleOnAccountAdded, _MultichainAssetsController_bootstrapStellarTrustlineExtras, _MultichainAssetsController_handleAccountBalancesUpdatedForEnrichment, _MultichainAssetsController_enrichStellarAccountAssetInfo, _MultichainAssetsController_getAccountAssetInfoFromSnap, _MultichainAssetsController_handleOnAccountRemovedEvent, _MultichainAssetsController_refreshAssetsMetadata, _MultichainAssetsController_updateAssetsMetadata, _MultichainAssetsController_getAssetSnaps, _MultichainAssetsController_getAssetSnapFor, _MultichainAssetsController_getAllSnaps, _MultichainAssetsController_getSnapsPermissions, _MultichainAssetsController_getAssetsMetadataFrom, _MultichainAssetsController_groupTokenAssetsByChain, _MultichainAssetsController_runBatchedBulkTokenScans, _MultichainAssetsController_filterBlockaidSpamTokensOnAdd, _MultichainAssetsController_findMaliciousTokensAmong, _MultichainAssetsController_getAssetsList, _MultichainAssetsController_getClient, _MultichainAssetsController_assertControllerMutexIsLocked, _MultichainAssetsController_withControllerLock;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultichainAssetsController = exports.getDefaultMultichainAssetsControllerState = void 0;
 const keyring_api_1 = require("@metamask/keyring-api");
@@ -20,6 +20,7 @@ const polling_controller_1 = require("@metamask/polling-controller");
 const snaps_utils_1 = require("@metamask/snaps-utils");
 const utils_1 = require("@metamask/utils");
 const async_mutex_1 = require("async-mutex");
+const stellarAccountAssetInfo_1 = require("../multichain/stellarAccountAssetInfo.cjs");
 const stellarTrustline_1 = require("../multichain/stellarTrustline.cjs");
 const utils_2 = require("./utils.cjs");
 const controllerName = 'MultichainAssetsController';
@@ -36,8 +37,6 @@ function getDefaultMultichainAssetsControllerState() {
         accountsAssets: {},
         assetsMetadata: {},
         allIgnoredAssets: {},
-        stellarClassicTrustlineInactiveAssetIds: {},
-        stellarTrustlineInactiveBackfillComplete: false,
     };
 }
 exports.getDefaultMultichainAssetsControllerState = getDefaultMultichainAssetsControllerState;
@@ -67,18 +66,6 @@ const assetsControllerMetadata = {
         includeInDebugSnapshot: false,
         usedInUi: true,
     },
-    stellarClassicTrustlineInactiveAssetIds: {
-        includeInStateLogs: false,
-        persist: true,
-        includeInDebugSnapshot: false,
-        usedInUi: true,
-    },
-    stellarTrustlineInactiveBackfillComplete: {
-        includeInStateLogs: false,
-        persist: true,
-        includeInDebugSnapshot: false,
-        usedInUi: false,
-    },
 };
 const MESSENGER_EXPOSED_METHODS = [
     'getAssetMetadata',
@@ -121,8 +108,30 @@ class MultichainAssetsController extends (0, polling_controller_1.StaticInterval
         this.messenger.subscribe('AccountsController:accountAssetListUpdated', 
         // eslint-disable-next-line @typescript-eslint/no-misused-promises
         async (event) => await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_handleAccountAssetListUpdatedEvent).call(this, event));
+        this.messenger.subscribe('AccountsController:accountBalancesUpdated', (event) => {
+            // eslint-disable-next-line no-void
+            void __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_handleAccountBalancesUpdatedForEnrichment).call(this, event);
+        });
+        // Bootstrap trust-line `extra` after unlock (and when already unlocked on first state event).
+        let previousKeyringIsUnlocked;
+        this.messenger.subscribe('KeyringController:stateChanged', (keyringState) => {
+            const { isUnlocked } = keyringState;
+            if (previousKeyringIsUnlocked === undefined) {
+                previousKeyringIsUnlocked = isUnlocked;
+                if (isUnlocked) {
+                    // eslint-disable-next-line no-void
+                    void __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_bootstrapStellarTrustlineExtras).call(this);
+                }
+                return;
+            }
+            const justUnlocked = isUnlocked && !previousKeyringIsUnlocked;
+            previousKeyringIsUnlocked = isUnlocked;
+            if (justUnlocked) {
+                // eslint-disable-next-line no-void
+                void __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_bootstrapStellarTrustlineExtras).call(this);
+            }
+        });
         messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
-        __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_backfillStellarTrustlineInactiveIfNeeded).call(this);
     }
     async _executePoll(_input) {
         await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_withControllerLock).call(this, async () => {
@@ -178,7 +187,6 @@ class MultichainAssetsController extends (0, polling_controller_1.StaticInterval
             if (state.accountsAssets[accountId]) {
                 state.accountsAssets[accountId] = state.accountsAssets[accountId].filter((asset) => !assetsToIgnore.includes(asset));
             }
-            __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_removeStellarTrustlineInactiveAssetIds).call(this, state, accountId, assetsToIgnore);
             if (!state.allIgnoredAssets[accountId]) {
                 state.allIgnoredAssets[accountId] = [];
             }
@@ -228,17 +236,6 @@ class MultichainAssetsController extends (0, polling_controller_1.StaticInterval
                         delete state.allIgnoredAssets[accountId];
                     }
                 }
-                for (const assetId of addedAssets) {
-                    if ((0, stellarTrustline_1.isStellarClassicAssetCaip19)(assetId)) {
-                        if (!state.stellarClassicTrustlineInactiveAssetIds[accountId]) {
-                            state.stellarClassicTrustlineInactiveAssetIds[accountId] = [];
-                        }
-                        const inactive = state.stellarClassicTrustlineInactiveAssetIds[accountId];
-                        if (!inactive.includes(assetId)) {
-                            inactive.push(assetId);
-                        }
-                    }
-                }
             });
             // Publish event to notify other controllers (balances, rates) about the new assets
             if (addedAssets.length > 0) {
@@ -250,35 +247,16 @@ class MultichainAssetsController extends (0, polling_controller_1.StaticInterval
                         },
                     },
                 });
+                // Let MultichainBalancesController create balance rows before merging trust-line `extra`.
+                await Promise.resolve();
+                await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_enrichStellarAccountAssetInfo).call(this, accountId, addedAssets);
             }
-            await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_reconcileStellarClassicTrustlineInactiveWithSnap).call(this, accountId, addedAssets);
             return this.state.accountsAssets[accountId] || [];
         });
     }
 }
 exports.MultichainAssetsController = MultichainAssetsController;
-_MultichainAssetsController_snaps = new WeakMap(), _MultichainAssetsController_controllerOperationMutex = new WeakMap(), _MultichainAssetsController_instances = new WeakSet(), _MultichainAssetsController_backfillStellarTrustlineInactiveIfNeeded = function _MultichainAssetsController_backfillStellarTrustlineInactiveIfNeeded() {
-    if (this.state.stellarTrustlineInactiveBackfillComplete) {
-        return;
-    }
-    this.update((state) => {
-        for (const [accountId, assets] of Object.entries(state.accountsAssets)) {
-            for (const assetId of assets) {
-                if (!(0, stellarTrustline_1.isStellarClassicAssetCaip19)(assetId)) {
-                    continue;
-                }
-                if (!state.stellarClassicTrustlineInactiveAssetIds[accountId]) {
-                    state.stellarClassicTrustlineInactiveAssetIds[accountId] = [];
-                }
-                const inactive = state.stellarClassicTrustlineInactiveAssetIds[accountId];
-                if (!inactive.includes(assetId)) {
-                    inactive.push(assetId);
-                }
-            }
-        }
-        state.stellarTrustlineInactiveBackfillComplete = true;
-    });
-}, _MultichainAssetsController_handleAccountAssetListUpdatedEvent = 
+_MultichainAssetsController_snaps = new WeakMap(), _MultichainAssetsController_controllerOperationMutex = new WeakMap(), _MultichainAssetsController_instances = new WeakSet(), _MultichainAssetsController_handleAccountAssetListUpdatedEvent = 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 async function _MultichainAssetsController_handleAccountAssetListUpdatedEvent(event) {
     return __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_withControllerLock).call(this, async () => __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_handleAccountAssetListUpdated).call(this, event));
@@ -288,61 +266,6 @@ async function _MultichainAssetsController_handleOnAccountAddedEvent(account) {
     return __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_withControllerLock).call(this, async () => __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_handleOnAccountAdded).call(this, account));
 }, _MultichainAssetsController_isAssetIgnored = function _MultichainAssetsController_isAssetIgnored(asset, accountId) {
     return this.state.allIgnoredAssets[accountId]?.includes(asset) ?? false;
-}, _MultichainAssetsController_reconcileStellarClassicTrustlineInactiveWithSnap = 
-/**
- * After `addAssets`, Stellar classic (`asset:`) ids are marked trustline-inactive until
- * the keyring confirms them. Re-fetch the account asset list from the Snap and clear
- * that flag for any added classic id the Snap already reports (e.g. hide → re-add with
- * an existing trustline), without relying on a later `accountAssetListUpdated` event.
- *
- * @param accountId - Account the assets were added to.
- * @param addedAssets - Assets that were newly added in this `addAssets` call.
- */
-async function _MultichainAssetsController_reconcileStellarClassicTrustlineInactiveWithSnap(accountId, addedAssets) {
-    const stellarAdded = addedAssets.filter(stellarTrustline_1.isStellarClassicAssetCaip19);
-    if (stellarAdded.length === 0) {
-        return;
-    }
-    const accounts = this.messenger.call('AccountsController:listMultichainAccounts');
-    const account = accounts.find((a) => a.id === accountId);
-    if (!account || !__classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_isNonEvmAccount).call(this, account)) {
-        return;
-    }
-    const snapId = account.metadata.snap?.id;
-    if (!snapId) {
-        return;
-    }
-    let snapAssets;
-    try {
-        snapAssets = await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_getAssetsList).call(this, accountId, snapId);
-    }
-    catch {
-        return;
-    }
-    const snapAssetSet = new Set(snapAssets.filter(utils_1.isCaipAssetType));
-    const confirmedTrustline = stellarAdded.filter((asset) => snapAssetSet.has(asset));
-    if (confirmedTrustline.length === 0) {
-        return;
-    }
-    this.update((state) => {
-        __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_removeStellarTrustlineInactiveAssetIds).call(this, state, accountId, confirmedTrustline);
-    });
-}, _MultichainAssetsController_removeStellarTrustlineInactiveAssetIds = function _MultichainAssetsController_removeStellarTrustlineInactiveAssetIds(state, accountId, assetIds) {
-    if (assetIds.length === 0) {
-        return;
-    }
-    const list = state.stellarClassicTrustlineInactiveAssetIds[accountId];
-    if (!list) {
-        return;
-    }
-    const drop = new Set(assetIds);
-    const next = list.filter((a) => !drop.has(a));
-    if (next.length === 0) {
-        delete state.stellarClassicTrustlineInactiveAssetIds[accountId];
-    }
-    else {
-        state.stellarClassicTrustlineInactiveAssetIds[accountId] = next;
-    }
 }, _MultichainAssetsController_handleAccountAssetListUpdated = 
 /**
  * Function to update the assets list for an account
@@ -354,11 +277,6 @@ async function _MultichainAssetsController_handleAccountAssetListUpdated(event)
     __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_assertControllerMutexIsLocked).call(this);
     const assetsForMetadataRefresh = new Set([]);
     const accountsAndAssetsToUpdate = {};
-    /**
-     * When the keyring re-announces a Stellar classic asset id the user had already
-     * imported, `preFiltered` excludes it; we still clear "no trustline" UI state.
-     */
-    const clearStellarTrustlineInactiveByAccount = {};
     for (const [accountId, { added, removed }] of Object.entries(event.assets)) {
         if (added.length > 0 || removed.length > 0) {
             const existing = this.state.accountsAssets[accountId] || [];
@@ -369,15 +287,6 @@ async function _MultichainAssetsController_handleAccountAssetListUpdated(event)
                 !__classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_isAssetIgnored).call(this, asset, accountId));
             // Filter out tokens that cannot be verified or are flagged malicious
             const filteredToBeAddedAssets = await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_filterBlockaidSpamTokensOnAdd).call(this, preFilteredToBeAddedAssets);
-            const filteredToBeAddedSet = new Set(filteredToBeAddedAssets);
-            const snapConfirmsStellarTrustline = added.filter((asset) => (0, utils_1.isCaipAssetType)(asset) &&
-                !__classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_isAssetIgnored).call(this, asset, accountId) &&
-                (0, stellarTrustline_1.isStellarClassicAssetCaip19)(asset) &&
-                (existing.includes(asset) || filteredToBeAddedSet.has(asset)));
-            if (snapConfirmsStellarTrustline.length > 0) {
-                clearStellarTrustlineInactiveByAccount[accountId] =
-                    snapConfirmsStellarTrustline;
-            }
             // In case accountsAndAssetsToUpdate event is fired with "removed" assets that don't exist, we don't want to remove them
             const filteredToBeRemovedAssets = removed.filter((asset) => existing.includes(asset) && (0, utils_1.isCaipAssetType)(asset));
             if (filteredToBeAddedAssets.length > 0 ||
@@ -398,28 +307,16 @@ async function _MultichainAssetsController_handleAccountAssetListUpdated(event)
             }
         }
     }
-    const accountIdsToUpdate = new Set([
-        ...Object.keys(accountsAndAssetsToUpdate),
-        ...Object.keys(clearStellarTrustlineInactiveByAccount),
-    ]);
     this.update((state) => {
-        for (const accountId of accountIdsToUpdate) {
-            const toMerge = accountsAndAssetsToUpdate[accountId];
-            if (toMerge) {
-                const { added, removed: removedAssets } = toMerge;
-                const assets = new Set([
-                    ...(state.accountsAssets[accountId] || []),
-                    ...added,
-                ]);
-                for (const asset of removedAssets) {
-                    assets.delete(asset);
-                }
-                state.accountsAssets[accountId] = Array.from(assets);
-            }
-            __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_removeStellarTrustlineInactiveAssetIds).call(this, state, accountId, clearStellarTrustlineInactiveByAccount[accountId] ?? []);
-            if (toMerge) {
-                __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_removeStellarTrustlineInactiveAssetIds).call(this, state, accountId, toMerge.removed);
+        for (const [accountId, { added, removed: removedAssets }] of Object.entries(accountsAndAssetsToUpdate)) {
+            const assets = new Set([
+                ...(state.accountsAssets[accountId] || []),
+                ...added,
+            ]);
+            for (const asset of removedAssets) {
+                assets.delete(asset);
             }
+            state.accountsAssets[accountId] = Array.from(assets);
         }
     });
     // Trigger fetching metadata for new assets
@@ -453,7 +350,6 @@ async function _MultichainAssetsController_handleOnAccountAdded(account) {
         await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_refreshAssetsMetadata).call(this, assets);
         this.update((state) => {
             state.accountsAssets[account.id] = assets;
-            delete state.stellarClassicTrustlineInactiveAssetIds[account.id];
         });
         this.messenger.publish(`${controllerName}:accountAssetListUpdated`, {
             assets: {
@@ -463,6 +359,126 @@ async function _MultichainAssetsController_handleOnAccountAdded(account) {
                 },
             },
         });
+        await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_enrichStellarAccountAssetInfo).call(this, account.id, filteredCaip);
+    }
+}, _MultichainAssetsController_bootstrapStellarTrustlineExtras = 
+/**
+ * After unlock, enrich trust-line `extra` for all Stellar classics already in the portfolio.
+ */
+async function _MultichainAssetsController_bootstrapStellarTrustlineExtras() {
+    const { isUnlocked } = this.messenger.call('KeyringController:getState');
+    if (!isUnlocked) {
+        return;
+    }
+    const accounts = this.messenger.call('AccountsController:listMultichainAccounts');
+    for (const account of accounts) {
+        if (!(0, stellarAccountAssetInfo_1.isStellarMultichainAccount)(account)) {
+            continue;
+        }
+        const classics = (this.state.accountsAssets[account.id] ?? []).filter(stellarTrustline_1.isStellarClassicAssetCaip19);
+        if (classics.length > 0) {
+            await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_enrichStellarAccountAssetInfo).call(this, account.id, classics);
+        }
+    }
+}, _MultichainAssetsController_handleAccountBalancesUpdatedForEnrichment = 
+/**
+ * After snap balance events, fetch Stellar asset info (metadata + trust-line `extra`).
+ *
+ * @param payload - Keyring balance update payload.
+ */
+async function _MultichainAssetsController_handleAccountBalancesUpdatedForEnrichment(payload) {
+    // Yield so MultichainBalancesController applies balance rows first (MAC inits before MBC in extension).
+    await Promise.resolve();
+    for (const accountId of Object.keys(payload.balances)) {
+        const classics = (this.state.accountsAssets[accountId] ?? []).filter(stellarTrustline_1.isStellarClassicAssetCaip19);
+        if (classics.length === 0) {
+            continue;
+        }
+        await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_enrichStellarAccountAssetInfo).call(this, accountId, classics);
+    }
+}, _MultichainAssetsController_enrichStellarAccountAssetInfo = 
+/**
+ * Fetches Stellar-only `keyring_getAccountAssetInfo` and merges metadata + balance `extra`.
+ *
+ * @param accountId - Account id.
+ * @param assetIds - Assets to enrich.
+ */
+async function _MultichainAssetsController_enrichStellarAccountAssetInfo(accountId, assetIds) {
+    const stellarClassicIds = assetIds.filter(stellarTrustline_1.isStellarClassicAssetCaip19);
+    if (stellarClassicIds.length === 0) {
+        return;
+    }
+    const accounts = this.messenger.call('AccountsController:listMultichainAccounts');
+    const account = accounts.find((a) => a.id === accountId);
+    if (!account || !(0, stellarAccountAssetInfo_1.isStellarMultichainAccount)(account)) {
+        return;
+    }
+    const snapId = account.metadata.snap?.id;
+    if (!snapId) {
+        return;
+    }
+    const info = await __classPrivateFieldGet(this, _MultichainAssetsController_instances, "m", _MultichainAssetsController_getAccountAssetInfoFromSnap).call(this, accountId, snapId, stellarClassicIds);
+    if (!info) {
+        return;
+    }
+    const metadataUpdates = {};
+    const extrasByAsset = {};
+    for (const assetId of stellarClassicIds) {
+        const entry = info[assetId];
+        if (!entry) {
+            // Snap omits assets with no on-chain row (portfolio import without trust line).
+            extrasByAsset[assetId] = { limit: '0' };
+            continue;
+        }
+        metadataUpdates[assetId] = entry.metadata;
+        const balanceExtra = (0, stellarAccountAssetInfo_1.stellarAssetInfoExtraToBalanceExtra)(entry.extra);
+        if (balanceExtra === undefined) {
+            // Snap omits extra when there is no on-chain trust line (portfolio import).
+            extrasByAsset[assetId] = { limit: '0' };
+        }
+        else {
+            extrasByAsset[assetId] = balanceExtra;
+        }
+    }
+    if (Object.keys(metadataUpdates).length > 0) {
+        this.update((state) => {
+            state.assetsMetadata = {
+                ...state.assetsMetadata,
+                ...metadataUpdates,
+            };
+        });
+    }
+    if (Object.keys(extrasByAsset).length > 0) {
+        this.messenger.call('MultichainBalancesController:mergeAccountBalanceExtras', accountId, extrasByAsset);
+    }
+}, _MultichainAssetsController_getAccountAssetInfoFromSnap = 
+/**
+ * Calls the Stellar snap `keyring_getAccountAssetInfo` handler.
+ *
+ * @param accountId - Account id.
+ * @param snapId - Stellar wallet snap id.
+ * @param assets - CAIP-19 assets to resolve.
+ * @returns Per-asset metadata and optional trust-line extra, or undefined on failure.
+ */
+async function _MultichainAssetsController_getAccountAssetInfoFromSnap(accountId, snapId, assets) {
+    try {
+        return (await this.messenger.call('SnapController:handleRequest', {
+            snapId: snapId,
+            origin: 'metamask',
+            handler: snaps_utils_1.HandlerType.OnKeyringRequest,
+            request: {
+                jsonrpc: '2.0',
+                method: stellarAccountAssetInfo_1.KEYRING_GET_ACCOUNT_ASSET_INFO_METHOD,
+                params: {
+                    accountId,
+                    assets,
+                },
+            },
+        }));
+    }
+    catch (error) {
+        console.error(error);
+        return undefined;
     }
 }, _MultichainAssetsController_handleOnAccountRemovedEvent = 
 /**
@@ -478,9 +494,6 @@ async function _MultichainAssetsController_handleOnAccountRemovedEvent(accountId
         if (state.allIgnoredAssets[accountId]) {
             delete state.allIgnoredAssets[accountId];
         }
-        if (state.stellarClassicTrustlineInactiveAssetIds[accountId]) {
-            delete state.stellarClassicTrustlineInactiveAssetIds[accountId];
-        }
         // TODO: We are not deleting the assetsMetadata because we will soon make this controller extends StaticIntervalPollingController
         // and update all assetsMetadata once a day.
     });