1
0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-12-12 20:57:12 +01:00
metamask-extension/app/scripts/controllers/detect-tokens.js

283 lines
8.4 KiB
JavaScript
Raw Normal View History

import { warn } from 'loglevel';
import { MINUTE } from '../../../shared/constants/time';
import { CHAIN_IDS } from '../../../shared/constants/network';
import { STATIC_MAINNET_TOKEN_LIST } from '../../../shared/constants/tokens';
import { isTokenDetectionEnabledForNetwork } from '../../../shared/modules/network.utils';
import { isEqualCaseInsensitive } from '../../../shared/modules/string-utils';
import {
AssetType,
TokenStandard,
} from '../../../shared/constants/transaction';
import { EVENT, EVENT_NAMES } from '../../../shared/constants/metametrics';
2018-06-27 22:29:24 +02:00
// By default, poll every 3 minutes
const DEFAULT_INTERVAL = MINUTE * 3;
2018-06-27 22:29:24 +02:00
/**
* A controller that polls for token exchange
* rates based on a user's current token list
*/
export default class DetectTokensController {
2018-06-27 22:29:24 +02:00
/**
* Creates a DetectTokensController
*
* @param {object} [config] - Options to configure controller
* @param config.interval
* @param config.preferences
* @param config.network
* @param config.keyringMemStore
* @param config.tokenList
* @param config.tokensController
* @param config.assetsContractController
* @param config.trackMetaMetricsEvent
2018-06-27 22:29:24 +02:00
*/
2020-11-03 00:41:28 +01:00
constructor({
interval = DEFAULT_INTERVAL,
preferences,
network,
keyringMemStore,
tokenList,
tokensController,
assetsContractController = null,
trackMetaMetricsEvent,
2020-11-03 00:41:28 +01:00
} = {}) {
this.assetsContractController = assetsContractController;
this.tokensController = tokensController;
this.preferences = preferences;
this.interval = interval;
this.network = network;
this.keyringMemStore = keyringMemStore;
this.tokenList = tokenList;
this.useTokenDetection =
this.preferences?.store.getState().useTokenDetection;
this.selectedAddress = this.preferences?.store.getState().selectedAddress;
this.tokenAddresses = this.tokensController?.state.tokens.map((token) => {
return token.address;
});
this.hiddenTokens = this.tokensController?.state.ignoredTokens;
this.detectedTokens = this.tokensController?.state.detectedTokens;
this.chainId = this.getChainIdFromNetworkStore(network);
this._trackMetaMetricsEvent = trackMetaMetricsEvent;
preferences?.store.subscribe(({ selectedAddress, useTokenDetection }) => {
if (
this.selectedAddress !== selectedAddress ||
this.useTokenDetection !== useTokenDetection
) {
this.selectedAddress = selectedAddress;
this.useTokenDetection = useTokenDetection;
this.restartTokenDetection({ selectedAddress });
}
});
tokensController?.subscribe(
({ tokens = [], ignoredTokens = [], detectedTokens = [] }) => {
this.tokenAddresses = tokens.map((token) => {
return token.address;
});
this.hiddenTokens = ignoredTokens;
this.detectedTokens = detectedTokens;
},
);
}
/**
* For each token in the tokenlist provided by the TokenListController, check selectedAddress balance.
*
* @param options
* @param options.selectedAddress - the selectedAddress against which to detect for token balances
* @param options.chainId - the chainId against which to detect for token balances
2018-06-27 22:29:24 +02:00
*/
async detectNewTokens({ selectedAddress, chainId } = {}) {
const addressAgainstWhichToDetect = selectedAddress ?? this.selectedAddress;
const chainIdAgainstWhichToDetect =
chainId ?? this.getChainIdFromNetworkStore(this._network);
if (!this.isActive) {
return;
}
if (!isTokenDetectionEnabledForNetwork(chainIdAgainstWhichToDetect)) {
return;
}
if (
!this.useTokenDetection &&
chainIdAgainstWhichToDetect !== CHAIN_IDS.MAINNET
) {
return;
}
const isTokenDetectionInactiveInMainnet =
!this.useTokenDetection &&
chainIdAgainstWhichToDetect === CHAIN_IDS.MAINNET;
const { tokenList } = this._tokenList.state;
const tokenListUsed = isTokenDetectionInactiveInMainnet
? STATIC_MAINNET_TOKEN_LIST
: tokenList;
const tokensToDetect = [];
for (const tokenAddress in tokenListUsed) {
2020-11-03 00:41:28 +01:00
if (
!this.tokenAddresses.find((address) =>
isEqualCaseInsensitive(address, tokenAddress),
) &&
!this.hiddenTokens.find((address) =>
isEqualCaseInsensitive(address, tokenAddress),
) &&
!this.detectedTokens.find(({ address }) =>
isEqualCaseInsensitive(address, tokenAddress),
)
2020-11-03 00:41:28 +01:00
) {
tokensToDetect.push(tokenAddress);
2018-07-13 02:43:43 +02:00
}
2018-06-27 22:29:24 +02:00
}
const sliceOfTokensToDetect = [
tokensToDetect.slice(0, 1000),
tokensToDetect.slice(1000, tokensToDetect.length - 1),
];
for (const tokensSlice of sliceOfTokensToDetect) {
let result;
try {
result = await this.assetsContractController.getBalancesInSingleCall(
addressAgainstWhichToDetect,
tokensSlice,
);
} catch (error) {
warn(
`MetaMask - DetectTokensController single call balance fetch failed`,
error,
);
return;
2019-01-22 19:23:11 +01:00
}
const tokensWithBalance = [];
const eventTokensDetails = [];
if (result) {
const nonZeroTokenAddresses = Object.keys(result);
for (const nonZeroTokenAddress of nonZeroTokenAddresses) {
const { address, symbol, decimals } =
tokenListUsed[nonZeroTokenAddress];
eventTokensDetails.push(`${symbol} - ${address}`);
tokensWithBalance.push({
address,
symbol,
decimals,
});
}
if (tokensWithBalance.length > 0) {
this._trackMetaMetricsEvent({
event: EVENT_NAMES.TOKEN_DETECTED,
category: EVENT.CATEGORIES.WALLET,
properties: {
tokens: eventTokensDetails,
token_standard: TokenStandard.ERC20,
asset_type: AssetType.token,
},
});
await this.tokensController.addDetectedTokens(tokensWithBalance, {
selectedAddress: addressAgainstWhichToDetect,
chainId: chainIdAgainstWhichToDetect,
});
}
}
}
2018-06-27 22:29:24 +02:00
}
/**
* Restart token detection polling period and call detectNewTokens
* in case of address change or user session initialization.
*
* @param options
* @param options.selectedAddress - the selectedAddress against which to detect for token balances
* @param options.chainId - the chainId against which to detect for token balances
*/
restartTokenDetection({ selectedAddress, chainId } = {}) {
const addressAgainstWhichToDetect = selectedAddress ?? this.selectedAddress;
const chainIdAgainstWhichToDetect = chainId ?? this.chainId;
if (!(this.isActive && addressAgainstWhichToDetect)) {
return;
}
this.detectNewTokens({
selectedAddress: addressAgainstWhichToDetect,
chainId: chainIdAgainstWhichToDetect,
});
this.interval = DEFAULT_INTERVAL;
}
getChainIdFromNetworkStore(network) {
return network?.store.getState().provider.chainId;
}
/* eslint-disable accessor-pairs */
2018-06-27 22:29:24 +02:00
/**
* @type {number}
2018-06-27 22:29:24 +02:00
*/
2020-11-03 00:41:28 +01:00
set interval(interval) {
this._handle && clearInterval(this._handle);
if (!interval) {
return;
}
this._handle = setInterval(() => {
this.detectNewTokens();
}, interval);
2018-06-27 22:29:24 +02:00
}
/**
* @type {object}
2018-06-27 22:29:24 +02:00
*/
2020-11-03 00:41:28 +01:00
set network(network) {
if (!network) {
return;
}
this._network = network;
this._network.store.subscribe(() => {
if (this.chainId !== this.getChainIdFromNetworkStore(network)) {
const chainId = this.getChainIdFromNetworkStore(network);
this.chainId = chainId;
this.restartTokenDetection({ chainId: this.chainId });
}
});
2018-06-27 22:29:24 +02:00
}
/**
2018-07-20 01:46:46 +02:00
* In setter when isUnlocked is updated to true, detectNewTokens and restart polling
*
* @type {object}
2018-07-20 01:46:46 +02:00
*/
2020-11-03 00:41:28 +01:00
set keyringMemStore(keyringMemStore) {
if (!keyringMemStore) {
return;
}
this._keyringMemStore = keyringMemStore;
2018-07-20 01:46:46 +02:00
this._keyringMemStore.subscribe(({ isUnlocked }) => {
if (this.isUnlocked !== isUnlocked) {
this.isUnlocked = isUnlocked;
if (isUnlocked) {
this.restartTokenDetection();
}
}
});
2018-07-20 01:46:46 +02:00
}
2018-07-21 22:03:31 +02:00
/**
* @type {object}
*/
set tokenList(tokenList) {
if (!tokenList) {
return;
}
this._tokenList = tokenList;
}
/**
* Internal isActive state
*
* @type {object}
*/
2020-11-03 00:41:28 +01:00
get isActive() {
return this.isOpen && this.isUnlocked;
2018-07-21 01:58:03 +02:00
}
/* eslint-enable accessor-pairs */
2018-06-27 22:29:24 +02:00
}