@metamask/assets-controllers 38.0.0 → 38.0.1

package/dist/TokensController.mjs

@@ -1,16 +1,677 @@
-import {
-  TokensController,
-  TokensController_default,
-  getDefaultTokensState
-} from "./chunk-XMQA5NLX.mjs";
-import "./chunk-S5CFNNOM.mjs";
-import "./chunk-KPBNX6GP.mjs";
-import "./chunk-AX522TDL.mjs";
-import "./chunk-BZEAPSD5.mjs";
-import "./chunk-XUI43LEZ.mjs";
-export {
-  TokensController,
-  TokensController_default as default,
-  getDefaultTokensState
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TokensController_instances, _TokensController_mutex, _TokensController_chainId, _TokensController_selectedAccountId, _TokensController_provider, _TokensController_abortController, _TokensController_onNetworkDidChange, _TokensController_onSelectedAccountChange, _TokensController_fetchTokenMetadata, _TokensController_updateTokensAttribute, _TokensController_detectIsERC721, _TokensController_getProvider, _TokensController_createEthersContract, _TokensController_generateRandomId, _TokensController_getNewAllTokensState, _TokensController_getAddressOrSelectedAddress, _TokensController_isInteractingWithWallet, _TokensController_requestApproval, _TokensController_getSelectedAccount, _TokensController_getSelectedAddress;
+function $importDefault(module) {
+    if (module?.__esModule) {
+        return module.default;
+    }
+    return module;
+}
+import { Contract } from "@ethersproject/contracts";
+import { Web3Provider } from "@ethersproject/providers";
+import { BaseController } from "@metamask/base-controller";
+import $contractsMap from "@metamask/contract-metadata";
+const contractsMap = $importDefault($contractsMap);
+import { toChecksumHexAddress, ERC721_INTERFACE_ID, ORIGIN_METAMASK, ApprovalType, ERC20, ERC721, ERC1155, isValidHexAddress, safelyExecute } from "@metamask/controller-utils";
+import { abiERC721 } from "@metamask/metamask-eth-abis";
+import { rpcErrors } from "@metamask/rpc-errors";
+import { Mutex } from "async-mutex";
+import { v1 as random } from "uuid";
+import { formatAggregatorNames, formatIconUrlWithProxy } from "./assetsUtil.mjs";
+import { ERC20Standard } from "./Standards/ERC20Standard.mjs";
+import { ERC1155Standard } from "./Standards/NftStandards/ERC1155/ERC1155Standard.mjs";
+import { fetchTokenMetadata, TOKEN_METADATA_NO_SUPPORT_ERROR } from "./token-service.mjs";
+const metadata = {
+    tokens: {
+        persist: true,
+        anonymous: false,
+    },
+    ignoredTokens: {
+        persist: true,
+        anonymous: false,
+    },
+    detectedTokens: {
+        persist: true,
+        anonymous: false,
+    },
+    allTokens: {
+        persist: true,
+        anonymous: false,
+    },
+    allIgnoredTokens: {
+        persist: true,
+        anonymous: false,
+    },
+    allDetectedTokens: {
+        persist: true,
+        anonymous: false,
+    },
+};
+const controllerName = 'TokensController';
+export const getDefaultTokensState = () => {
+    return {
+        tokens: [],
+        ignoredTokens: [],
+        detectedTokens: [],
+        allTokens: {},
+        allIgnoredTokens: {},
+        allDetectedTokens: {},
+    };
+};
+/**
+ * Controller that stores assets and exposes convenience methods
+ */
+export class TokensController extends BaseController {
+    /**
+     * Tokens controller options
+     * @param options - Constructor options.
+     * @param options.chainId - The chain ID of the current network.
+     * @param options.provider - Network provider.
+     * @param options.state - Initial state to set on this controller.
+     * @param options.messenger - The controller messenger.
+     */
+    constructor({ chainId: initialChainId, provider, state, messenger, }) {
+        super({
+            name: controllerName,
+            metadata,
+            messenger,
+            state: {
+                ...getDefaultTokensState(),
+                ...state,
+            },
+        });
+        _TokensController_instances.add(this);
+        _TokensController_mutex.set(this, new Mutex());
+        _TokensController_chainId.set(this, void 0);
+        _TokensController_selectedAccountId.set(this, void 0);
+        _TokensController_provider.set(this, void 0);
+        _TokensController_abortController.set(this, void 0);
+        __classPrivateFieldSet(this, _TokensController_chainId, initialChainId, "f");
+        __classPrivateFieldSet(this, _TokensController_provider, provider, "f");
+        __classPrivateFieldSet(this, _TokensController_selectedAccountId, __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getSelectedAccount).call(this).id, "f");
+        __classPrivateFieldSet(this, _TokensController_abortController, new AbortController(), "f");
+        this.messagingSystem.registerActionHandler(`${controllerName}:addDetectedTokens`, this.addDetectedTokens.bind(this));
+        this.messagingSystem.subscribe('AccountsController:selectedEvmAccountChange', __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_onSelectedAccountChange).bind(this));
+        this.messagingSystem.subscribe('NetworkController:networkDidChange', __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_onNetworkDidChange).bind(this));
+        this.messagingSystem.subscribe('TokenListController:stateChange', ({ tokenList }) => {
+            const { tokens } = this.state;
+            if (tokens.length && !tokens[0].name) {
+                __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_updateTokensAttribute).call(this, tokenList, 'name');
+            }
+        });
+    }
+    /**
+     * Adds a token to the stored token list.
+     *
+     * @param options - The method argument object.
+     * @param options.address - Hex address of the token contract.
+     * @param options.symbol - Symbol of the token.
+     * @param options.decimals - Number of decimals the token uses.
+     * @param options.name - Name of the token.
+     * @param options.image - Image of the token.
+     * @param options.interactingAddress - The address of the account to add a token to.
+     * @param options.networkClientId - Network Client ID.
+     * @returns Current token list.
+     */
+    async addToken({ address, symbol, decimals, name, image, interactingAddress, networkClientId, }) {
+        const chainId = __classPrivateFieldGet(this, _TokensController_chainId, "f");
+        const releaseLock = await __classPrivateFieldGet(this, _TokensController_mutex, "f").acquire();
+        const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
+        let currentChainId = chainId;
+        if (networkClientId) {
+            currentChainId = this.messagingSystem.call('NetworkController:getNetworkClientById', networkClientId).configuration.chainId;
+        }
+        const accountAddress = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getAddressOrSelectedAddress).call(this, interactingAddress);
+        const isInteractingWithWalletAccount = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_isInteractingWithWallet).call(this, accountAddress);
+        try {
+            address = toChecksumHexAddress(address);
+            const tokens = allTokens[currentChainId]?.[accountAddress] || [];
+            const ignoredTokens = allIgnoredTokens[currentChainId]?.[accountAddress] || [];
+            const detectedTokens = allDetectedTokens[currentChainId]?.[accountAddress] || [];
+            const newTokens = [...tokens];
+            const [isERC721, tokenMetadata] = await Promise.all([
+                __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_detectIsERC721).call(this, address, networkClientId),
+                // TODO parameterize the token metadata fetch by networkClientId
+                __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_fetchTokenMetadata).call(this, address),
+            ]);
+            // TODO remove this once this method is fully parameterized by networkClientId
+            if (!networkClientId && currentChainId !== __classPrivateFieldGet(this, _TokensController_chainId, "f")) {
+                throw new Error('TokensController Error: Switched networks while adding token');
+            }
+            const newEntry = {
+                address,
+                symbol,
+                decimals,
+                image: image ||
+                    formatIconUrlWithProxy({
+                        chainId: currentChainId,
+                        tokenAddress: address,
+                    }),
+                isERC721,
+                aggregators: formatAggregatorNames(tokenMetadata?.aggregators || []),
+                name,
+            };
+            const previousIndex = newTokens.findIndex((token) => token.address.toLowerCase() === address.toLowerCase());
+            if (previousIndex !== -1) {
+                newTokens[previousIndex] = newEntry;
+            }
+            else {
+                newTokens.push(newEntry);
+            }
+            const newIgnoredTokens = ignoredTokens.filter((tokenAddress) => tokenAddress.toLowerCase() !== address.toLowerCase());
+            const newDetectedTokens = detectedTokens.filter((token) => token.address.toLowerCase() !== address.toLowerCase());
+            const { newAllTokens, newAllIgnoredTokens, newAllDetectedTokens } = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getNewAllTokensState).call(this, {
+                newTokens,
+                newIgnoredTokens,
+                newDetectedTokens,
+                interactingAddress: accountAddress,
+                interactingChainId: currentChainId,
+            });
+            let newState = {
+                allTokens: newAllTokens,
+                allIgnoredTokens: newAllIgnoredTokens,
+                allDetectedTokens: newAllDetectedTokens,
+            };
+            // Only update active tokens if user is interacting with their active wallet account.
+            if (isInteractingWithWalletAccount) {
+                newState = {
+                    ...newState,
+                    tokens: newTokens,
+                    ignoredTokens: newIgnoredTokens,
+                    detectedTokens: newDetectedTokens,
+                };
+            }
+            this.update((state) => {
+                Object.assign(state, newState);
+            });
+            return newTokens;
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    /**
+     * Add a batch of tokens.
+     *
+     * @param tokensToImport - Array of tokens to import.
+     * @param networkClientId - Optional network client ID used to determine interacting chain ID.
+     */
+    async addTokens(tokensToImport, networkClientId) {
+        const releaseLock = await __classPrivateFieldGet(this, _TokensController_mutex, "f").acquire();
+        const { tokens, detectedTokens, ignoredTokens } = this.state;
+        const importedTokensMap = {};
+        // Used later to dedupe imported tokens
+        const newTokensMap = tokens.reduce((output, current) => {
+            output[current.address] = current;
+            return output;
+        }, {});
+        try {
+            tokensToImport.forEach((tokenToAdd) => {
+                const { address, symbol, decimals, image, aggregators, name } = tokenToAdd;
+                const checksumAddress = toChecksumHexAddress(address);
+                const formattedToken = {
+                    address: checksumAddress,
+                    symbol,
+                    decimals,
+                    image,
+                    aggregators,
+                    name,
+                };
+                newTokensMap[address] = formattedToken;
+                importedTokensMap[address.toLowerCase()] = true;
+                return formattedToken;
+            });
+            const newTokens = Object.values(newTokensMap);
+            const newDetectedTokens = detectedTokens.filter((token) => !importedTokensMap[token.address.toLowerCase()]);
+            const newIgnoredTokens = ignoredTokens.filter((tokenAddress) => !newTokensMap[tokenAddress.toLowerCase()]);
+            let interactingChainId;
+            if (networkClientId) {
+                interactingChainId = this.messagingSystem.call('NetworkController:getNetworkClientById', networkClientId).configuration.chainId;
+            }
+            const { newAllTokens, newAllDetectedTokens, newAllIgnoredTokens } = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getNewAllTokensState).call(this, {
+                newTokens,
+                newDetectedTokens,
+                newIgnoredTokens,
+                interactingChainId,
+            });
+            this.update((state) => {
+                state.tokens = newTokens;
+                state.allTokens = newAllTokens;
+                state.detectedTokens = newDetectedTokens;
+                state.allDetectedTokens = newAllDetectedTokens;
+                state.ignoredTokens = newIgnoredTokens;
+                state.allIgnoredTokens = newAllIgnoredTokens;
+            });
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    /**
+     * Ignore a batch of tokens.
+     *
+     * @param tokenAddressesToIgnore - Array of token addresses to ignore.
+     */
+    ignoreTokens(tokenAddressesToIgnore) {
+        const { ignoredTokens, detectedTokens, tokens } = this.state;
+        const ignoredTokensMap = {};
+        let newIgnoredTokens = [...ignoredTokens];
+        const checksummedTokenAddresses = tokenAddressesToIgnore.map((address) => {
+            const checksumAddress = toChecksumHexAddress(address);
+            ignoredTokensMap[address.toLowerCase()] = true;
+            return checksumAddress;
+        });
+        newIgnoredTokens = [...ignoredTokens, ...checksummedTokenAddresses];
+        const newDetectedTokens = detectedTokens.filter((token) => !ignoredTokensMap[token.address.toLowerCase()]);
+        const newTokens = tokens.filter((token) => !ignoredTokensMap[token.address.toLowerCase()]);
+        const { newAllIgnoredTokens, newAllDetectedTokens, newAllTokens } = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getNewAllTokensState).call(this, {
+            newIgnoredTokens,
+            newDetectedTokens,
+            newTokens,
+        });
+        this.update((state) => {
+            state.ignoredTokens = newIgnoredTokens;
+            state.tokens = newTokens;
+            state.detectedTokens = newDetectedTokens;
+            state.allIgnoredTokens = newAllIgnoredTokens;
+            state.allDetectedTokens = newAllDetectedTokens;
+            state.allTokens = newAllTokens;
+        });
+    }
+    /**
+     * Adds a batch of detected tokens to the stored token list.
+     *
+     * @param incomingDetectedTokens - Array of detected tokens to be added or updated.
+     * @param detectionDetails - An object containing the chain ID and address of the currently selected network on which the incomingDetectedTokens were detected.
+     * @param detectionDetails.selectedAddress - the account address on which the incomingDetectedTokens were detected.
+     * @param detectionDetails.chainId - the chainId on which the incomingDetectedTokens were detected.
+     */
+    async addDetectedTokens(incomingDetectedTokens, detectionDetails) {
+        const releaseLock = await __classPrivateFieldGet(this, _TokensController_mutex, "f").acquire();
+        const chainId = detectionDetails?.chainId ?? __classPrivateFieldGet(this, _TokensController_chainId, "f");
+        // Previously selectedAddress could be an empty string. This is to preserve the behaviour
+        const accountAddress = detectionDetails?.selectedAddress ?? __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getSelectedAddress).call(this);
+        const { allTokens, allDetectedTokens, allIgnoredTokens } = this.state;
+        let newTokens = [...(allTokens?.[chainId]?.[accountAddress] ?? [])];
+        let newDetectedTokens = [
+            ...(allDetectedTokens?.[chainId]?.[accountAddress] ?? []),
+        ];
+        try {
+            incomingDetectedTokens.forEach((tokenToAdd) => {
+                const { address, symbol, decimals, image, aggregators, isERC721, name, } = tokenToAdd;
+                const checksumAddress = toChecksumHexAddress(address);
+                const newEntry = {
+                    address: checksumAddress,
+                    symbol,
+                    decimals,
+                    image,
+                    isERC721,
+                    aggregators,
+                    name,
+                };
+                const previousImportedIndex = newTokens.findIndex((token) => token.address.toLowerCase() === checksumAddress.toLowerCase());
+                if (previousImportedIndex !== -1) {
+                    // Update existing data of imported token
+                    newTokens[previousImportedIndex] = newEntry;
+                }
+                else {
+                    const ignoredTokenIndex = allIgnoredTokens?.[chainId]?.[accountAddress]?.indexOf(address) ??
+                        -1;
+                    if (ignoredTokenIndex === -1) {
+                        // Add detected token
+                        const previousDetectedIndex = newDetectedTokens.findIndex((token) => token.address.toLowerCase() === checksumAddress.toLowerCase());
+                        if (previousDetectedIndex !== -1) {
+                            newDetectedTokens[previousDetectedIndex] = newEntry;
+                        }
+                        else {
+                            newDetectedTokens.push(newEntry);
+                        }
+                    }
+                }
+            });
+            const { newAllTokens, newAllDetectedTokens } = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getNewAllTokensState).call(this, {
+                newTokens,
+                newDetectedTokens,
+                interactingAddress: accountAddress,
+                interactingChainId: chainId,
+            });
+            // We may be detecting tokens on a different chain/account pair than are currently configured.
+            // Re-point `tokens` and `detectedTokens` to keep them referencing the current chain/account.
+            const selectedAddress = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getSelectedAddress).call(this);
+            newTokens = newAllTokens?.[__classPrivateFieldGet(this, _TokensController_chainId, "f")]?.[selectedAddress] || [];
+            newDetectedTokens =
+                newAllDetectedTokens?.[__classPrivateFieldGet(this, _TokensController_chainId, "f")]?.[selectedAddress] || [];
+            this.update((state) => {
+                state.tokens = newTokens;
+                state.allTokens = newAllTokens;
+                state.detectedTokens = newDetectedTokens;
+                state.allDetectedTokens = newAllDetectedTokens;
+            });
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    /**
+     * Adds isERC721 field to token object. This is called when a user attempts to add tokens that
+     * were previously added which do not yet had isERC721 field.
+     *
+     * @param tokenAddress - The contract address of the token requiring the isERC721 field added.
+     * @returns The new token object with the added isERC721 field.
+     */
+    async updateTokenType(tokenAddress) {
+        const isERC721 = await __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_detectIsERC721).call(this, tokenAddress);
+        const tokens = [...this.state.tokens];
+        const tokenIndex = tokens.findIndex((token) => {
+            return token.address.toLowerCase() === tokenAddress.toLowerCase();
+        });
+        const updatedToken = { ...tokens[tokenIndex], isERC721 };
+        tokens[tokenIndex] = updatedToken;
+        this.update((state) => {
+            state.tokens = tokens;
+        });
+        return updatedToken;
+    }
+    /**
+     * Adds a new suggestedAsset to the list of watched assets.
+     * Parameters will be validated according to the asset type being watched.
+     *
+     * @param options - The method options.
+     * @param options.asset - The asset to be watched. For now only ERC20 tokens are accepted.
+     * @param options.type - The asset type.
+     * @param options.interactingAddress - The address of the account that is requesting to watch the asset.
+     * @param options.networkClientId - Network Client ID.
+     * @returns A promise that resolves if the asset was watched successfully, and rejects otherwise.
+     */
+    async watchAsset({ asset, type, interactingAddress, networkClientId, }) {
+        if (type !== ERC20) {
+            throw new Error(`Asset of type ${type} not supported`);
+        }
+        if (!asset.address) {
+            throw rpcErrors.invalidParams('Address must be specified');
+        }
+        if (!isValidHexAddress(asset.address)) {
+            throw rpcErrors.invalidParams(`Invalid address "${asset.address}"`);
+        }
+        const selectedAddress = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getAddressOrSelectedAddress).call(this, interactingAddress);
+        // Validate contract
+        if (await __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_detectIsERC721).call(this, asset.address, networkClientId)) {
+            throw rpcErrors.invalidParams(
+            // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `Contract ${asset.address} must match type ${type}, but was detected as ${ERC721}`);
+        }
+        const provider = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getProvider).call(this, networkClientId);
+        const isErc1155 = await safelyExecute(() => new ERC1155Standard(provider).contractSupportsBase1155Interface(asset.address));
+        if (isErc1155) {
+            throw rpcErrors.invalidParams(
+            // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `Contract ${asset.address} must match type ${type}, but was detected as ${ERC1155}`);
+        }
+        const erc20 = new ERC20Standard(provider);
+        const [contractName, contractSymbol, contractDecimals] = await Promise.all([
+            safelyExecute(() => erc20.getTokenName(asset.address)),
+            safelyExecute(() => erc20.getTokenSymbol(asset.address)),
+            safelyExecute(async () => erc20.getTokenDecimals(asset.address)),
+        ]);
+        asset.name = contractName;
+        // Validate symbol
+        if (!asset.symbol && !contractSymbol) {
+            throw rpcErrors.invalidParams('A symbol is required, but was not found in either the request or contract');
+        }
+        if (contractSymbol !== undefined &&
+            asset.symbol !== undefined &&
+            asset.symbol.toUpperCase() !== contractSymbol.toUpperCase()) {
+            throw rpcErrors.invalidParams(
+            // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `The symbol in the request (${asset.symbol}) does not match the symbol in the contract (${contractSymbol})`);
+        }
+        asset.symbol = contractSymbol ?? asset.symbol;
+        if (typeof asset.symbol !== 'string') {
+            throw rpcErrors.invalidParams(`Invalid symbol: not a string`);
+        }
+        if (asset.symbol.length > 11) {
+            throw rpcErrors.invalidParams(`Invalid symbol "${asset.symbol}": longer than 11 characters`);
+        }
+        // Validate decimals
+        if (asset.decimals === undefined && contractDecimals === undefined) {
+            throw rpcErrors.invalidParams('Decimals are required, but were not found in either the request or contract');
+        }
+        if (contractDecimals !== undefined &&
+            asset.decimals !== undefined &&
+            String(asset.decimals) !== contractDecimals) {
+            throw rpcErrors.invalidParams(
+            // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `The decimals in the request (${asset.decimals}) do not match the decimals in the contract (${contractDecimals})`);
+        }
+        const decimalsStr = contractDecimals ?? asset.decimals;
+        const decimalsNum = parseInt(decimalsStr, 10);
+        if (!Number.isInteger(decimalsNum) || decimalsNum > 36 || decimalsNum < 0) {
+            throw rpcErrors.invalidParams(
+            // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            `Invalid decimals "${decimalsStr}": must be an integer 0 <= 36`);
+        }
+        asset.decimals = decimalsNum;
+        const suggestedAssetMeta = {
+            asset,
+            id: __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_generateRandomId).call(this),
+            time: Date.now(),
+            type,
+            interactingAddress: selectedAddress,
+        };
+        await __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_requestApproval).call(this, suggestedAssetMeta);
+        const { address, symbol, decimals, name, image } = asset;
+        await this.addToken({
+            address,
+            symbol,
+            decimals,
+            name,
+            image,
+            interactingAddress: suggestedAssetMeta.interactingAddress,
+            networkClientId,
+        });
+    }
+    /**
+     * Removes all tokens from the ignored list.
+     */
+    clearIgnoredTokens() {
+        this.update((state) => {
+            state.ignoredTokens = [];
+            state.allIgnoredTokens = {};
+        });
+    }
+}
+_TokensController_mutex = new WeakMap(), _TokensController_chainId = new WeakMap(), _TokensController_selectedAccountId = new WeakMap(), _TokensController_provider = new WeakMap(), _TokensController_abortController = new WeakMap(), _TokensController_instances = new WeakSet(), _TokensController_onNetworkDidChange = function _TokensController_onNetworkDidChange({ selectedNetworkClientId }) {
+    const selectedNetworkClient = this.messagingSystem.call('NetworkController:getNetworkClientById', selectedNetworkClientId);
+    const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
+    const { chainId } = selectedNetworkClient.configuration;
+    __classPrivateFieldGet(this, _TokensController_abortController, "f").abort();
+    __classPrivateFieldSet(this, _TokensController_abortController, new AbortController(), "f");
+    __classPrivateFieldSet(this, _TokensController_chainId, chainId, "f");
+    const selectedAddress = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getSelectedAddress).call(this);
+    this.update((state) => {
+        state.tokens = allTokens[chainId]?.[selectedAddress] || [];
+        state.ignoredTokens = allIgnoredTokens[chainId]?.[selectedAddress] || [];
+        state.detectedTokens =
+            allDetectedTokens[chainId]?.[selectedAddress] || [];
+    });
+}, _TokensController_onSelectedAccountChange = function _TokensController_onSelectedAccountChange(selectedAccount) {
+    const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
+    __classPrivateFieldSet(this, _TokensController_selectedAccountId, selectedAccount.id, "f");
+    this.update((state) => {
+        state.tokens = allTokens[__classPrivateFieldGet(this, _TokensController_chainId, "f")]?.[selectedAccount.address] ?? [];
+        state.ignoredTokens =
+            allIgnoredTokens[__classPrivateFieldGet(this, _TokensController_chainId, "f")]?.[selectedAccount.address] ?? [];
+        state.detectedTokens =
+            allDetectedTokens[__classPrivateFieldGet(this, _TokensController_chainId, "f")]?.[selectedAccount.address] ?? [];
+    });
+}, _TokensController_fetchTokenMetadata = 
+/**
+ * Fetch metadata for a token.
+ *
+ * @param tokenAddress - The address of the token.
+ * @returns The token metadata.
+ */
+async function _TokensController_fetchTokenMetadata(tokenAddress) {
+    try {
+        const token = await fetchTokenMetadata(__classPrivateFieldGet(this, _TokensController_chainId, "f"), tokenAddress, __classPrivateFieldGet(this, _TokensController_abortController, "f").signal);
+        return token;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message.includes(TOKEN_METADATA_NO_SUPPORT_ERROR)) {
+            return undefined;
+        }
+        throw error;
+    }
+}, _TokensController_updateTokensAttribute = function _TokensController_updateTokensAttribute(tokenList, tokenAttribute) {
+    const { tokens } = this.state;
+    const newTokens = tokens.map((token) => {
+        const newToken = tokenList[token.address.toLowerCase()];
+        return !token[tokenAttribute] && newToken?.[tokenAttribute]
+            ? { ...token, [tokenAttribute]: newToken[tokenAttribute] }
+            : { ...token };
+    });
+    this.update((state) => {
+        state.tokens = newTokens;
+    });
+}, _TokensController_detectIsERC721 = 
+/**
+ * Detects whether or not a token is ERC-721 compatible.
+ *
+ * @param tokenAddress - The token contract address.
+ * @param networkClientId - Optional network client ID to fetch contract info with.
+ * @returns A boolean indicating whether the token address passed in supports the EIP-721
+ * interface.
+ */
+async function _TokensController_detectIsERC721(tokenAddress, networkClientId) {
+    const checksumAddress = toChecksumHexAddress(tokenAddress);
+    // if this token is already in our contract metadata map we don't need
+    // to check against the contract
+    if (contractsMap[checksumAddress]?.erc721 === true) {
+        return Promise.resolve(true);
+    }
+    else if (contractsMap[checksumAddress]?.erc20 === true) {
+        return Promise.resolve(false);
+    }
+    const tokenContract = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_createEthersContract).call(this, tokenAddress, abiERC721, networkClientId);
+    try {
+        return await tokenContract.supportsInterface(ERC721_INTERFACE_ID);
+    }
+    catch (error) {
+        // currently we see a variety of errors across different networks when
+        // token contracts are not ERC721 compatible. We need to figure out a better
+        // way of differentiating token interface types but for now if we get an error
+        // we have to assume the token is not ERC721 compatible.
+        return false;
+    }
+}, _TokensController_getProvider = function _TokensController_getProvider(networkClientId) {
+    return new Web3Provider(networkClientId
+        ? this.messagingSystem.call('NetworkController:getNetworkClientById', networkClientId).provider
+        : __classPrivateFieldGet(this, _TokensController_provider, "f"));
+}, _TokensController_createEthersContract = function _TokensController_createEthersContract(tokenAddress, abi, networkClientId) {
+    const web3provider = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getProvider).call(this, networkClientId);
+    const tokenContract = new Contract(tokenAddress, abi, web3provider);
+    return tokenContract;
+}, _TokensController_generateRandomId = function _TokensController_generateRandomId() {
+    return random();
+}, _TokensController_getNewAllTokensState = function _TokensController_getNewAllTokensState(params) {
+    const { newTokens, newIgnoredTokens, newDetectedTokens, interactingAddress, interactingChainId, } = params;
+    const { allTokens, allIgnoredTokens, allDetectedTokens } = this.state;
+    const userAddressToAddTokens = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getAddressOrSelectedAddress).call(this, interactingAddress);
+    const chainIdToAddTokens = interactingChainId ?? __classPrivateFieldGet(this, _TokensController_chainId, "f");
+    let newAllTokens = allTokens;
+    if (newTokens?.length ||
+        (newTokens &&
+            allTokens &&
+            allTokens[chainIdToAddTokens] &&
+            allTokens[chainIdToAddTokens][userAddressToAddTokens])) {
+        const networkTokens = allTokens[chainIdToAddTokens];
+        const newNetworkTokens = {
+            ...networkTokens,
+            ...{ [userAddressToAddTokens]: newTokens },
+        };
+        newAllTokens = {
+            ...allTokens,
+            ...{ [chainIdToAddTokens]: newNetworkTokens },
+        };
+    }
+    let newAllIgnoredTokens = allIgnoredTokens;
+    if (newIgnoredTokens?.length ||
+        (newIgnoredTokens &&
+            allIgnoredTokens &&
+            allIgnoredTokens[chainIdToAddTokens] &&
+            allIgnoredTokens[chainIdToAddTokens][userAddressToAddTokens])) {
+        const networkIgnoredTokens = allIgnoredTokens[chainIdToAddTokens];
+        const newIgnoredNetworkTokens = {
+            ...networkIgnoredTokens,
+            ...{ [userAddressToAddTokens]: newIgnoredTokens },
+        };
+        newAllIgnoredTokens = {
+            ...allIgnoredTokens,
+            ...{ [chainIdToAddTokens]: newIgnoredNetworkTokens },
+        };
+    }
+    let newAllDetectedTokens = allDetectedTokens;
+    if (newDetectedTokens?.length ||
+        (newDetectedTokens &&
+            allDetectedTokens &&
+            allDetectedTokens[chainIdToAddTokens] &&
+            allDetectedTokens[chainIdToAddTokens][userAddressToAddTokens])) {
+        const networkDetectedTokens = allDetectedTokens[chainIdToAddTokens];
+        const newDetectedNetworkTokens = {
+            ...networkDetectedTokens,
+            ...{ [userAddressToAddTokens]: newDetectedTokens },
+        };
+        newAllDetectedTokens = {
+            ...allDetectedTokens,
+            ...{ [chainIdToAddTokens]: newDetectedNetworkTokens },
+        };
+    }
+    return { newAllTokens, newAllIgnoredTokens, newAllDetectedTokens };
+}, _TokensController_getAddressOrSelectedAddress = function _TokensController_getAddressOrSelectedAddress(address) {
+    if (address) {
+        return address;
+    }
+    return __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getSelectedAddress).call(this);
+}, _TokensController_isInteractingWithWallet = function _TokensController_isInteractingWithWallet(address) {
+    const selectedAddress = __classPrivateFieldGet(this, _TokensController_instances, "m", _TokensController_getSelectedAddress).call(this);
+    return selectedAddress === address;
+}, _TokensController_requestApproval = async function _TokensController_requestApproval(suggestedAssetMeta) {
+    return this.messagingSystem.call('ApprovalController:addRequest', {
+        id: suggestedAssetMeta.id,
+        origin: ORIGIN_METAMASK,
+        type: ApprovalType.WatchAsset,
+        requestData: {
+            id: suggestedAssetMeta.id,
+            interactingAddress: suggestedAssetMeta.interactingAddress,
+            asset: {
+                address: suggestedAssetMeta.asset.address,
+                decimals: suggestedAssetMeta.asset.decimals,
+                symbol: suggestedAssetMeta.asset.symbol,
+                image: suggestedAssetMeta.asset.image || null,
+            },
+        },
+    }, true);
+}, _TokensController_getSelectedAccount = function _TokensController_getSelectedAccount() {
+    return this.messagingSystem.call('AccountsController:getSelectedAccount');
+}, _TokensController_getSelectedAddress = function _TokensController_getSelectedAddress() {
+    // If the address is not defined (or empty), we fallback to the currently selected account's address
+    const account = this.messagingSystem.call('AccountsController:getAccount', __classPrivateFieldGet(this, _TokensController_selectedAccountId, "f"));
+    return account?.address || '';
+};
+export default TokensController;
 //# sourceMappingURL=TokensController.mjs.map