@ledgerhq/cryptoassets 13.30.0 → 13.31.0-nightly.1

package/src/tokens.ts

@@ -1,179 +1,61 @@
-import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import cardanoNativeTokens, { CardanoNativeToken } from "./data/cardanoNative";
-import { findCryptoCurrencyById, getCryptoCurrencyById } from "./currencies";
-import jettonTokens, { TonJettonToken } from "./data/ton-jetton";
-import { tokens as sepoliaTokens } from "./data/evm/11155111";
-import stellarTokens, { StellarToken } from "./data/stellar";
-import hederaTokens, { HederaToken } from "./data/hedera";
-import vechainTokens, { Vip180Token } from "./data/vip180";
-import esdttokens, { MultiversXESDTToken } from "./data/esdt";
-import asatokens, { AlgorandASAToken } from "./data/asa";
-import { tokens as polygonTokens } from "./data/evm/137";
-import { tokens as sonicTokens } from "./data/evm/146";
-import { tokens as coreTokens } from "./data/evm/1116";
-import trc10tokens, { TRC10Token } from "./data/trc10";
-import trc20tokens, { TRC20Token } from "./data/trc20";
-import { tokens as mainnetTokens } from "./data/evm/1";
-import { tokens as bnbTokens } from "./data/evm/56";
-import { tokens as celoTokens } from "./data/evm/42220";
-import filecoinTokens from "./data/filecoin-erc20";
-import spltokens, { SPLToken } from "./data/spl";
-import aptCoinTokens, { AptosToken as AptosCoinToken } from "./data/apt_coin";
-import aptFATokens, { AptosToken as AptosFAToken } from "./data/apt_fungible_asset";
-import suitokens, { SuiToken } from "./data/sui";
-import { ERC20Token } from "./types";
-import { getEnv } from "@ledgerhq/live-env";
-
-const emptyArray = [];
-const tokensArray: TokenCurrency[] = [];
-const tokensArrayWithDelisted: TokenCurrency[] = [];
-const tokensByCryptoCurrency: Record<string, TokenCurrency[]> = {};
-const tokensByCryptoCurrencyWithDelisted: Record<string, TokenCurrency[]> = {};
-const tokensById: Record<string, TokenCurrency> = {};
-const tokensByTicker: Record<string, TokenCurrency> = {};
-const tokensByAddress: Record<string, TokenCurrency> = {};
-const tokensByCurrencyAddress: Record<string, TokenCurrency> = {};
-const tokenListHashes = new Set();
-
-// Ethereum mainnet tokens
-addTokens(mainnetTokens.map(convertERC20));
-// Ethereum Sepolia testnet tokens
-addTokens(sepoliaTokens.map(convertERC20));
-// Polygon tokens
-addTokens(polygonTokens.map(convertERC20));
-// Hedera tokens
-addTokens(hederaTokens.map(convertHederaTokens));
-// Binance Smart Chain tokens
-addTokens(bnbTokens.map(convertERC20));
-// Tron tokens
-addTokens(trc10tokens.map(convertTRONTokens("trc10")));
-addTokens(trc20tokens.map(convertTRONTokens("trc20")));
-// Algoland tokens
-addTokens(asatokens.map(convertAlgorandASATokens));
-// MultiversX tokens
-addTokens(esdttokens.map(convertMultiversXESDTTokens));
-// Cardano tokens
-addTokens(cardanoNativeTokens.map(convertCardanoNativeTokens));
-// Stellar tokens
-addTokens(stellarTokens.map(convertStellarTokens));
-// VeChain tokens
-addTokens(vechainTokens.map(convertVechainToken));
-// Ton tokens
-addTokens(jettonTokens.map(convertJettonToken));
-// Filecoin tokens
-addTokens(filecoinTokens.map(convertERC20));
-// Solana tokens
-addTokens(spltokens.map(convertSplTokens));
-// Sonic
-addTokens(sonicTokens.map(convertERC20));
-// Core
-addTokens(coreTokens.map(convertERC20));
-// Celo
-addTokens(celoTokens.map(convertERC20));
-
-if (getEnv("SUI_ENABLE_TOKENS")) {
-  // Sui tokens
-  addTokens(suitokens.map(convertSuiTokens));
-}
-
-if (getEnv("APTOS_ENABLE_TOKENS")) {
-  // Aptos Legacy Coin tokens
-  addTokens(aptCoinTokens.map(convertAptCoinTokens));
-  // Aptos fungible assets tokens
-  addTokens(aptFATokens.map(convertAptFaTokens));
-}
-
-type TokensListOptions = {
-  withDelisted: boolean;
-};
-
-const defaultTokenListOptions: TokensListOptions = {
-  withDelisted: false,
-};
-
-export function createTokenHash(token: TokenCurrency): string {
-  return token
-    ? `${token.id}${token.contractAddress}${token.delisted}${token.ticker}${token.ledgerSignature}`
-    : "";
-}
-
 /**
- * Only for jest purpose, clean object to be empty
- * @param obj
+ * BEWARE: this file will progressively disappear when https://github.com/LedgerHQ/ledger-live/pull/11905 lands
  */
-const __clearObject = (obj: Record<string, TokenCurrency | TokenCurrency[]>): void => {
-  for (const key in obj) {
-    delete obj[key];
-  }
-};
-/**
- * Only for jest purpose, clear all the init list
- */
-export function __clearAllLists(): void {
-  tokensArray.length = 0;
-  tokensArrayWithDelisted.length = 0;
-  __clearObject(tokensByCryptoCurrency);
-  __clearObject(tokensByCryptoCurrencyWithDelisted);
-  __clearObject(tokensById);
-  __clearObject(tokensByTicker);
-  __clearObject(tokensByAddress);
-  __clearObject(tokensByCurrencyAddress);
-  tokenListHashes.clear();
-}
-
-/**
- *
- */
-export function listTokens(options?: Partial<TokensListOptions>): TokenCurrency[] {
-  const { withDelisted } = { ...defaultTokenListOptions, ...options };
-  return withDelisted ? tokensArrayWithDelisted : tokensArray;
-}
 
-/**
- *
- */
-export function listTokensForCryptoCurrency(
-  currency: CryptoCurrency,
-  options?: Partial<TokensListOptions>,
-): TokenCurrency[] {
-  const { withDelisted } = { ...defaultTokenListOptions, ...options };
-  if (withDelisted) {
-    return tokensByCryptoCurrencyWithDelisted[currency.id] || emptyArray;
-  }
-
-  return tokensByCryptoCurrency[currency.id] || emptyArray;
-}
-
-/**
- *
- */
-export function listTokenTypesForCryptoCurrency(currency: CryptoCurrency): string[] {
-  return currency.tokenTypes || [];
-}
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import {
+  addTokens,
+  listTokensLegacy,
+  listTokensForCryptoCurrencyLegacy,
+  type TokensListOptions,
+  __clearAllLists,
+  convertERC20,
+  convertAlgorandASATokens,
+  convertVechainToken,
+  convertTRONTokens,
+  convertMultiversXESDTTokens,
+  convertCardanoNativeTokens,
+  convertStellarTokens,
+  convertJettonToken,
+  convertSplTokens,
+  convertSuiTokens,
+  convertAptCoinTokens,
+  convertAptFaTokens,
+  convertHederaTokens,
+} from "./legacy/legacy-utils";
+import { tokensByCurrencyAddress, tokensById } from "./legacy/legacy-state";
+import { initializeLegacyTokens } from "./legacy/legacy-data";
+
+export {
+  addTokens,
+  convertERC20,
+  convertAlgorandASATokens,
+  convertVechainToken,
+  convertTRONTokens,
+  convertMultiversXESDTTokens,
+  convertCardanoNativeTokens,
+  convertStellarTokens,
+  convertJettonToken,
+  convertSplTokens,
+  convertSuiTokens,
+  convertAptCoinTokens,
+  convertAptFaTokens,
+  convertHederaTokens,
+  __clearAllLists,
+};
 
-/**
- *
- */
-export function findTokenByTicker(ticker: string): TokenCurrency | undefined {
-  return tokensByTicker[ticker];
-}
+initializeLegacyTokens(addTokens);
 
 /**
- *
+ * @deprecated Please do `await getCryptoAssetsStore().findTokenById(id)` instead to anticipate https://github.com/LedgerHQ/ledger-live/pull/11905
  */
 export function findTokenById(id: string): TokenCurrency | undefined {
   return tokensById[id];
 }
 
-let deprecatedDisplayed = false;
-export function findTokenByAddress(address: string): TokenCurrency | undefined {
-  if (!deprecatedDisplayed) {
-    deprecatedDisplayed = true;
-    console.warn("findTokenByAddress is deprecated. use findTokenByAddressInCurrency");
-  }
-  return tokensByAddress[address.toLowerCase()];
-}
-
+/**
+ * @deprecated Please do `await getCryptoAssetsStore().findTokenByAddress(address, currencyId)` instead to anticipate https://github.com/LedgerHQ/ledger-live/pull/11905
+ */
 export function findTokenByAddressInCurrency(
   address: string,
   currencyId: string,
@@ -182,12 +64,12 @@ export function findTokenByAddressInCurrency(
 }
 
 /**
- *
+ * @deprecated This function will be removed when https://github.com/LedgerHQ/ledger-live/pull/11905 lands
  */
 export const hasTokenId = (id: string): boolean => id in tokensById;
 
 /**
- *
+ * @deprecated Please use `await getCryptoAssetsStore().findTokenById(id)` instead to anticipate https://github.com/LedgerHQ/ledger-live/pull/11905
  */
 export function getTokenById(id: string): TokenCurrency {
   const currency = findTokenById(id);
@@ -199,431 +81,28 @@ export function getTokenById(id: string): TokenCurrency {
   return currency;
 }
 
-function removeTokenFromArray(array: TokenCurrency[], tokenId: string) {
-  if (array && array.length > 0) {
-    const index = array.findIndex(currentToken => currentToken && currentToken.id === tokenId);
-    if (index === -1) return array;
-    return array.splice(index, 1);
-  }
-}
-
-function removeTokenFromRecord(record: Record<string, TokenCurrency>, key: string) {
-  tokenListHashes.delete(record[key]);
-  delete record[key];
-}
-
 /**
- * Delete previous token entry to all array
- * @param token
+ * @deprecated This function is deprecated. See https://ledgerhq.atlassian.net/browse/LIVE-21646
+ * Tokens will no longer be listable as we moved to DaDa API when possible / or CAL API directly.
  */
-function removeTokenFromAllLists(token: TokenCurrency) {
-  const { id, contractAddress, parentCurrency, ticker } = token;
-  const lowCaseContract = contractAddress.toLowerCase();
-
-  removeTokenFromRecord(tokensById, id);
-  removeTokenFromRecord(tokensByCurrencyAddress, parentCurrency.id + ":" + lowCaseContract);
-  removeTokenFromRecord(tokensByAddress, lowCaseContract);
-  removeTokenFromRecord(tokensByTicker, ticker);
-  removeTokenFromArray(tokensArray, id);
-  removeTokenFromArray(tokensArrayWithDelisted, id);
-  removeTokenFromArray(tokensByCryptoCurrency[parentCurrency.id], id);
-  removeTokenFromArray(tokensByCryptoCurrencyWithDelisted[parentCurrency.id], id);
-}
-
-export function addTokens(list: (TokenCurrency | undefined)[]): void {
-  list.forEach(token => {
-    if (!token) return;
-    const tokenHash = createTokenHash(token);
-    if (tokenListHashes.has(tokenHash)) return;
-
-    /**
-     * We clean all the reference of an existing token, if an hash doesn't  match.
-     * Like this we can update any change from a already added token coming from Dynamic CAL
-     * and maintain it up to date without having to release a new version of LLD or LLM
-     */
-    const { id, contractAddress, parentCurrency, delisted, ticker } = token;
-    if (tokensById[id]) removeTokenFromAllLists(token);
-    const lowCaseContract = contractAddress.toLowerCase();
-
-    if (!delisted) tokensArray.push(token);
-    tokensArrayWithDelisted.push(token);
-    tokensById[id] = token;
-
-    if (!tokensByTicker[ticker]) {
-      tokensByTicker[ticker] = token;
-    }
-
-    tokensByAddress[lowCaseContract] = token;
-    tokensByCurrencyAddress[parentCurrency.id + ":" + lowCaseContract] = token;
-
-    if (!(parentCurrency.id in tokensByCryptoCurrency)) {
-      tokensByCryptoCurrency[parentCurrency.id] = [];
-    }
-
-    if (!(parentCurrency.id in tokensByCryptoCurrencyWithDelisted)) {
-      tokensByCryptoCurrencyWithDelisted[parentCurrency.id] = [];
-    }
-
-    if (!delisted) tokensByCryptoCurrency[parentCurrency.id].push(token);
-    tokensByCryptoCurrencyWithDelisted[parentCurrency.id].push(token);
-
-    tokenListHashes.add(tokenHash);
-  });
-}
-
-export function convertERC20([
-  parentCurrencyId,
-  token,
-  ticker,
-  magnitude,
-  name,
-  ledgerSignature,
-  contractAddress,
-  disableCountervalue,
-  delisted,
-]: ERC20Token): TokenCurrency | undefined {
-  const parentCurrency = findCryptoCurrencyById(parentCurrencyId);
-
-  if (!parentCurrency) {
-    return;
-  }
-
-  const tokenType = parentCurrencyId === "bsc" ? "bep20" : "erc20";
-
-  return {
-    type: "TokenCurrency",
-    id: `${parentCurrencyId}/${tokenType}/${token}`,
-    ledgerSignature,
-    contractAddress,
-    parentCurrency,
-    tokenType,
-    name,
-    ticker,
-    delisted,
-    disableCountervalue: !!parentCurrency.isTestnetFor || !!disableCountervalue,
-    units: [
-      {
-        name,
-        code: ticker,
-        magnitude,
-      },
-    ],
-  };
-}
-
-export function convertAlgorandASATokens([
-  id,
-  abbr,
-  name,
-  contractAddress,
-  precision,
-]: AlgorandASAToken): TokenCurrency {
-  const parentCurrency = getCryptoCurrencyById("algorand");
-
-  return {
-    type: "TokenCurrency",
-    id: `algorand/asa/${id}`,
-    contractAddress,
-    parentCurrency,
-    tokenType: "asa",
-    name,
-    ticker: abbr,
-    disableCountervalue: false,
-    units: [
-      {
-        name,
-        code: abbr,
-        magnitude: precision,
-      },
-    ],
-  };
-}
-
-export function convertVechainToken([
-  tokenIdenfitier,
-  ticker,
-  name,
-  contractAddress,
-  precision,
-]: Vip180Token): TokenCurrency {
-  return {
-    type: "TokenCurrency",
-    id: `vechain/vip180/${tokenIdenfitier}`,
-    contractAddress: contractAddress,
-    parentCurrency: getCryptoCurrencyById("vechain"),
-    tokenType: "vip180",
-    name,
-    ticker,
-    disableCountervalue: false,
-    units: [
-      {
-        name,
-        code: ticker,
-        magnitude: precision,
-      },
-    ],
-  };
-}
-
-export function convertTRONTokens(type: "trc10" | "trc20") {
-  return ([id, abbr, name, contractAddress, precision, delisted, ledgerSignature]:
-    | TRC10Token
-    | TRC20Token): TokenCurrency => {
-    const parentCurrency = getCryptoCurrencyById("tron");
-
-    return {
-      type: "TokenCurrency",
-      id: `tron/${type}/${id}`,
-      contractAddress,
-      parentCurrency,
-      tokenType: type,
-      name,
-      ticker: abbr,
-      delisted,
-      disableCountervalue: false,
-      ledgerSignature,
-      units: [
-        {
-          name,
-          code: abbr,
-          magnitude: precision,
-        },
-      ],
-    };
-  };
-}
-
-export function convertMultiversXESDTTokens([
-  ticker,
-  identifier,
-  decimals,
-  signature,
-  name,
-]: MultiversXESDTToken): TokenCurrency {
-  const MULTIVERSX_ESDT_CONTRACT = "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzllls8a5w6u";
-  // const parentCurrency = getCryptoCurrencyById("multiversx");
-  const parentCurrency = getCryptoCurrencyById("elrond");
-
-  return {
-    type: "TokenCurrency",
-    id: `multiversx/esdt/${identifier}`,
-    contractAddress: MULTIVERSX_ESDT_CONTRACT,
-    ledgerSignature: signature,
-    parentCurrency,
-    tokenType: "esdt",
-    disableCountervalue: false,
-    name,
-    ticker,
-    units: [
-      {
-        name,
-        code: name,
-        magnitude: decimals,
-      },
-    ],
-  };
-}
-
-export function convertSplTokens([
-  id,
-  network,
-  name,
-  symbol,
-  address,
-  decimals,
-]: SPLToken): TokenCurrency {
-  return {
-    type: "TokenCurrency",
-    id,
-    contractAddress: address,
-    parentCurrency: getCryptoCurrencyById(network),
-    name,
-    tokenType: "spl",
-    ticker: symbol,
-    disableCountervalue: false,
-    units: [
-      {
-        name,
-        code: symbol,
-        magnitude: decimals,
-      },
-    ],
-  };
-}
-function convertAptosTokens(
-  tokenType: "coin" | "fungible_asset",
-  [id, ticker, name, address, decimals, delisted]: AptosCoinToken | AptosFAToken,
-): TokenCurrency {
-  return {
-    type: "TokenCurrency",
-    id,
-    contractAddress: address,
-    parentCurrency: getCryptoCurrencyById("aptos"),
-    name,
-    tokenType,
-    ticker,
-    disableCountervalue: false,
-    delisted,
-    units: [
-      {
-        name,
-        code: ticker,
-        magnitude: decimals,
-      },
-    ],
-  };
-}
-
-export function convertAptCoinTokens(token: AptosCoinToken): TokenCurrency {
-  return convertAptosTokens("coin", token);
-}
-
-export function convertAptFaTokens(token: AptosFAToken): TokenCurrency {
-  return convertAptosTokens("fungible_asset", token);
-}
-
-export function convertSuiTokens([id, name, ticker, address, decimals]: SuiToken): TokenCurrency {
-  return {
-    type: "TokenCurrency",
-    id,
-    contractAddress: address,
-    parentCurrency: getCryptoCurrencyById("sui"),
-    name,
-    tokenType: "sui",
-    ticker,
-    disableCountervalue: false,
-    units: [
-      {
-        name,
-        code: ticker,
-        magnitude: decimals,
-      },
-    ],
-  };
-}
-
-function convertHederaTokens([
-  id,
-  tokenId,
-  name,
-  ticker,
-  network,
-  decimals,
-  delisted,
-]: HederaToken): TokenCurrency {
-  return {
-    type: "TokenCurrency",
-    id,
-    contractAddress: tokenId,
-    parentCurrency: getCryptoCurrencyById(network),
-    tokenType: "hts",
-    name,
-    ticker,
-    delisted,
-    disableCountervalue: false,
-    units: [
-      {
-        name,
-        code: ticker,
-        magnitude: decimals,
-      },
-    ],
-  };
-}
-
-export function convertCardanoNativeTokens([
-  parentCurrencyId,
-  policyId,
-  assetName,
-  name,
-  ticker,
-  decimals,
-  delisted,
-]: CardanoNativeToken): TokenCurrency | undefined {
-  const assetId = policyId + assetName;
-
-  const parentCurrency = getCryptoCurrencyById(parentCurrencyId);
-
-  if (!parentCurrency) {
-    return;
-  }
-
-  return {
-    type: "TokenCurrency",
-    id: `${parentCurrencyId}/native/${assetId}`,
-    // Tracking and accounting of native tokens is natively supported by cardano ledger.
-    // As there's no contract for native tokens, using unique assetId in place of contractAddress
-    contractAddress: assetId,
-    parentCurrency,
-    tokenType: "native",
-    name,
-    ticker,
-    delisted,
-    disableCountervalue: false,
-    units: [
-      {
-        name,
-        code: ticker,
-        magnitude: decimals,
-      },
-    ],
-  };
+export function listTokens(options?: Partial<TokensListOptions>): TokenCurrency[] {
+  return listTokensLegacy(options);
 }
 
-export function convertStellarTokens([
-  assetCode,
-  assetIssuer,
-  assetType,
-  name,
-  precision,
-]: StellarToken): TokenCurrency {
-  const parentCurrency = getCryptoCurrencyById("stellar");
-
-  // FIXME: to be discussed with CAL service as values are Uppercase IRL
-  return {
-    type: "TokenCurrency",
-    id: `stellar/asset/${assetCode.toUpperCase()}:${assetIssuer.toUpperCase()}`,
-    contractAddress: assetIssuer.toUpperCase(),
-    parentCurrency,
-    tokenType: assetType,
-    name,
-    ticker: assetCode,
-    disableCountervalue: false,
-    units: [
-      {
-        name,
-        code: assetCode,
-        magnitude: precision,
-      },
-    ],
-  };
+/**
+ * @deprecated This function is deprecated. See https://ledgerhq.atlassian.net/browse/LIVE-21646
+ * Tokens will no longer be listable as we moved to DaDa API when possible / or CAL API directly.
+ */
+export function listTokensForCryptoCurrency(
+  currency: CryptoCurrency,
+  options?: Partial<TokensListOptions>,
+): TokenCurrency[] {
+  return listTokensForCryptoCurrencyLegacy(currency, options);
 }
 
-export function convertJettonToken([address, name, ticker, magnitude, delisted]: TonJettonToken):
-  | TokenCurrency
-  | undefined {
-  const parentCurrency = findCryptoCurrencyById("ton");
-
-  if (!parentCurrency) {
-    return;
-  }
-
-  return {
-    type: "TokenCurrency",
-    id: "ton/jetton/" + address.toLocaleLowerCase(),
-    contractAddress: address,
-    parentCurrency,
-    tokenType: "jetton",
-    name,
-    ticker,
-    delisted,
-    disableCountervalue: false,
-    units: [
-      {
-        name,
-        code: ticker,
-        magnitude,
-      },
-    ],
-  };
+/**
+ * @deprecated Prefer using currency.tokenTypes directly.
+ */
+export function listTokenTypesForCryptoCurrency(currency: CryptoCurrency): string[] {
+  return currency.tokenTypes || [];
 }