dequanto 0.0.1 → 0.0.7

package/src/solidity/storage/handlers/SlotFixedArrayHandler.ts

@@ -0,0 +1,52 @@
+import alot from 'alot';
+import { $abiType } from '@dequanto/utils/$abiType';
+import { ASlotFixedArray } from '../SlotFixedArray';
+import { IAccessorItem } from '../Accessor';
+import { SlotsStorage } from '@dequanto/solidity/SlotsStorage';
+import { SlotsParser } from '@dequanto/solidity/SlotsParser';
+import { SlotsCursorTransport } from '../SlotsStorageTransport';
+
+export class SlotFixedArrayHandler extends ASlotFixedArray {
+
+    async get (keys: IAccessorItem[]){
+        if (keys == null || keys.length === 0) {
+            return this.fetchAll();
+        }
+        let storage = await this.getStorageInner(keys);
+        return storage.get(keys);
+    }
+
+    async set(keys: IAccessorItem[], value: any): Promise<any> {
+        if (keys == null || keys.length === 0) {
+            throw new Error(`saveAll not implemented`);
+        }
+        let storage = await this.getStorageInner(keys);
+        return storage.set(keys, value);
+    }
+
+    async fetchAll () {
+        let slot = this.slot;
+        let arrLength = $abiType.array.getLength(slot.type);
+
+        return await alot.fromRange(0, arrLength).mapAsync(async i => {
+            return this.get([
+                { key: i, type: 'index' }
+            ]);
+        }).toArrayAsync()
+    }
+
+
+    private async getStorageInner (keys: IAccessorItem[]) {
+        let key = keys.shift();
+        if (key.type !== 'index') {
+            throw new Error(`Expected to get the Array index as a Key got ${key.key} as ${key.type}`);
+        }
+        let cursor = await this.getCursorFor(key.key);
+        let baseType = $abiType.array.getBaseType(this.slot.type);
+        let baseSlots = await SlotsParser.slotsFromAbi(baseType);
+
+        let transport = new SlotsCursorTransport(cursor, this.transport);
+        let storage = new SlotsStorage(transport, baseSlots);
+        return storage;
+    }
+}

package/src/solidity/storage/handlers/SlotMappingHandler.ts

@@ -0,0 +1,52 @@
+import { $abiType } from '@dequanto/utils/$abiType';
+import { ISlotVarDefinition, SlotsParser } from '../../SlotsParser';
+import { SlotsStorage } from '../../SlotsStorage';
+import { $types } from '../../utils/$types';
+import { SlotsStorageTransportForMapping } from '../SlotsStorageTransport';
+import { ASlotsStorageHandler } from '../SlotsStorageHandler';
+import { IAccessorItem } from '../Accessor';
+
+export class SlotMappingHandler extends ASlotsStorageHandler {
+
+    static supports (slot: ISlotVarDefinition): boolean {
+        return $types.isMapping(slot.type);
+    }
+
+    async get(keys: IAccessorItem[]): Promise<any> {
+        if (keys == null || keys.length === 0) {
+            return this.fetchAll();
+        }
+        let key = keys.shift();
+        let reader = await this.getStorageInner(key);
+        return reader.get(keys);
+    }
+
+    async set(keys: IAccessorItem[], value: any): Promise<any> {
+        if (keys == null || keys.length === 0) {
+            throw new Error(`saveAll not implemented`);
+        }
+        let key = keys.shift();
+        let storage = await this.getStorageInner(key);
+        storage.set(keys, value);
+    }
+
+    async fetchAll () {
+        throw new Error(`SlotMappingReader doesn't support fetchAll method, as size could be infinite`);
+    }
+
+    private async getStorageInner(key: IAccessorItem): Promise<any> {
+
+        let { slot } = this;
+        let mapValueType = $abiType.mapping.getValueType(slot.type);
+        let mapValueSlots = await SlotsParser.slotsFromAbi(mapValueType);
+
+        let transport = new SlotsStorageTransportForMapping(
+            this.transport,
+            this.slot.slot,
+            key.key,
+            mapValueSlots.length
+        );
+        let storage = new SlotsStorage(transport, mapValueSlots);
+        return storage;
+    }
+}

package/src/solidity/storage/handlers/SlotStringHandler.ts

@@ -0,0 +1,130 @@
+import alot from 'alot';
+import { AbiDeserializer } from '@dequanto/contracts/utils/AbiDeserializer';
+import { $abiParser } from '@dequanto/utils/$abiParser';
+import { $buffer } from '@dequanto/utils/$buffer';
+import { $require } from '@dequanto/utils/$require';
+import { ISlotVarDefinition } from '../../SlotsParser';
+import { SlotsStorageTransportForArray } from '../SlotsStorageTransport';
+import { ASlotsStorageHandler } from '../SlotsStorageHandler';
+import { IAccessorItem } from '../Accessor';
+import { $contract } from '@dequanto/utils/$contract';
+import { $abiUtils } from '@dequanto/utils/$abiUtils';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $hex } from '@dequanto/utils/$hex';
+
+export class SlotStringHandler extends ASlotsStorageHandler {
+
+    static supports (slot: ISlotVarDefinition) {
+        return slot.type === 'string';
+    }
+
+    async get (keys?: IAccessorItem[]){
+        this.requireNoKeys(keys);
+
+        let { slot } = this;
+        let location = slot.slot;
+        let memory = [];
+
+        let slotValue = await this.transport.getStorageAt(location, 0, 256);
+        /**
+         * Per slot 32 bytes
+         * At original slot position, the last n-bytes is the SIZE of the STRING
+         *
+         * If a string < 31 bytes then it takes the first 31 bytes of the original slot
+         * otherwise take the SIZE of the STRING calculate how much slots it occupies and read dynamic bytes array
+         */
+
+        let arraySizeMatch = /0x0{2,}(?<size>[^0][\da-f]+)$/i.exec(slotValue);
+        if (arraySizeMatch != null) {
+            let size = parseInt(arraySizeMatch.groups.size, 16) - 1;
+            memory = await this.readMultiSlot(size);
+        } else {
+            slotValue = slotValue.replace(/[\da-f]{2}$/i, '');
+            memory = [ slotValue ];
+        }
+        memory = memory.map(hex => $buffer.fromHex(hex));
+
+        let value = $buffer.toHex($buffer.concat(memory));
+        let abi = $abiParser.parseArguments(this.slot.type);
+        let deserialized = AbiDeserializer.process(value, abi);
+        return deserialized;
+    }
+
+    async set(keys: IAccessorItem[], value: string) {
+        this.requireNoKeys(keys);
+
+        let { slot } = this;
+
+        let hex = $hex.toHexBuffer(value);
+
+        let length = hex.length - 2;
+        let bytesCount = length / 2;
+        if (bytesCount > 31) {
+            await this.writeMultiSlot(hex);
+            return;
+        }
+
+        hex = $hex.padBytes(hex, 31, { padEnd: true }) + $hex.raw($hex.toHexBuffer(length));
+        this.transport.setStorageAt(slot.slot, 0, 256, hex);
+    }
+
+    async fetchAll() {
+        return this.get();
+    }
+
+
+    private async readMultiSlot (size: number) {
+        let SLOT_SIZE = 64;
+
+        let slotCount = Math.ceil(size / SLOT_SIZE);
+
+        $require.Number(slotCount, `Slots count is not a number for ${size}`);
+        $require.True(slotCount < 50, `The string is too big. Prevented to make ${slotCount} requests`);
+
+        return await alot
+            .fromRange(0, slotCount)
+            .mapAsync(async i => {
+                let reader = new SlotsStorageTransportForArray(this.transport, this.slot.slot, i, 1);
+                let slotValue = await reader.getStorageAt(0);
+                return slotValue;
+            })
+            .toArrayAsync()
+    }
+
+    private requireNoKeys (keys: IAccessorItem[]) {
+        if (keys?.length > 0) {
+            throw new Error(`ValueTypes cann't have the nested accessors: ${ keys.map(x => x.key).join('.') }`);
+        }
+    }
+
+    private async writeMultiSlot (buffer: string) {
+        let hex = $hex.raw(buffer);
+        let SLOT_SIZE = 64;
+        let slotCount = Math.ceil(hex.length / SLOT_SIZE);
+
+
+        $require.True(slotCount < 50, `The string is too big. Prevented to make ${slotCount} requests`);
+
+        //> Write length
+        this.transport.setStorageAt(this.slot.slot, 0, 256, hex.length);
+
+        //> Write all slots
+        return await alot
+            .fromRange(0, slotCount)
+            .mapAsync(async i => {
+
+                let buf = '0x' + hex.substring(i * SLOT_SIZE, i * SLOT_SIZE + SLOT_SIZE);
+                let slotValue = await this.transport.setStorageAt(this.getSlot(i), 0, 256, buf);
+                return slotValue;
+            })
+            .toArrayAsync()
+    }
+
+    private getSlot (idx: number) {
+        let slotArrNr = this.slot.slot;
+        let x = BigInt($contract.keccak256($abiUtils.encodePacked(slotArrNr)));
+        let uint = x + BigInt(idx);
+        return $bigint.toHex(uint);
+    }
+}
+

package/src/solidity/storage/handlers/SlotStructHandler.ts

@@ -0,0 +1,46 @@
+import alot from 'alot';
+import { IAccessorItem } from '../Accessor';
+import { SlotsStorage } from '@dequanto/solidity/SlotsStorage';
+import { ISlotVarDefinition, SlotsParser } from '@dequanto/solidity/SlotsParser';
+import { SlotsCursorTransport } from '../SlotsStorageTransport';
+import { ASlotsStorageHandler } from '../SlotsStorageHandler';
+import { $types } from '@dequanto/solidity/utils/$types';
+
+export class SlotStructHandler extends ASlotsStorageHandler {
+
+    static supports (slot: ISlotVarDefinition): boolean {
+        return $types.isStruct(slot.type);
+    }
+
+    async get (keys?: IAccessorItem[]){
+        if (keys == null || keys.length == 0) {
+            return this.fetchAll();
+        }
+        let storage = await this.getInnerStorage();
+        return storage.get(keys);
+    }
+
+    async set(keys: IAccessorItem[], value: any): Promise<any> {
+        let storage = await this.getInnerStorage();
+        await storage.set(keys, value);
+    }
+
+    async fetchAll () {
+        let baseSlots = await SlotsParser.slotsFromAbi(this.slot.type);
+        let storage = await this.getInnerStorage();
+
+        return await alot(baseSlots).mapAsync(async slot => {
+            return {
+                value: await storage.get(slot.name),
+                key: slot.name
+            };
+        }).toDictionaryAsync(x => x.key, x => x.value);
+    }
+
+    private async getInnerStorage () {
+        let transport = new SlotsCursorTransport(this.slot, this.transport);
+        let baseSlots = await SlotsParser.slotsFromAbi(this.slot.type);
+        let storage = new SlotsStorage(transport, baseSlots);
+        return storage;
+    }
+}

package/src/solidity/storage/handlers/SlotValueHandler.ts

@@ -0,0 +1,36 @@
+import { AbiDeserializer } from '@dequanto/contracts/utils/AbiDeserializer';
+import { $abiParser } from '@dequanto/utils/$abiParser';
+import { IAccessorItem } from '../Accessor';
+import { ASlotsStorageHandler } from '../SlotsStorageHandler';
+
+export class SlotValueHandler extends ASlotsStorageHandler {
+
+
+    async get (keys?: IAccessorItem[]){
+        this.requireNoKeys(keys);
+
+        let { slot } = this;
+
+        let value = await this.transport.getStorageAt(slot.slot, slot.position, slot.size);
+        let abi = $abiParser.parseArguments(this.slot.type);
+        let deserialized = AbiDeserializer.process(value, abi);
+        return deserialized;
+    }
+
+    async set(keys: IAccessorItem[], value: any): Promise<any> {
+        this.requireNoKeys(keys);
+
+        let { slot } = this;
+        await this.transport.setStorageAt(slot.slot, slot.position, slot.size, value);
+    }
+
+    async fetchAll() {
+        return this.get();
+    }
+
+    private requireNoKeys (keys: IAccessorItem[]) {
+        if (keys?.length > 0) {
+            throw new Error(`ValueTypes cann't have the nested accessors: ${ keys.map(x => x.key).join('.') }`);
+        }
+    }
+}

package/src/solidity/utils/$str.ts

@@ -0,0 +1,36 @@
+import { $buffer } from '@dequanto/utils/$buffer';
+import { $hex } from '@dequanto/utils/$hex';
+import { $require } from '@dequanto/utils/$require';
+
+export namespace $str {
+    export function sliceFromEnd (hex: string, positionBits: number, bits: number) {
+        let len = bits / 8 * 2;
+        let position = positionBits / 8 * 2;
+        let start = hex.length - len - position;
+        if (start < 0) {
+            throw new Error(`Not enough space to slice the buffer (${len}B) from position ${position/8}B`);
+        }
+        let sliced = hex.substring(start, start + len);
+        return sliced;
+    }
+
+    export function writeFromEnd (hex: string, hexIn: string, positionBits: number, bits: number) {
+        hexIn = hexIn.startsWith('0x')
+            ? hexIn.substring(2)
+            : hexIn;
+
+        let len = bits / 8 * 2;
+        let position = positionBits / 8 * 2;
+        let start = hex.length - len - position;
+        if (start < 0) {
+            throw new Error(`Not enough space to write the buffer (${len}B) at position ${position/8}B`);
+        }
+        let sliced = hex.substring(0, start) + hexIn + hex.substring(start + len);
+        return sliced;
+    }
+
+    export function fromHex (hex: string) {
+        let trimmed = $hex.trimBytes(hex);
+        return $buffer.fromHex(trimmed).toString();
+    }
+}

package/src/solidity/utils/$types.ts

@@ -0,0 +1,16 @@
+import { $require } from '@dequanto/utils/$require';
+
+export namespace $types {
+    export function isFixedArray (type: string) {
+        return /\[\d+\]$/.test(type);
+    }
+    export function isDynamicArray (type: string) {
+        return /\[\s*\]$/.test(type);
+    }
+    export function isStruct (type: string) {
+        return /^\(.+\)$/.test(type);
+    }
+    export function isMapping(type: string) {
+        return /mapping\(.+\)$/.test(type);
+    }
+}

package/src/structs/PackedRanges.ts

@@ -1,11 +1,17 @@
 import alot from 'alot';
 
 /**
- *  Allows in a compact way to add/remove a number to the range; check if number was added.
+ * Defines a RANGE: [FROM_NUMBER, TO_NUMBER | Infinity)
+ *
+ * - Walking/Iterating/Visiting through the range marks the visited number as ADD.
+ *
+ * - Possible to ADD the number manually, for example for persistance/restore properties
+ *
+ * - Check if NUMBER was already visited/iterated
+ *
  */
-
 export class PackedRanges {
-    private ranges: [number, number][] = [];
+    protected ranges: [number, number][] = [];
 
     from: number = 0
     to: number

package/src/tokens/TokenDataProvider.ts

@@ -0,0 +1,271 @@
+import alot from 'alot';
+import memd from 'memd';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { ArbTokenProvider } from '@dequanto/chains/arbitrum/ArbTokenProvider';
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { $address } from '@dequanto/utils/$address';
+import { $is } from '@dequanto/utils/$is';
+import { $require } from '@dequanto/utils/$require';
+import { ITokenProvider } from './TokenProviders/ITokenProvider';
+import { TPExplorer as TPExplorer } from './TokenProviders/TPExplorer';
+import { TPCoinmarketcap } from './TokenProviders/TPCoinmarketcap';
+import { TPOneInch } from './TokenProviders/TPOneInch';
+import { TPSushiswap } from './TokenProviders/TPSushiswap';
+import { TPConfig } from './TokenProviders/TPConfig';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TPChain } from './TokenProviders/TPChain';
+import { TPCoingecko } from './TokenProviders/TPCoingecko';
+import { $config } from '@dequanto/utils/$config';
+
+export class TokenDataProvider {
+
+    private config = new TPConfig();
+
+    private providers = [
+        this.config,
+        new TPOneInch(),
+        new TPSushiswap(),
+        // @TODO uniswap thegraph api doesn't work any more
+        // new TPUniswap(),
+        new TPCoinmarketcap(),
+        new TPCoingecko(),
+        new ArbTokenProvider(),
+        new TPExplorer(this.platform, this.explorer),
+        new TPChain(this.platform, this.client),
+    ] as ITokenProvider[];
+
+
+    constructor(private platform: TPlatform, private explorer?: IBlockChainExplorer, private client?: Web3Client) {
+
+    }
+
+    async getTokenOrDefault (address: TAddress, chainLookup: boolean = true): Promise<IToken> {
+        return await this.getToken(address, chainLookup) ?? this.default(address);
+    }
+
+
+    async getToken (symbol: string, chainLookup?: boolean): Promise<IToken>
+    async getToken (address: TAddress, chainLookup?: boolean): Promise<IToken>
+
+    @memd.deco.memoize({ perInstance: true })
+    async getToken (mix: string, chainLookup: boolean = true): Promise<IToken> {
+        let [ token, provider ] = $is.Address(mix)
+            ? await this.getTokenByAddress(mix, chainLookup)
+            : await this.getTokenBySymbol(mix, chainLookup);
+
+        return token
+    }
+
+    @memd.deco.memoize({ perInstance: true })
+    async getKnownToken (mix: string): Promise<IToken> {
+        let [ token, provider ] = $is.Address(mix)
+            ? await this.getTokenByAddress(mix, false)
+            : await this.getTokenBySymbol(mix, false);
+
+        if (token == null) {
+            throw new Error(`Token ${mix} not found`);
+        }
+        return token
+    }
+
+    /**
+     *  Adds and saves the token to dequanto configuration.
+     */
+    async addKnownToken (token: IToken): Promise<any> {
+        await this.config.addToken(token);
+    }
+
+    isNative (token: IToken): boolean
+    isNative (address: TAddress): boolean
+    isNative (symbol: string): boolean
+    isNative (mix): boolean {
+        $require.notNull(mix, `Token is undefined`);
+
+        if (typeof mix === 'object') {
+            return this.isNative(mix.symbol ?? mix.address);
+        }
+        if ($is.Address(mix)) {
+            return NativeTokens.isNativeByAddress(mix);
+        }
+        return NativeTokens.isNativeBySymbol(this.platform, mix);
+    }
+
+    getNative (platform: TPlatform): IToken {
+        return NativeTokens.getNative(platform);
+    }
+
+    /** Download tokens with various exchange/swap providers and merge them into one collection. */
+    async redownload () {
+        return await alot(this.providers)
+            .forEachAsync(async (x, i) => {
+                console.log(`Get from #${i} Provider`);
+                await x.redownloadTokens();
+                console.log(`Get from #${i} Provider DONE`);
+            })
+            .toArrayAsync()
+    }
+
+    async getTokenByAddress (address: TAddress, chainLookup: boolean = true): Promise<[IToken, ITokenProvider]> {
+        let [ token, provider ] = await alot(this.providers)
+            .mapAsync(async provider => {
+                if (provider instanceof TPExplorer && chainLookup === false) {
+                    return [null, null];;
+                }
+                return [await provider.getByAddress(this.platform, address), provider];
+            })
+            .firstAsync(([ token ]) => token != null) ?? [];
+
+        if (!token?.symbol && NativeTokens.isNativeByAddress(address)) {
+            token = NativeTokens.getNative(this.platform)
+        }
+        return [token, provider];
+    }
+    async getTokenBySymbol (symbol: string, chainLookup: boolean = true): Promise<[IToken, ITokenProvider]> {
+        let [ token, provider ] = await alot(this.providers)
+            .mapAsync(async provider => {
+                if (provider instanceof TPExplorer && chainLookup === false) {
+                    return [null, null];
+                }
+                return [await provider.getBySymbol(this.platform, symbol), provider];
+            })
+            .firstAsync(([token]) => token != null) ?? [];
+
+        if (!token?.symbol && NativeTokens.isNativeBySymbol(this.platform, symbol)) {
+            token = NativeTokens.getNative(this.platform);
+        }
+        return [ token, provider ];
+    }
+
+    private default (address: TAddress) {
+        return {
+            platform: this.platform,
+            symbol: address,
+            name: address,
+            address: address,
+            decimals: 18,
+        };
+    }
+}
+
+namespace NativeTokens {
+    const T1 = `0x0000000000000000000000000000000000000000`;
+    const T2 = `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee`;
+    const TOKENS = {
+        'ETH': <Partial<IToken>>{
+            name: 'Ethereum Native Token',
+            symbol: 'ETH',
+            decimals: 18,
+            icon: null,
+            platform: 'eth',
+            address: T2,
+        },
+        'BNB': <Partial<IToken>>{
+            name: 'BSC Native Token',
+            symbol: 'BNB',
+            decimals: 18,
+            icon: null,
+            platform: 'bsc',
+            address: T1,
+        },
+        'MATIC': <Partial<IToken>>{
+            name: 'Polygon Native Token',
+            symbol: 'MATIC',
+            decimals: 18,
+            icon: null,
+            platform: 'polygon',
+            address: T2,
+        },
+        'XDAI': <Partial<IToken>>{
+            name: 'xDai Native Token',
+            symbol: 'XDAI',
+            decimals: 18,
+            icon: null,
+            platform: 'xdai',
+            address: T1,
+            aliases: ['DAI']
+        },
+    };
+    const PLATFORMS = {
+        'eth': 'ETH',
+        'hardhat': 'ETH',
+        'bsc': 'BNB',
+        'polygon': 'MATIC',
+        'xdai': 'xDAI',
+        'arbitrum': 'ETH',
+    };
+    const PLATFORM_ALIASES = {
+        ['xdai']: {
+            aliases: ['DAI']
+        }
+    } as {
+        [platform in TPlatform]: {
+            aliases: string[]
+        }
+    };
+
+    export function isNativeBySymbol (platform: TPlatform, symbol: string) {
+        if (symbol == null) {
+            return false;
+        }
+        symbol = symbol.toUpperCase();
+        if (symbol in TOKENS) {
+            return true;
+        }
+        let byPlatform = PLATFORM_ALIASES[platform];
+        if (byPlatform?.aliases?.includes(symbol)) {
+            return true;
+        }
+        if (platform in PLATFORMS  === false) {
+            resolveNativeTokenFromConfiguration(platform);
+            return symbol in TOKENS
+        }
+
+        return false;
+    }
+
+    export function isNativeByAddress (address: TAddress) {
+        const check = address.toLowerCase();
+        return $address.eq(T1, check) || $address.eq(T2, check);
+    }
+
+    export function toNativeByAddress (platform: TPlatform, address: TAddress) {
+        const token = TOKENS[platform?.toUpperCase()];
+        return {
+            ...token,
+            address: address
+        };
+    }
+    export function getNative (platform: TPlatform): IToken {
+        if(platform in PLATFORMS === false){
+            resolveNativeTokenFromConfiguration(platform);
+        }
+        let symbol = PLATFORMS[platform]
+        if (symbol == null) {
+            throw new Error(`${platform} platform is not support`);
+        }
+        return TOKENS[symbol.toUpperCase()];
+    }
+
+    function resolveNativeTokenFromConfiguration (platform: TPlatform) {
+        let web3Config = $config.get(`web3.${platform}`);
+        if (web3Config == null || web3Config.chainToken == null) {
+            return null;
+        }
+
+        let symbol = web3Config.chainToken
+        PLATFORMS[platform] = symbol;
+        TOKENS[symbol] = {
+            name: symbol,
+            symbol: symbol,
+            decimals: 18,
+            icon: null,
+            platform: platform,
+            address: T1,
+        };
+        return TOKENS[symbol];
+    }
+}
+
+

package/src/tokens/TokenExchanges/AmmBase/V2/AmmPairV2Service.ts

@@ -12,6 +12,7 @@ import { UniswapExchange } from '@dequanto/tokens/TokenExchanges/UniswapExchange
 import { TokensService } from '@dequanto/tokens/TokensService';
 import { IToken } from '@dequanto/models/IToken';
 import { SushiswapPolygonExchange } from '../../SushiswapPolygonExchange';
+import { $require } from '@dequanto/utils/$require';
 
 
 
@@ -111,7 +112,8 @@ export class AmmPairV2Service {
 
 
         if (pool == null || pool.reserveTo < (50_000n * BigInt(pool.pair.to.decimals))) {
-            const SYMBOL = {eth: 'WETH', bsc: 'WBNB'}[platform];
+            const SYMBOL = { eth: 'WETH', bsc: 'WBNB', polygon: 'MATIC' }[platform];
+            $require.notNull(SYMBOL, `Native symbol for platform ${platform} not FOUND`);
             const nativeTokenPool = await this.getPoolInfo(address, SYMBOL);
 
             if (nativeTokenPool == null || nativeTokenPool.reserveTo < 10) {