Page MenuHomePhabricator
Files F13115908

No OneTemporary
Actions

View Options

diff --git a/cashtab/src/config/tokenBlacklist.ts b/cashtab/src/config/tokenBlacklist.ts
index 4afe8c304..a521f3231 100644
--- a/cashtab/src/config/tokenBlacklist.ts
+++ b/cashtab/src/config/tokenBlacklist.ts
@@ -1,1560 +1,1560 @@
// Copyright (c) 2023 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
import {
cashtabSettingsValidation,
supportedFiatCurrencies,
} from 'config/CashtabSettings';
// Get names of fiat currencies
const fiatObjects = Object.keys(supportedFiatCurrencies);
const fiatNames: string[] = [];
const fiatSymbols: string[] = [];
for (const i in fiatObjects) {
fiatNames.push(supportedFiatCurrencies[fiatObjects[i]].name);
fiatSymbols.push(supportedFiatCurrencies[fiatObjects[i]].symbol);
}
interface CreateTokenBlacklist {
coingeckoTop500Tickers: string[];
coingeckoTop500Names: string[];
coingeckoTop500Ids: string[];
bannedTickers: string[];
bannedNames: string[];
fiatTickers: string[];
fiatNames: string[];
fiatSymbols: string[];
}
const tokenBlacklist: CreateTokenBlacklist = {
coingeckoTop500Tickers: [
'btc',
'eth',
'usdt',
'bnb',
'usdc',
'xrp',
'busd',
'ada',
'sol',
'doge',
'dot',
'matic',
'steth',
'shib',
'dai',
'trx',
'wbtc',
'avax',
'uni',
'okb',
'leo',
'ltc',
'atom',
'link',
'etc',
'ftt',
'xlm',
'cro',
'qnt',
'xmr',
'near',
'algo',
'bch',
'vet',
'lunc',
'flow',
'fil',
'hbar',
'ape',
'egld',
'wbt',
'frax',
'icp',
'apt',
'aave',
'xtz',
'xcn',
'ht',
'tkx',
'sand',
'mana',
'ldo',
'eos',
'theta',
'chz',
'cusdc',
'kcs',
'bsv',
'usdp',
'axs',
'tusd',
'mkr',
'evmos',
'btt',
'usdd',
'xec',
'miota',
'ethw',
'klay',
'zec',
'cdai',
'gt',
'cake',
'grt',
'btse',
'neo',
'osmo',
'ceth',
'hnt',
'snx',
'nexo',
'ftm',
'ar',
'xrd',
'paxg',
'cspr',
'crv',
'kava',
'bit',
'ens',
'twt',
'dash',
'rune',
'zil',
'rpl',
'xdc',
'enj',
'bat',
'xaut',
'stx',
'fxs',
'cel',
'mina',
'dcr',
'dfi',
'amp',
'luna',
'rvn',
'ustc',
'cusdt',
'cvx',
'1inch',
'mex',
'comp',
'omi',
'hot',
'xem',
'gusd',
'celo',
'waves',
'imx',
'btg',
'lrc',
'ksm',
'rose',
'nxm',
'tfuel',
'gmx',
'gno',
'ohm',
'gmt',
'qtum',
'sushi',
'safemoon',
'okt',
'srm',
'iost',
'glm',
'jst',
'hbtc',
'gala',
'kda',
'cvxcrv',
'iotx',
'rsr',
'yfi',
'poly',
'elg',
'lpt',
'ankr',
'bal',
'omg',
'bone',
'msol',
'syn',
'zrx',
'mc',
'one',
'reth',
'eurt',
'dydx',
'mim',
'dag',
'flux',
'icx',
'glmr',
'woo',
'juno',
'rbn',
'ont',
'babydoge',
'op',
'husd',
'brise',
'lusd',
'nft',
'ewt',
'nu',
'chsb',
'ln',
'xcm',
'10set',
'alusd',
'waxp',
'hive',
'vvs',
'azero',
'xch',
'deso',
'zen',
'mdx',
'sc',
'scrt',
'sxp',
'rndr',
'audio',
'uma',
'sgb',
'inj',
'dao',
'sfm',
'cet',
'lsk',
'pla',
'skl',
'dgb',
'elon',
'astr',
'slp',
'metis',
'fx',
'eurs',
'pundix',
'mxc',
'kiro',
'erg',
'gfarm2',
'stsol',
'vgx',
'ckb',
'reef',
'usdn',
'ren',
'lyxe',
'api3',
'coti',
'looks',
'dexe',
'snt',
'pltc',
'uqc',
'kub',
'ceek',
'usdx',
'scho',
'prom',
'tribe',
'veri',
'pyr',
'xsushi',
'win',
'med',
'mpl',
'pokt',
'boba',
'cvc',
'xno',
'sys',
'gns',
'steem',
'orbs',
'ardr',
'mbox',
'mvl',
'tryb',
'ever',
'wrx',
'kuji',
'nmr',
'pha',
'mx',
'ult',
'seth2',
'rad',
'bsw',
'aca',
'people',
'spell',
'knc',
'bico',
'alice',
'hxro',
'eul',
'multi',
'plt',
'c98',
'raca',
'exrd',
'celr',
'req',
'plex',
'powr',
'bnt',
'ctsi',
'ilv',
'ctc',
'temple',
'tel',
'krd',
'cfx',
'uos',
'dka',
'nrv',
'chr',
'xprt',
'dent',
'fun',
'asd',
'arrr',
'savax',
'magic',
'rlc',
'bdx',
'emaid',
'xyo',
'euroc',
'quack',
'strax',
'wcfg',
'cfg',
'aethc',
'tsuka',
'btc.b',
'qkc',
'renbtc',
'stpt',
'canto',
'vtho',
'gal',
'mlk',
'fidu',
'ton',
'trac',
'dock',
'ctk',
'ocean',
'ray',
'stg',
'shr',
'ogn',
'mnw',
'pcx',
'sx',
'susd',
'joe',
'nest',
'kilt',
'aurora',
'h2o',
'keep',
'flexusd',
'mtrg',
'xvs',
'bfc',
'ant',
'ccd',
'ssv',
'floki',
'sfund',
'cdt',
'mtl',
'ark',
'sure',
'xmon',
'tlm',
'btcst',
'stmx',
'itamcube',
'koin',
'lqty',
'rev',
'utk',
'storj',
'movr',
'elf',
'xido',
'hez',
'core',
'efi',
'aergo',
'stars',
'zz',
'wozx',
'fei',
'ach',
'fet',
'sun',
'agix',
'gog',
'sofi',
'ride',
'nkn',
'mtd',
'ads',
'bor',
'sweat',
'oxt',
'iq',
'badger',
'dodo',
'fold',
'xsgd',
'rly',
'xvg',
'rep',
'dawn',
'gbex',
'ygg',
'strk',
'beta',
'mimatic',
'alpha',
'manc',
'phb',
'koda',
'dpx',
'dero',
'ghst',
'cusd',
'meta',
'ufo',
'etn',
'divi',
'saitama',
'mask',
'dusk',
'santos',
'akt',
'nxs',
'bond',
'rif',
'mintme',
'yfii',
'wnxm',
'bitci',
'mft',
'ibeur',
'tlos',
'dc',
'ata',
'alpaca',
'fer',
'xcad',
'blid',
'band',
'wmt',
'gods',
'egc',
'axn',
'bake',
'pols',
'auction',
'kishu',
'ama',
'tt',
'usdk',
'flm',
'ageur',
'zig',
'poop',
'dome',
'vega',
'sfp',
'cbat',
'vra',
'ampl',
'mln',
'dola',
'ousd',
'kp3r',
'cocos',
'hydra',
'pond',
'tru',
'dei',
'ern',
'idex',
'nebl',
'time',
'loomold',
'qrdo',
'lcx',
'avinoc',
'perp',
'hunt',
'cweb',
'b2m',
'clv',
'klv',
'xki',
'lto',
'ava',
'ron',
'hc',
'opt2',
'astrafer',
'kunci',
'itheum',
'leash',
'tomo',
'cqt',
'volt',
'orn',
'regen',
'super',
'gxc',
'wan',
'forth',
'sb',
],
coingeckoTop500Names: [
'Bitcoin',
'Ethereum',
'Tether',
'BNB',
'USD Coin',
'XRP',
'Binance USD',
'Cardano',
'Solana',
'Dogecoin',
'Polkadot',
'Polygon',
'Lido Staked Ether',
'Shiba Inu',
'Dai',
'TRON',
'Wrapped Bitcoin',
'Avalanche',
'Uniswap',
'OKB',
'LEO Token',
'Litecoin',
'Cosmos Hub',
'Chainlink',
'Ethereum Classic',
'FTX',
'Stellar',
'Cronos',
'Quant',
'Monero',
'NEAR Protocol',
'Algorand',
'Bitcoin Cash',
'VeChain',
'Terra Luna Classic',
'Flow',
'Filecoin',
'Hedera',
'ApeCoin',
'Elrond',
'WhiteBIT Token',
'Frax',
'Internet Computer',
'Aptos',
'Aave',
'Tezos',
'Chain',
'Huobi',
'Tokenize Xchange',
'The Sandbox',
'Decentraland',
'Lido DAO',
'EOS',
'Theta Network',
'Chiliz',
'cUSDC',
'KuCoin',
'Bitcoin SV',
'Pax Dollar',
'Axie Infinity',
'TrueUSD',
'Maker',
'Evmos',
'BitTorrent',
'USDD',
'eCash',
'Klaytn',
'IOTA',
'EthereumPoW',
'Zcash',
'cDAI',
'PancakeSwap',
'Gate',
'The Graph',
'NEO',
'BTSE Token',
'cETH',
'Osmosis',
'Helium',
'Synthetix Network',
'NEXO',
'Fantom',
'Arweave',
'Radix',
'Casper Network',
'PAX Gold',
'Curve DAO',
'Kava',
'BitDAO',
'Ethereum Name Service',
'Dash',
'Trust Wallet',
'Zilliqa',
'THORChain',
'Rocket Pool',
'XDC Network',
'Enjin Coin',
'Basic Attention',
'Tether Gold',
'Stacks',
'Frax Share',
'Celsius Network',
'Mina Protocol',
'Decred',
'DeFiChain',
'Amp',
'Terra',
'Ravencoin',
'cUSDT',
'TerraClassicUSD',
'Convex Finance',
'1inch',
'Maiar DEX',
'Compound',
'ECOMI',
'Holo',
'NEM',
'Gemini Dollar',
'Celo',
'Waves',
'Bitcoin Gold',
'Immutable X',
'Loopring',
'Kusama',
'Oasis Network',
'Theta Fuel',
'Nexus Mutual',
'GMX',
'Gnosis',
'Olympus',
'STEPN',
'Qtum',
'Sushi',
'SafeMoon [OLD]',
'OKC',
'Serum',
'IOST',
'Golem',
'JUST',
'Gala',
'Huobi BTC',
'Kadena',
'IoTeX',
'Convex CRV',
'Reserve Rights',
'yearn.finance',
'Polymath',
'Ankr',
'Escoin',
'Livepeer',
'Balancer',
'Bone ShibaSwap',
'OMG Network',
'Marinade staked SOL',
'Merit Circle',
'0x',
'Harmony',
'Synapse',
'Rocket Pool ETH',
'Euro Tether',
'dYdX',
'Magic Internet Money',
'Flux',
'ICON',
'Constellation',
'Moonbeam',
'WOO Network',
'JUNO',
'Optimism',
'Ontology',
'Ribbon Finance',
'Bitgert',
'HUSD',
'Baby Doge Coin',
'Energy Web',
'APENFT',
'SwissBorg',
'Liquity USD',
'NuCypher',
'Coinmetro',
'Tenset',
'LINK',
'Alchemix USD',
'WAX',
'Hive',
'VVS Finance',
'Decentralized Social',
'Aleph Zero',
'Chia',
'Horizen',
'Mdex',
'Siacoin',
'Secret',
'SXP',
'Render',
'UMA',
'Audius',
'Injective',
'DAO Maker',
'Songbird',
'SafeMoon',
'CoinEx',
'Lisk',
'PlayDapp',
'SKALE',
'DigiByte',
'Dogelon Mars',
'Astar',
'Smooth Love Potion',
'Metis',
'Function X',
'Pundi X',
'STASIS EURO',
'MXC',
'Kirobo',
'Ergo',
'Gains Farm',
'Lido Staked SOL',
'Voyager VGX',
'Nervos Network',
'Reef',
'Neutrino USD',
'REN',
'LUKSO',
'API3',
'COTI',
'LooksRare',
'DeXe',
'Status',
'PlatonCoin',
'Uquid Coin',
'Bitkub Coin',
'CEEK Smart VR',
'USDX',
'Scholarship Coin',
'Tribe',
'Prom',
'Veritaseum',
'xSUSHI',
'Vulcan Forged',
'WINkLink',
'Medibloc',
'Maple',
'Pocket Network',
'Civic',
'Nano',
'Boba Network',
'Syscoin',
'Gains Network',
'Velas',
'Steem',
'Orbs',
'Ardor',
'Mobox',
'MVL',
'BiLira',
'Everscale',
'WazirX',
'Kujira',
'Numeraire',
'Phala Network',
'MX',
'Shardus',
'sETH2',
'Radicle',
'Biswap',
'Acala',
'ConstitutionDAO',
'Spell',
'Kyber Network Crystal',
'Biconomy',
'My Neighbor Alice',
'Hxro',
'Euler',
'Multichain',
'Poollotto.finance',
'Coin98',
'Radio Caca',
'e-Radix',
'Celer Network',
'Request',
'PLEX',
'Power Ledger',
'Bancor Network',
'Cartesi',
'Illuvium',
'Creditcoin',
'Telcoin',
'TempleDAO',
'Krypton DAO',
'Conflux',
'Ultra',
'dKargo',
'Nerve Finance',
'Chromia',
'Persistence',
'Dent',
'FUN',
'AscendEx',
'Pirate Chain',
'BENQI Liquid Staked AVAX',
'iExec RLC',
'Magic',
'Beldex',
'MaidSafeCoin',
'XYO Network',
'Euro Coin',
'Rich Quack',
'Stratis',
'Wrapped Centrifuge',
'Centrifuge',
'Ankr Reward-Bearing Staked ETH',
'Bitcoin Avalanche Bridged (BTC.b)',
'QuarkChain',
'renBTC',
'STP',
'CANTO',
'VeThor',
'Galxe',
'MiL.k Alliance',
'Fidu',
'Dejitaru Tsuka',
'Tokamak Network',
'OriginTrail',
'Dock',
'Shentu',
'Ocean Protocol',
'Raydium',
'Stargate Finance',
'Share',
'Origin Protocol',
'Morpheus Network',
'ChainX',
'SX Network',
'sUSD',
'JOE',
'Nest Protocol',
'KILT Protocol',
'Aurora',
'H2O Dao',
'Keep Network',
'flexUSD',
'Meter Governance',
'Venus',
'Bifrost',
'Aragon',
'Concordium',
'SSV Network',
'FLOKI',
'Seedify.fund',
'Blox',
'Metal',
'Ark',
'inSure DeFi',
'XMON',
'Alien Worlds',
'BTC Standard Hashrate Token',
'StormX',
'CUBE',
'Koinos',
'Liquity',
'Revain',
'Utrust',
'Storj',
'Moonriver',
'aelf',
'Xido Finance',
'Hermez Network',
'cVault.finance',
'Efinity',
'Aergo',
'Stargaze',
'ZigZag',
'Efforce',
'Fei USD',
'Alchemy Pay',
'Fetch.ai',
'Sun Token',
'SingularityNET',
'Guild of Guardians',
'RAI Finance',
'holoride',
'NKN',
'Minted',
'Adshares',
'BoringDAO [OLD]',
'Sweatcoin - Sweat Economy',
'Orchid Protocol',
'IQ',
'Badger DAO',
'DODO',
'Manifold Finance',
'XSGD',
'Rally',
'Verge',
'Augur',
'Globiance Exchange',
'Yield Guild Games',
'Strike',
'Dawn Protocol',
'MAI',
'Beta Finance',
'Alpha Venture DAO',
'Mancium',
'Phoenix Global [OLD]',
'Koda Cryptocurrency',
'Dopex',
'Dero',
'Aavegotchi',
'UFO Gaming',
'Metadium',
'Celo Dollar',
'Electroneum',
'Divi',
'Saitama',
'Mask Network',
'DUSK Network',
'Santos FC Fan Token',
'Akash Network',
'Nexus',
'BarnBridge',
'RSK Infrastructure Framework',
'MintMe.com Coin',
'DFI.money',
'Wrapped NXM',
'Hifi Finance',
'Bitcicoin',
'Iron Bank EURO',
'Telos',
'Dogechain',
'XCAD Network',
'Automata',
'Alpaca Finance',
'Ferro',
'Bolide',
'World Mobile Token',
'Band Protocol',
'Gods Unchained',
'EverGrow Coin',
'Axion',
'BakerySwap',
'Polkastarter',
'Bounce',
'Kishu Inu',
'MrWeb Finance [OLD]',
'ThunderCore',
'USDK',
'Flamingo Finance',
'agEUR',
'Zignaly',
'Raresama',
'Everdome',
'Vega Protocol',
'SafePal',
'cBAT',
'Verasity',
'Ampleforth',
'Enzyme',
'Dola',
'Keep3rV1',
'Origin Dollar',
'COCOS BCX',
'Hydra',
'Marlin',
'TrueFi',
'DEI',
'Ethernity Chain',
'IDEX',
'Neblio',
'chrono.tech',
'Loom Network (OLD)',
'LCX',
'Qredo',
'AVINOC',
'Perpetual Protocol',
'Hunt',
'Coinweb',
'Bit2Me',
'Klever',
'Clover Finance',
'KI',
'LTO Network',
'Travala.com',
'Ronin',
'HyperCash',
'Optimus OPT2',
'Astrafer',
'Kunci Coin',
'Itheum',
'Doge Killer',
'TomoChain',
'Covalent',
'Volt Inu',
'Orion Protocol',
'Regen',
'SuperFarm',
'GXChain',
'Vite',
'Wanchain',
'Ampleforth Governance',
],
coingeckoTop500Ids: [
'bitcoin',
'ethereum',
'tether',
'binancecoin',
'usd-coin',
'ripple',
'binance-usd',
'cardano',
'solana',
'dogecoin',
'polkadot',
'matic-network',
'staked-ether',
'shiba-inu',
'dai',
'tron',
'avalanche-2',
'wrapped-bitcoin',
'uniswap',
'okb',
'litecoin',
'leo-token',
'cosmos',
'chainlink',
'ethereum-classic',
'ftx-token',
'stellar',
'crypto-com-chain',
'quant-network',
'monero',
'near',
'algorand',
'bitcoin-cash',
'vechain',
'terra-luna',
'flow',
'filecoin',
'apecoin',
'hedera-hashgraph',
'tokenize-xchange',
'elrond-erd-2',
'whitebit',
'internet-computer',
'tezos',
'frax',
'aptos',
'chain-2',
'huobi-token',
'aave',
'the-sandbox',
'decentraland',
'lido-dao',
'eos',
'theta-token',
'chiliz',
'compound-usd-coin',
'kucoin-shares',
'axie-infinity',
'bitcoin-cash-sv',
'paxos-standard',
'true-usd',
'maker',
'evmos',
'bittorrent',
'usdd',
'ecash',
'iota',
'ethereum-pow-iou',
'zcash',
'gatechain-token',
'pancakeswap-token',
'cdai',
'klay-token',
'the-graph',
'neo',
'compound-ether',
'osmosis',
'btse-token',
'havven',
'helium',
'nexo',
'fantom',
'arweave',
'pax-gold',
'radix',
'curve-dao-token',
'casper-network',
'kava',
'bitdao',
'trust-wallet-token',
'dash',
'ethereum-name-service',
'zilliqa',
'thorchain',
'enjincoin',
'basic-attention-token',
'blockstack',
'rocket-pool',
'xdce-crowd-sale',
'tether-gold',
'frax-share',
'mina-protocol',
'celsius-degree-token',
'decred',
'defichain',
'amp-token',
'terra-luna-2',
'ravencoin',
'1inch',
'convex-finance',
'terrausd',
'maiar-dex',
'compound-usdt',
'compound-governance-token',
'nem',
'holotoken',
'ecomi',
'gemini-dollar',
'celo',
'theta-fuel',
'loopring',
'waves',
'kusama',
'immutable-x',
'nxm',
'bitcoin-gold',
'oasis-network',
'gnosis',
'gmx',
'olympus',
'qtum',
'stepn',
'sushi',
'safemoon',
'serum',
'oec-token',
'iostoken',
'golem',
'gala',
'iotex',
'kadena',
'huobi-btc',
'yearn-finance',
'reserve-rights-token',
'just',
'convex-crv',
'polymath',
'balancer',
'ankr',
'livepeer',
'escoin-token',
'omisego',
'bone-shibaswap',
'msol',
'rocket-pool-eth',
'0x',
'harmony',
'synapse-2',
'ribbon-finance',
'tether-eurt',
'merit-circle',
'energy-web-token',
'magic-internet-money',
'icon',
'dydx',
'moonbeam',
'zelcash',
'woo-network',
'constellation-labs',
'optimism',
'juno-network',
'ontology',
'baby-doge-coin',
'nucypher',
'husd',
'tenset',
'bitrise-token',
'link',
'liquity-usd',
'coinmetro',
'swissborg',
'apenft',
'wax',
'alchemix-usd',
'hive',
'vvs-finance',
'bitclout',
'aleph-zero',
'zencash',
'chia',
'siacoin',
'mdex',
'secret',
'songbird',
'swipe',
'render-token',
'audius',
'injective-protocol',
'uma',
'dao-maker',
'playdapp',
'safemoon-2',
'coinex-token',
'lisk',
'dogelon-mars',
'digibyte',
'skale',
'astar',
'smooth-love-potion',
'gains-farm',
'metis-token',
'pundi-x-2',
'lukso-token',
'mxc',
'fx-coin',
'stasis-eurs',
'lido-staked-sol',
'kirobo',
'ergo',
'republic-protocol',
'reef',
'ethos',
'nervos-network',
'coti',
'api3',
'neutrino',
'looksrare',
'status',
'dexe',
'platoncoin',
'bitkub-coin',
'ceek',
'gains-network',
'tribe-2',
'scholarship-coin',
'usdx',
'veritaseum',
'prometeus',
'medibloc',
'xsushi',
'syscoin',
'vulcan-forged',
'wink',
'civic',
'nano',
'boba-network',
'maple',
'ardor',
'pocket-network',
'uquid-coin',
'orbs',
'mass-vehicle-ledger',
'mobox',
'everscale',
'velas',
'krypton-dao',
'bilira',
'wazirx',
'steem',
'numeraire',
'kujira',
'seth2',
'constitutiondao',
'hxro',
'mx-token',
'my-neighbor-alice',
'kyber-network-crystal',
'radicle',
'spell-token',
'shardus',
'acala',
'multichain',
'biswap',
'pha',
'richquack',
'biconomy',
'coin98',
'euler',
'canto',
'celer-network',
'cartesi',
'request-network',
'illuvium',
'milk-alliance',
'radio-caca',
'telcoin',
'power-ledger',
'bancor',
'poollotto-finance',
'ultra',
'e-radix',
'creditcoin-2',
'conflux-token',
'dkargo',
'chromaway',
'temple',
'magic',
'plex',
'dent',
'benqi-liquid-staked-avax',
'pirate-chain',
'nerve-finance',
'funfair',
'persistence',
'beldex',
'iexec-rlc',
'maidsafecoin',
'euro-coin',
'ankreth',
'wrapped-centrifuge',
'centrifuge',
'stratis',
'stp-network',
'xyo-network',
'asd',
'quark-chain',
'aurora-near',
'renbtc',
'dejitaru-tsuka',
'bitcoin-avalanche-bridged-btc-b',
'project-galaxy',
'origintrail',
'fidu',
'meter',
'vethor-token',
'tokamak-network',
'raydium',
'certik',
'dock',
'sx-network',
'ocean-protocol',
'origin-protocol',
'sharering',
'kilt-protocol',
'morpheus-network',
'joe',
'chainx',
'insure',
'keep-network',
'stargate-finance',
'nusd',
'aragon',
'venus',
'flex-usd',
'bifrost',
'h2o-dao',
'ssv-network',
'nest',
'ark',
'concordium',
'metal',
'floki',
'koinos',
'alien-worlds',
'btc-standard-hashrate-token',
'storm',
'seedify-fund',
'utrust',
'liquity',
'blox',
'revain',
'storj',
'cube',
'moonriver',
'xmon',
'aelf',
'cvault-finance',
'hermez-network-token',
'efinity',
'wozx',
'guild-of-guardians',
'aergo',
'singularitynet',
'alchemy-pay',
'fei-usd',
'fetch-ai',
'zigzag-2',
'minted',
'everipedia',
'sun-token',
'stargaze',
'sweatcoin',
'rai-finance',
'nkn',
'adshares',
'orchid-protocol',
'augur',
'boringdao-[old]',
'holoride',
'badger-dao',
'dodo',
'dogechain',
'santos-fc-fan-token',
'rally-2',
'divi',
'xido-finance',
'dopex',
'strike',
'xsgd',
'yield-guild-games',
'dawn-protocol',
'mancium',
'verge',
'beta-finance',
'manifold-finance',
'alpha-finance',
'mimatic',
'dero',
'metadium',
'celo-dollar',
'red-pulse',
'dusk-network',
'koda-finance',
'aavegotchi',
'ufo-gaming',
'mask-network',
'saitama-inu',
'akash-network',
'electroneum',
'globiance-exchange',
'nexus',
'rif-token',
'barnbridge',
'wrapped-nxm',
'bitcicoin',
'yfii-finance',
'origin-dollar',
'xcad-network',
'automata',
'iron-bank-euro',
'mainframe',
'webchain',
'kishu-inu',
'world-mobile-token',
'telos',
'alpaca-finance',
'band-protocol',
'ferro',
'bolide',
'thunder-token',
'gods-unchained',
'bakerytoken',
'auction',
'axion',
'evergrowcoin',
'vega-protocol',
'polkastarter',
'flamingo-finance',
'mrweb-finance',
'ampleforth',
'everdome',
'usdk',
'ageur',
'compound-basic-attention-token',
'verasity',
'zignaly',
'safepal',
'keep3rv1',
'dola-usd',
'truefi',
'cocos-bcx',
'raresama',
'hydra',
'marlin',
'aurora-dao',
'dei-token',
'ethernity-chain',
'loom-network',
'chronobank',
'qredo',
'hunt-token',
'step-app-fitfi',
'lcx',
'avinoc',
'bit2me',
'neblio',
'melon',
'optimus-opt2',
'perpetual-protocol',
'ronin',
'klever',
'coinweb',
'volt-inu-2',
'astrafer',
'concierge-io',
'leash',
'tomochain',
'clover-finance',
'orion-protocol',
'lto-network',
'hshare',
'regen',
'itheum',
'ki',
'covalent',
'unibright',
'kunci-coin',
'ampleforth-governance-token',
'ellipsis',
'superfarm',
],
- bannedTickers: ['ebtc', 'xbt', 'xecx', 'stXEC'],
- bannedNames: ['ebitcoin', 'Staked XEC', 'Staked eCash'],
+ bannedTickers: ['ebtc', 'xbt', 'xecx', 'stXEC', 'firma'],
+ bannedNames: ['ebitcoin', 'Staked XEC', 'Staked eCash', 'firma'],
fiatTickers: cashtabSettingsValidation.fiatCurrency,
fiatNames,
fiatSymbols,
};
const blacklists = Object.keys(tokenBlacklist);
let blacklist: string[] = [];
for (const i in blacklists) {
blacklist = blacklist.concat(
tokenBlacklist[blacklists[i] as keyof CreateTokenBlacklist],
);
}
// Remove spaces and case sensitivity
for (const i in blacklist) {
blacklist[i] = blacklist[i]
.toLowerCase()
.trim()
.split(' ')
.filter(string => string)
.join(' ');
}
export default blacklist;
diff --git a/cashtab/src/validation/__tests__/index.test.js b/cashtab/src/validation/__tests__/index.test.js
index fcad01dd3..9252068ba 100644
--- a/cashtab/src/validation/__tests__/index.test.js
+++ b/cashtab/src/validation/__tests__/index.test.js
@@ -1,610 +1,616 @@
// Copyright (c) 2024 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
import {
isValidTokenName,
isValidTokenTicker,
isValidTokenDecimals,
getTokenDocumentUrlError,
isValidCashtabSettings,
isValidXecSendAmount,
isValidTokenId,
isValidXecAirdrop,
isValidAirdropExclusionArray,
isValidContactList,
migrateLegacyCashtabSettings,
isValidCashtabCache,
validateMnemonic,
isProbablyNotAScam,
isValidMultiSendUserInput,
shouldSendXecBeDisabled,
parseAddressInput,
isValidCashtabWallet,
isValidTokenSendOrBurnAmount,
isValidTokenMintAmount,
getOpReturnRawError,
nodeWillAcceptOpReturnRaw,
getContactNameError,
getContactAddressError,
getWalletNameError,
TOKEN_DOCUMENT_URL_MAX_CHARACTERS,
getXecListPriceError,
getAgoraPartialListPriceError,
getAgoraPartialAcceptTokenQtyError,
getAgoraMinBuyError,
} from 'validation';
import {
validXecAirdropExclusionList,
invalidXecAirdropExclusionList,
invalidXecAirdropExclusionListPrefixless,
} from 'validation/fixtures/mocks';
import vectors from 'validation/fixtures/vectors';
import appConfig from 'config/app';
describe('Cashtab validation functions', () => {
it(`validateMnemonic() returns true for a valid mnemonic`, () => {
const mnemonic =
'labor tail bulb distance estate collect lecture into smile differ yard legal';
expect(validateMnemonic(mnemonic)).toBe(true);
});
it(`validateMnemonic() returns false for an invalid mnemonic`, () => {
const mnemonic =
'labor tail bulb not valid collect lecture into smile differ yard legal';
expect(validateMnemonic(mnemonic)).toBe(false);
});
it(`validateMnemonic() returns false for an empty string mnemonic`, () => {
const mnemonic = '';
expect(validateMnemonic(mnemonic)).toBe(false);
});
it(`Accepts a valid ${appConfig.tokenTicker} token name`, () => {
expect(isValidTokenName('Valid token name')).toBe(true);
});
it(`Accepts a valid ${appConfig.tokenTicker} token name that is a stringified number`, () => {
expect(isValidTokenName('123456789')).toBe(true);
});
it(`Rejects ${appConfig.tokenTicker} token name if longer than 68 characters`, () => {
expect(
isValidTokenName(
'This token name is not valid because it is longer than 68 characters which is really pretty long for a token name when you think about it and all',
),
).toBe(false);
});
it(`Rejects ${appConfig.tokenTicker} token name if empty string`, () => {
expect(isValidTokenName('')).toBe(false);
});
it(`Accepts a 4-char ${appConfig.tokenTicker} token ticker`, () => {
expect(isValidTokenTicker('DOGG')).toBe(true);
});
it(`Accepts a 12-char ${appConfig.tokenTicker} token ticker`, () => {
expect(isValidTokenTicker('123456789123')).toBe(true);
});
it(`Rejects ${appConfig.tokenTicker} token ticker if empty string`, () => {
expect(isValidTokenTicker('')).toBe(false);
});
it(`Rejects ${appConfig.tokenTicker} token ticker if > 12 chars`, () => {
expect(isValidTokenTicker('1234567891234')).toBe(false);
});
it(`Accepts tokenDecimals if zero`, () => {
expect(isValidTokenDecimals('0')).toBe(true);
});
it(`Accepts tokenDecimals if between 0 and 9 inclusive`, () => {
expect(isValidTokenDecimals('9')).toBe(true);
});
it(`Rejects tokenDecimals if empty string`, () => {
expect(isValidTokenDecimals('')).toBe(false);
});
it(`Rejects tokenDecimals if non-integer`, () => {
expect(isValidTokenDecimals('1.7')).toBe(false);
});
it(`No error for a valid ${appConfig.tokenTicker} token document URL`, () => {
expect(getTokenDocumentUrlError('cashtabapp.com')).toBe(false);
});
it(`No error for a valid ${appConfig.tokenTicker} token document URL including special URL characters`, () => {
expect(getTokenDocumentUrlError('https://cashtabapp.com/')).toBe(false);
});
it(`No error for a blank string as a valid ${appConfig.tokenTicker} token document URL`, () => {
expect(getTokenDocumentUrlError('')).toBe(false);
});
it(`Expected error for valid url longer than 68 characters`, () => {
expect(
getTokenDocumentUrlError(
'http://www.ThisTokenDocumentUrlIsActuallyMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchMuchTooLong.com/',
),
).toBe(
`URL must be less than ${TOKEN_DOCUMENT_URL_MAX_CHARACTERS} characters.`,
);
});
it(`No error for a domain input with https protocol as ${appConfig.tokenTicker} token document URL`, () => {
expect(getTokenDocumentUrlError('https://google.com')).toBe(false);
});
it(`No error for a domain input with http protocol as ${appConfig.tokenTicker} token document URL`, () => {
expect(getTokenDocumentUrlError('http://test.com')).toBe(false);
});
it(`No error for a domain input with a primary and secondary top level domain as ${appConfig.tokenTicker} token document URL`, () => {
expect(getTokenDocumentUrlError('http://test.co.uk')).toBe(false);
});
it(`No error for a domain input with just a subdomain as ${appConfig.tokenTicker} token document URL`, () => {
expect(getTokenDocumentUrlError('www.test.co.uk')).toBe(false);
});
it(`Expected error for a domain input with no top level domain, protocol or subdomain ${appConfig.tokenTicker} token document URL`, () => {
expect(getTokenDocumentUrlError('mywebsite')).toBe('Invalid URL');
});
it(`Accepts a common wikipedia URL convention (underscore and parenthesis)`, () => {
expect(
getTokenDocumentUrlError(
'https://en.wikipedia.org/wiki/Tai-Pan_(novel)',
),
).toBe(false);
});
it(`Expected error for a domain input as numbers ${appConfig.tokenTicker} token document URL`, () => {
expect(getTokenDocumentUrlError(12345)).toBe('Invalid URL');
});
it(`isValidTokenId accepts valid token ID that is 64 chars in length`, () => {
const testValidTokenId =
'1c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e';
expect(isValidTokenId(testValidTokenId)).toBe(true);
});
it(`isValidTokenId rejects a token ID that is less than 64 chars in length`, () => {
const testValidTokenId = '111111thisisaninvalidtokenid';
expect(isValidTokenId(testValidTokenId)).toBe(false);
});
it(`isValidTokenId rejects a token ID that is more than 64 chars in length`, () => {
const testValidTokenId =
'111111111c6c9c64d70b285befe733f175d0f384538576876bd280b10587df81279d3f5e';
expect(isValidTokenId(testValidTokenId)).toBe(false);
});
it(`isValidTokenId rejects a token ID number that is 64 digits in length`, () => {
// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
const testValidTokenId = 8912345678912345678912345678912345678912345678912345678912345679;
expect(isValidTokenId(testValidTokenId)).toBe(false);
});
it(`isValidTokenId rejects null`, () => {
const testValidTokenId = null;
expect(isValidTokenId(testValidTokenId)).toBe(false);
});
it(`isValidTokenId rejects undefined`, () => {
const testValidTokenId = undefined;
expect(isValidTokenId(testValidTokenId)).toBe(false);
});
it(`isValidTokenId rejects empty string`, () => {
const testValidTokenId = '';
expect(isValidTokenId(testValidTokenId)).toBe(false);
});
it(`isValidTokenId rejects special character input`, () => {
const testValidTokenId = '^&$%@&^$@&%$!';
expect(isValidTokenId(testValidTokenId)).toBe(false);
});
it(`isValidTokenId rejects non-alphanumeric input`, () => {
const testValidTokenId = 99999999999;
expect(isValidTokenId(testValidTokenId)).toBe(false);
});
it(`isValidXecAirdrop accepts valid Total Airdrop Amount`, () => {
const testAirdropTotal = '1000000';
expect(isValidXecAirdrop(testAirdropTotal)).toBe(true);
});
it(`isValidXecAirdrop rejects null`, () => {
const testAirdropTotal = null;
expect(isValidXecAirdrop(testAirdropTotal)).toBe(false);
});
it(`isValidXecAirdrop rejects undefined`, () => {
const testAirdropTotal = undefined;
expect(isValidXecAirdrop(testAirdropTotal)).toBe(false);
});
it(`isValidXecAirdrop rejects empty string`, () => {
const testAirdropTotal = '';
expect(isValidXecAirdrop(testAirdropTotal)).toBe(false);
});
it(`isValidTokenId rejects an alphanumeric input`, () => {
const testAirdropTotal = 'a73hsyujs3737';
expect(isValidXecAirdrop(testAirdropTotal)).toBe(false);
});
it(`isValidTokenId rejects a number !> 0 in string format`, () => {
const testAirdropTotal = '0';
expect(isValidXecAirdrop(testAirdropTotal)).toBe(false);
});
it(`isValidAirdropExclusionArray accepts a valid airdrop exclusion list`, () => {
expect(isValidAirdropExclusionArray(validXecAirdropExclusionList)).toBe(
true,
);
});
it(`isValidAirdropExclusionArray rejects an invalid airdrop exclusion list`, () => {
expect(
isValidAirdropExclusionArray(invalidXecAirdropExclusionList),
).toBe(false);
});
it(`isValidAirdropExclusionArray rejects a list of addresses if any are not prefixed`, () => {
expect(
isValidAirdropExclusionArray(
invalidXecAirdropExclusionListPrefixless,
),
).toBe(false);
});
it(`isValidAirdropExclusionArray rejects an empty airdrop exclusion list`, () => {
expect(isValidAirdropExclusionArray([])).toBe(false);
});
it(`isValidAirdropExclusionArray rejects a null airdrop exclusion list`, () => {
expect(isValidAirdropExclusionArray(null)).toBe(false);
});
it(`isProbablyNotAScam prevents new genesis tx of "XECX" as token ticker`, () => {
expect(isProbablyNotAScam('XECX')).toBe(false);
});
it(`isProbablyNotAScam prevents new genesis tx of "Staked XEC" as token name`, () => {
expect(isProbablyNotAScam('Staked XEC')).toBe(false);
});
+ it(`isProbablyNotAScam prevents new genesis tx of "FIRMA" as token ticker`, () => {
+ expect(isProbablyNotAScam('FIRMA')).toBe(false);
+ });
+ it(`isProbablyNotAScam prevents new genesis tx of "Firma" as token name`, () => {
+ expect(isProbablyNotAScam('Firma')).toBe(false);
+ });
it(`isProbablyNotAScam recognizes "bitcoin" is probably a scam token name`, () => {
expect(isProbablyNotAScam('bitcoin')).toBe(false);
});
it(`isProbablyNotAScam recognizes "ebitcoin" is probably a scam token name`, () => {
expect(isProbablyNotAScam('ebitcoin')).toBe(false);
});
it(`isProbablyNotAScam recognizes "Lido Staked Ether", from coingeckoTop500Names, is probably a scam token name`, () => {
expect(isProbablyNotAScam('Lido Staked Ether')).toBe(false);
});
it(`isProbablyNotAScam recognizes 'matic-network', from coingeckoTop500Ids, is probably a scam token name`, () => {
expect(isProbablyNotAScam('matic-network')).toBe(false);
});
it(`isProbablyNotAScam recognizes 'Australian Dollar', from Cashtab supported fiat currencies, is probably a scam token name`, () => {
expect(isProbablyNotAScam('Australian Dollar')).toBe(false);
});
it(`isProbablyNotAScam recognizes 'ebtc', from bannedTickers, is probably a scam token name`, () => {
expect(isProbablyNotAScam('ebtc')).toBe(false);
});
it(`isProbablyNotAScam recognizes 'gbp', from bannedTickers, is probably a scam`, () => {
expect(isProbablyNotAScam('gbp')).toBe(false);
});
it(`isProbablyNotAScam recognizes 'Hong Kong Dollar', from fiatNames, is probably a scam`, () => {
expect(isProbablyNotAScam('gbp')).toBe(false);
});
it(`isProbablyNotAScam recognizes '₪', from fiat symbols, is probably a scam`, () => {
expect(isProbablyNotAScam('₪')).toBe(false);
});
it(`isProbablyNotAScam recognizes an ordinary token name as acceptable`, () => {
expect(isProbablyNotAScam('just a normal token name')).toBe(true);
});
it(`isProbablyNotAScam accepts a token name with fragments of banned potential scam names`, () => {
expect(
isProbablyNotAScam(
'This token is not Ethereum or bitcoin or USD $',
),
).toBe(true);
});
describe('Determining whether Send button should be disabled on SendXec screen', () => {
const { expectedReturns } = vectors.shouldSendXecBeDisabled;
// Successfully created targetOutputs
expectedReturns.forEach(expectedReturn => {
const {
description,
formData,
balanceSats,
apiError,
sendAmountError,
sendAddressError,
multiSendAddressError,
sendWithCashtabMsg,
cashtabMsgError,
sendWithOpReturnRaw,
opReturnRawError,
priceApiError,
isOneToManyXECSend,
sendDisabled,
} = expectedReturn;
it(`shouldSendXecBeDisabled: ${description}`, () => {
expect(
shouldSendXecBeDisabled(
formData,
balanceSats,
apiError,
sendAmountError,
sendAddressError,
multiSendAddressError,
sendWithCashtabMsg,
cashtabMsgError,
sendWithOpReturnRaw,
opReturnRawError,
priceApiError,
isOneToManyXECSend,
),
).toBe(sendDisabled);
});
});
});
describe('Parses user input address strings with parseAddressInput', () => {
const { expectedReturns } = vectors.parseAddressInput;
// Successfully created targetOutputs
expectedReturns.forEach(expectedReturn => {
const {
description,
addressInput,
balanceSats,
userLocale,
parsedAddressInput,
} = expectedReturn;
it(`parseAddressInput: ${description}`, () => {
expect(
parseAddressInput(addressInput, balanceSats, userLocale),
).toStrictEqual(parsedAddressInput);
});
});
});
describe('Validating Cashtab Contact Lists', () => {
const { expectedReturns } = vectors.isValidContactList;
expectedReturns.forEach(expectedReturn => {
const { description, contactList, isValid } = expectedReturn;
it(`isValidContactList: ${description}`, () => {
expect(isValidContactList(contactList)).toBe(isValid);
});
});
});
describe('Appropriately migrates users with legacy settings', () => {
const { expectedReturns } = vectors.migrateLegacyCashtabSettings;
expectedReturns.forEach(expectedReturn => {
const { description, legacySettings, migratedSettings } =
expectedReturn;
it(`migrateLegacyCashtabSettings: ${description}`, () => {
expect(migrateLegacyCashtabSettings(legacySettings)).toEqual(
migratedSettings,
);
});
});
});
describe('Determines if the user has valid cashtab settings', () => {
const { expectedReturns } = vectors.isValidCashtabSettings;
expectedReturns.forEach(expectedReturn => {
const { description, settings, isValid } = expectedReturn;
it(`isValidCashtabSettings: ${description}`, () => {
expect(isValidCashtabSettings(settings)).toBe(isValid);
});
});
});
describe('Determines if cashtabCache is valid or invalid', () => {
const { expectedReturns } = vectors.isValidCashtabCache;
expectedReturns.forEach(expectedReturn => {
const { description, cashtabCache, isValid } = expectedReturn;
it(`isValidCashtabCache: ${description}`, () => {
expect(isValidCashtabCache(cashtabCache)).toBe(isValid);
});
});
});
describe('Determines if a cashtab wallet is valid or invalid', () => {
const { expectedReturns } = vectors.isValidCashtabWallet;
expectedReturns.forEach(expectedReturn => {
const { description, wallet, returned } = expectedReturn;
it(`isValidCashtabWallet: ${description}`, () => {
expect(isValidCashtabWallet(wallet)).toBe(returned);
});
});
});
describe('Determines if a user input send amount is valid', () => {
const { expectedReturns } = vectors.isValidXecSendAmount;
expectedReturns.forEach(expectedReturn => {
const {
description,
sendAmount,
balanceSats,
userLocale,
selectedCurrency,
fiatPrice,
returned,
} = expectedReturn;
it(`isValidXecSendAmount: ${description}`, () => {
expect(
isValidXecSendAmount(
sendAmount,
balanceSats,
userLocale,
selectedCurrency,
fiatPrice,
),
).toBe(returned);
});
});
});
describe('Determines if a user input multi-send CSV is valid', () => {
const { expectedReturns } = vectors.isValidMultiSendUserInput;
expectedReturns.forEach(expectedReturn => {
const {
description,
userMultisendInput,
balanceSats,
userLocale,
returned,
} = expectedReturn;
it(`isValidMultiSendUserInput: ${description}`, () => {
expect(
isValidMultiSendUserInput(
userMultisendInput,
balanceSats,
userLocale,
),
).toBe(returned);
});
});
});
describe('Determines if a user input send or burn token amount is valid', () => {
const { expectedReturns } = vectors.isValidTokenSendOrBurnAmount;
expectedReturns.forEach(expectedReturn => {
const {
description,
amount,
tokenBalance,
decimals,
tokenProtocol,
returned,
} = expectedReturn;
it(`isValidTokenSendOrBurnAmount: ${description}`, () => {
expect(
isValidTokenSendOrBurnAmount(
amount,
tokenBalance,
decimals,
tokenProtocol,
),
).toBe(returned);
});
});
});
describe('Determines if a user input token mint amount is valid', () => {
const { expectedReturns } = vectors.isValidTokenMintAmount;
expectedReturns.forEach(expectedReturn => {
const { description, amount, decimals, tokenProtocol, returned } =
expectedReturn;
it(`isValidTokenMintAmount: ${description}`, () => {
expect(
isValidTokenMintAmount(amount, decimals, tokenProtocol),
).toBe(returned);
});
});
});
describe('Can tell if a string is valid bip21 op_return_raw input, or why it is not', () => {
const { expectedReturns } = vectors.getOpReturnRawError;
expectedReturns.forEach(expectedReturn => {
const { description, opReturnRaw, returned } = expectedReturn;
it(`getOpReturnRawError: ${description}`, () => {
expect(getOpReturnRawError(opReturnRaw)).toBe(returned);
});
});
});
describe('Validates OP_RETURN raw for eCash node broadcast', () => {
const { expectedReturns } = vectors.nodeWillAcceptOpReturnRaw;
expectedReturns.forEach(expectedReturn => {
const { description, opReturnRaw, returned } = expectedReturn;
it(`nodeWillAcceptOpReturnRaw: ${description}`, () => {
expect(nodeWillAcceptOpReturnRaw(opReturnRaw)).toBe(returned);
});
});
});
describe('Gets error or false for contact name input', () => {
const { expectedReturns } = vectors.getContactNameError;
expectedReturns.forEach(expectedReturn => {
const { description, name, contacts, returned } = expectedReturn;
it(`getContactNameError: ${description}`, () => {
expect(getContactNameError(name, contacts)).toBe(returned);
});
});
});
describe('Gets error or false for contact address input', () => {
const { expectedReturns } = vectors.getContactAddressError;
expectedReturns.forEach(expectedReturn => {
const { description, address, contacts, returned } = expectedReturn;
it(`getContactAddressError: ${description}`, () => {
expect(getContactAddressError(address, contacts)).toBe(
returned,
);
});
});
});
describe('Gets error or false for wallet name input', () => {
const { expectedReturns } = vectors.getWalletNameError;
expectedReturns.forEach(expectedReturn => {
const { description, name, wallets, returned } = expectedReturn;
it(`getWalletNameError: ${description}`, () => {
expect(getWalletNameError(name, wallets)).toBe(returned);
});
});
});
describe('Gets error or false for list price input', () => {
const { expectedReturns } = vectors.getXecListPriceError;
expectedReturns.forEach(expectedReturn => {
const {
description,
xecListPrice,
selectedCurrency,
fiatPrice,
returned,
} = expectedReturn;
it(`getXecListPriceError: ${description}`, () => {
expect(
getXecListPriceError(
xecListPrice,
selectedCurrency,
fiatPrice,
),
).toBe(returned);
});
});
});
describe('Gets error or false for agora partial list price input', () => {
const { expectedReturns } = vectors.getAgoraPartialListPriceError;
expectedReturns.forEach(expectedReturn => {
const {
description,
xecListPrice,
selectedCurrency,
fiatPrice,
tokenDecimals,
returned,
} = expectedReturn;
it(`getAgoraPartialListPriceError: ${description}`, () => {
expect(
getAgoraPartialListPriceError(
xecListPrice,
selectedCurrency,
fiatPrice,
tokenDecimals,
),
).toBe(returned);
});
});
});
describe('Gets error or false for agora partial qty select', () => {
const { expectedReturns } = vectors.getAgoraPartialAcceptTokenQtyError;
expectedReturns.forEach(expectedReturn => {
const {
description,
takeTokenDecimalizedQty,
decimalizedTokenQtyMin,
decimalizedTokenQtyMax,
decimals,
userLocale,
returned,
} = expectedReturn;
it(`getAgoraPartialAcceptTokenQtyError: ${description}`, () => {
expect(
getAgoraPartialAcceptTokenQtyError(
takeTokenDecimalizedQty,
decimalizedTokenQtyMin,
decimalizedTokenQtyMax,
decimals,
userLocale,
),
).toBe(returned);
});
});
});
describe('Gets error or false for min qty input', () => {
const { expectedReturns } = vectors.getAgoraMinBuyError;
expectedReturns.forEach(expectedReturn => {
const {
description,
xecListPrice,
selectedCurrency,
fiatPrice,
minBuyTokenQty,
offeredTokenQty,
tokenDecimals,
tokenProtocol,
tokenBalance,
userLocale,
returned,
} = expectedReturn;
it(`getAgoraMinBuyError: ${description}`, () => {
expect(
getAgoraMinBuyError(
xecListPrice,
selectedCurrency,
fiatPrice,
minBuyTokenQty,
offeredTokenQty,
tokenDecimals,
tokenProtocol,
tokenBalance,
userLocale,
),
).toBe(returned);
});
});
});
});

File Metadata

Mime Type
text/x-diff
Expires
Sun, Mar 2, 12:38 (20 h, 58 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5187869
Default Alt Text
(58 KB)

Event Timeline