dequanto 0.0.1 → 0.0.7

package/dist/src/solidity/storage/handlers/SlotStringHandler.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotStringHandler = void 0;
+const alot_1 = __importDefault(require("alot"));
+const AbiDeserializer_1 = require("@dequanto/contracts/utils/AbiDeserializer");
+const _abiParser_1 = require("@dequanto/utils/$abiParser");
+const _buffer_1 = require("@dequanto/utils/$buffer");
+const _require_1 = require("@dequanto/utils/$require");
+const SlotsStorageTransport_1 = require("../SlotsStorageTransport");
+const SlotsStorageHandler_1 = require("../SlotsStorageHandler");
+const _contract_1 = require("@dequanto/utils/$contract");
+const _abiUtils_1 = require("@dequanto/utils/$abiUtils");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const _hex_1 = require("@dequanto/utils/$hex");
+class SlotStringHandler extends SlotsStorageHandler_1.ASlotsStorageHandler {
+    static supports(slot) {
+        return slot.type === 'string';
+    }
+    async get(keys) {
+        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_1.$buffer.fromHex(hex));
+        let value = _buffer_1.$buffer.toHex(_buffer_1.$buffer.concat(memory));
+        let abi = _abiParser_1.$abiParser.parseArguments(this.slot.type);
+        let deserialized = AbiDeserializer_1.AbiDeserializer.process(value, abi);
+        return deserialized;
+    }
+    async set(keys, value) {
+        this.requireNoKeys(keys);
+        let { slot } = this;
+        let hex = _hex_1.$hex.toHexBuffer(value);
+        let length = hex.length - 2;
+        let bytesCount = length / 2;
+        if (bytesCount > 31) {
+            await this.writeMultiSlot(hex);
+            return;
+        }
+        hex = _hex_1.$hex.padBytes(hex, 31, { padEnd: true }) + _hex_1.$hex.raw(_hex_1.$hex.toHexBuffer(length));
+        this.transport.setStorageAt(slot.slot, 0, 256, hex);
+    }
+    async fetchAll() {
+        return this.get();
+    }
+    async readMultiSlot(size) {
+        let SLOT_SIZE = 64;
+        let slotCount = Math.ceil(size / SLOT_SIZE);
+        _require_1.$require.Number(slotCount, `Slots count is not a number for ${size}`);
+        _require_1.$require.True(slotCount < 50, `The string is too big. Prevented to make ${slotCount} requests`);
+        return await alot_1.default
+            .fromRange(0, slotCount)
+            .mapAsync(async (i) => {
+            let reader = new SlotsStorageTransport_1.SlotsStorageTransportForArray(this.transport, this.slot.slot, i, 1);
+            let slotValue = await reader.getStorageAt(0);
+            return slotValue;
+        })
+            .toArrayAsync();
+    }
+    requireNoKeys(keys) {
+        if (keys?.length > 0) {
+            throw new Error(`ValueTypes cann't have the nested accessors: ${keys.map(x => x.key).join('.')}`);
+        }
+    }
+    async writeMultiSlot(buffer) {
+        let hex = _hex_1.$hex.raw(buffer);
+        let SLOT_SIZE = 64;
+        let slotCount = Math.ceil(hex.length / SLOT_SIZE);
+        _require_1.$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_1.default
+            .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();
+    }
+    getSlot(idx) {
+        let slotArrNr = this.slot.slot;
+        let x = BigInt(_contract_1.$contract.keccak256(_abiUtils_1.$abiUtils.encodePacked(slotArrNr)));
+        let uint = x + BigInt(idx);
+        return _bigint_1.$bigint.toHex(uint);
+    }
+}
+exports.SlotStringHandler = SlotStringHandler;

package/dist/src/solidity/storage/handlers/SlotStructHandler.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotStructHandler = void 0;
+const alot_1 = __importDefault(require("alot"));
+const SlotsStorage_1 = require("@dequanto/solidity/SlotsStorage");
+const SlotsParser_1 = require("@dequanto/solidity/SlotsParser");
+const SlotsStorageTransport_1 = require("../SlotsStorageTransport");
+const SlotsStorageHandler_1 = require("../SlotsStorageHandler");
+const _types_1 = require("@dequanto/solidity/utils/$types");
+class SlotStructHandler extends SlotsStorageHandler_1.ASlotsStorageHandler {
+    static supports(slot) {
+        return _types_1.$types.isStruct(slot.type);
+    }
+    async get(keys) {
+        if (keys == null || keys.length == 0) {
+            return this.fetchAll();
+        }
+        let storage = await this.getInnerStorage();
+        return storage.get(keys);
+    }
+    async set(keys, value) {
+        let storage = await this.getInnerStorage();
+        await storage.set(keys, value);
+    }
+    async fetchAll() {
+        let baseSlots = await SlotsParser_1.SlotsParser.slotsFromAbi(this.slot.type);
+        let storage = await this.getInnerStorage();
+        return await (0, alot_1.default)(baseSlots).mapAsync(async (slot) => {
+            return {
+                value: await storage.get(slot.name),
+                key: slot.name
+            };
+        }).toDictionaryAsync(x => x.key, x => x.value);
+    }
+    async getInnerStorage() {
+        let transport = new SlotsStorageTransport_1.SlotsCursorTransport(this.slot, this.transport);
+        let baseSlots = await SlotsParser_1.SlotsParser.slotsFromAbi(this.slot.type);
+        let storage = new SlotsStorage_1.SlotsStorage(transport, baseSlots);
+        return storage;
+    }
+}
+exports.SlotStructHandler = SlotStructHandler;

package/dist/src/solidity/storage/handlers/SlotValueHandler.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotValueHandler = void 0;
+const AbiDeserializer_1 = require("@dequanto/contracts/utils/AbiDeserializer");
+const _abiParser_1 = require("@dequanto/utils/$abiParser");
+const SlotsStorageHandler_1 = require("../SlotsStorageHandler");
+class SlotValueHandler extends SlotsStorageHandler_1.ASlotsStorageHandler {
+    async get(keys) {
+        this.requireNoKeys(keys);
+        let { slot } = this;
+        let value = await this.transport.getStorageAt(slot.slot, slot.position, slot.size);
+        let abi = _abiParser_1.$abiParser.parseArguments(this.slot.type);
+        let deserialized = AbiDeserializer_1.AbiDeserializer.process(value, abi);
+        return deserialized;
+    }
+    async set(keys, value) {
+        this.requireNoKeys(keys);
+        let { slot } = this;
+        await this.transport.setStorageAt(slot.slot, slot.position, slot.size, value);
+    }
+    async fetchAll() {
+        return this.get();
+    }
+    requireNoKeys(keys) {
+        if (keys?.length > 0) {
+            throw new Error(`ValueTypes cann't have the nested accessors: ${keys.map(x => x.key).join('.')}`);
+        }
+    }
+}
+exports.SlotValueHandler = SlotValueHandler;

package/dist/src/solidity/utils/$str.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$str = void 0;
+const _buffer_1 = require("@dequanto/utils/$buffer");
+const _hex_1 = require("@dequanto/utils/$hex");
+var $str;
+(function ($str) {
+    function sliceFromEnd(hex, positionBits, bits) {
+        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;
+    }
+    $str.sliceFromEnd = sliceFromEnd;
+    function writeFromEnd(hex, hexIn, positionBits, bits) {
+        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;
+    }
+    $str.writeFromEnd = writeFromEnd;
+    function fromHex(hex) {
+        let trimmed = _hex_1.$hex.trimBytes(hex);
+        return _buffer_1.$buffer.fromHex(trimmed).toString();
+    }
+    $str.fromHex = fromHex;
+})($str = exports.$str || (exports.$str = {}));

package/dist/src/solidity/utils/$types.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$types = void 0;
+var $types;
+(function ($types) {
+    function isFixedArray(type) {
+        return /\[\d+\]$/.test(type);
+    }
+    $types.isFixedArray = isFixedArray;
+    function isDynamicArray(type) {
+        return /\[\s*\]$/.test(type);
+    }
+    $types.isDynamicArray = isDynamicArray;
+    function isStruct(type) {
+        return /^\(.+\)$/.test(type);
+    }
+    $types.isStruct = isStruct;
+    function isMapping(type) {
+        return /mapping\(.+\)$/.test(type);
+    }
+    $types.isMapping = isMapping;
+})($types = exports.$types || (exports.$types = {}));

package/dist/src/structs/PackedRanges.js

@@ -6,7 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PackedRanges = void 0;
 const alot_1 = __importDefault(require("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
+ *
  */
 class PackedRanges {
     constructor(opts) {

package/dist/src/tokens/TokenDataProvider.js

@@ -0,0 +1,251 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenDataProvider = void 0;
+const alot_1 = __importDefault(require("alot"));
+const memd_1 = __importDefault(require("memd"));
+const ArbTokenProvider_1 = require("@dequanto/chains/arbitrum/ArbTokenProvider");
+const _address_1 = require("@dequanto/utils/$address");
+const _is_1 = require("@dequanto/utils/$is");
+const _require_1 = require("@dequanto/utils/$require");
+const TPExplorer_1 = require("./TokenProviders/TPExplorer");
+const TPCoinmarketcap_1 = require("./TokenProviders/TPCoinmarketcap");
+const TPOneInch_1 = require("./TokenProviders/TPOneInch");
+const TPSushiswap_1 = require("./TokenProviders/TPSushiswap");
+const TPConfig_1 = require("./TokenProviders/TPConfig");
+const TPChain_1 = require("./TokenProviders/TPChain");
+const TPCoingecko_1 = require("./TokenProviders/TPCoingecko");
+const _config_1 = require("@dequanto/utils/$config");
+class TokenDataProvider {
+    constructor(platform, explorer, client) {
+        this.platform = platform;
+        this.explorer = explorer;
+        this.client = client;
+        this.config = new TPConfig_1.TPConfig();
+        this.providers = [
+            this.config,
+            new TPOneInch_1.TPOneInch(),
+            new TPSushiswap_1.TPSushiswap(),
+            // @TODO uniswap thegraph api doesn't work any more
+            // new TPUniswap(),
+            new TPCoinmarketcap_1.TPCoinmarketcap(),
+            new TPCoingecko_1.TPCoingecko(),
+            new ArbTokenProvider_1.ArbTokenProvider(),
+            new TPExplorer_1.TPExplorer(this.platform, this.explorer),
+            new TPChain_1.TPChain(this.platform, this.client),
+        ];
+    }
+    async getTokenOrDefault(address, chainLookup = true) {
+        return await this.getToken(address, chainLookup) ?? this.default(address);
+    }
+    async getToken(mix, chainLookup = true) {
+        let [token, provider] = _is_1.$is.Address(mix)
+            ? await this.getTokenByAddress(mix, chainLookup)
+            : await this.getTokenBySymbol(mix, chainLookup);
+        return token;
+    }
+    async getKnownToken(mix) {
+        let [token, provider] = _is_1.$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) {
+        await this.config.addToken(token);
+    }
+    isNative(mix) {
+        _require_1.$require.notNull(mix, `Token is undefined`);
+        if (typeof mix === 'object') {
+            return this.isNative(mix.symbol ?? mix.address);
+        }
+        if (_is_1.$is.Address(mix)) {
+            return NativeTokens.isNativeByAddress(mix);
+        }
+        return NativeTokens.isNativeBySymbol(this.platform, mix);
+    }
+    getNative(platform) {
+        return NativeTokens.getNative(platform);
+    }
+    /** Download tokens with various exchange/swap providers and merge them into one collection. */
+    async redownload() {
+        return await (0, alot_1.default)(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, chainLookup = true) {
+        let [token, provider] = await (0, alot_1.default)(this.providers)
+            .mapAsync(async (provider) => {
+            if (provider instanceof TPExplorer_1.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, chainLookup = true) {
+        let [token, provider] = await (0, alot_1.default)(this.providers)
+            .mapAsync(async (provider) => {
+            if (provider instanceof TPExplorer_1.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];
+    }
+    default(address) {
+        return {
+            platform: this.platform,
+            symbol: address,
+            name: address,
+            address: address,
+            decimals: 18,
+        };
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], TokenDataProvider.prototype, "getToken", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], TokenDataProvider.prototype, "getKnownToken", null);
+exports.TokenDataProvider = TokenDataProvider;
+var NativeTokens;
+(function (NativeTokens) {
+    const T1 = `0x0000000000000000000000000000000000000000`;
+    const T2 = `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee`;
+    const TOKENS = {
+        'ETH': {
+            name: 'Ethereum Native Token',
+            symbol: 'ETH',
+            decimals: 18,
+            icon: null,
+            platform: 'eth',
+            address: T2,
+        },
+        'BNB': {
+            name: 'BSC Native Token',
+            symbol: 'BNB',
+            decimals: 18,
+            icon: null,
+            platform: 'bsc',
+            address: T1,
+        },
+        'MATIC': {
+            name: 'Polygon Native Token',
+            symbol: 'MATIC',
+            decimals: 18,
+            icon: null,
+            platform: 'polygon',
+            address: T2,
+        },
+        'XDAI': {
+            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']
+        }
+    };
+    function isNativeBySymbol(platform, symbol) {
+        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;
+    }
+    NativeTokens.isNativeBySymbol = isNativeBySymbol;
+    function isNativeByAddress(address) {
+        const check = address.toLowerCase();
+        return _address_1.$address.eq(T1, check) || _address_1.$address.eq(T2, check);
+    }
+    NativeTokens.isNativeByAddress = isNativeByAddress;
+    function toNativeByAddress(platform, address) {
+        const token = TOKENS[platform?.toUpperCase()];
+        return {
+            ...token,
+            address: address
+        };
+    }
+    NativeTokens.toNativeByAddress = toNativeByAddress;
+    function getNative(platform) {
+        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()];
+    }
+    NativeTokens.getNative = getNative;
+    function resolveNativeTokenFromConfiguration(platform) {
+        let web3Config = _config_1.$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];
+    }
+})(NativeTokens || (NativeTokens = {}));

package/dist/src/tokens/TokenExchanges/AmmBase/V2/AmmPairV2Service.js

@@ -18,6 +18,7 @@ const PancakeswapExchange_1 = require("@dequanto/tokens/TokenExchanges/Pancakesw
 const UniswapExchange_1 = require("@dequanto/tokens/TokenExchanges/UniswapExchange");
 const TokensService_1 = require("@dequanto/tokens/TokensService");
 const SushiswapPolygonExchange_1 = require("../../SushiswapPolygonExchange");
+const _require_1 = require("@dequanto/utils/$require");
 ;
 class AmmPairV2Service {
     constructor(client, explorer) {
@@ -50,7 +51,8 @@ class AmmPairV2Service {
             .sortByAsync(({ reserveTo }) => reserveTo, 'desc')
             .firstAsync();
         if (pool == null || pool.reserveTo < (50000n * BigInt(pool.pair.to.decimals))) {
-            const SYMBOL = { eth: 'WETH', bsc: 'WBNB' }[platform];
+            const SYMBOL = { eth: 'WETH', bsc: 'WBNB', polygon: 'MATIC' }[platform];
+            _require_1.$require.notNull(SYMBOL, `Native symbol for platform ${platform} not FOUND`);
             const nativeTokenPool = await this.getPoolInfo(address, SYMBOL);
             if (nativeTokenPool == null || nativeTokenPool.reserveTo < 10) {
                 return null;

package/dist/src/tokens/TokenExchanges/AmmV2ExchangeBase.js

@@ -21,8 +21,8 @@ const AmmMasterChefV2Contract_1 = require("./AmmBase/V2/AmmMasterChefV2Contract"
 const AmmPairV2Contract_1 = require("./AmmBase/V2/AmmPairV2Contract");
 const AmmVaultV2Contract_1 = require("./AmmBase/V2/AmmVaultV2Contract");
 const TokensServiceBsc_1 = require("../TokensServiceBsc");
-const _is_1 = require("@dequanto/utils/$is");
 const _address_1 = require("@dequanto/utils/$address");
+const _require_1 = require("@dequanto/utils/$require");
 class AmmV2ExchangeBase {
     constructor(client, explorer) {
         this.client = client;
@@ -47,7 +47,7 @@ class AmmV2ExchangeBase {
         return a_di_1.default.resolve(AmmPairV2Contract_1.AmmPairV2Contract, pair, this.client, this.explorer);
     }
     async calcSwap(from, to, fromAmount) {
-        _is_1.$is.BigInt(fromAmount);
+        _require_1.$require.BigInt(fromAmount);
         if (fromAmount === 0n) {
             return {
                 amount: 0n,
@@ -63,8 +63,8 @@ class AmmV2ExchangeBase {
         if (lpReserves == null || lpReserves._reserve0 < 1000n) {
             return null;
         }
-        _is_1.$is.BigInt(lpReserves?._reserve0, `Reserve 0 not valid for LPAddress ${lpAddress}`);
-        _is_1.$is.BigInt(lpReserves?._reserve1, `Reserve 1 not valid for LPAddress ${lpAddress}`);
+        _require_1.$require.BigInt(lpReserves?._reserve0, `Reserve 0 not valid for LPAddress ${lpAddress}`);
+        _require_1.$require.BigInt(lpReserves?._reserve1, `Reserve 1 not valid for LPAddress ${lpAddress}`);
         let [fromI, toI] = BigInt(from.address) < BigInt(to.address) ? [0, 1] : [1, 0];
         let reserveFrom = lpReserves[`_reserve${fromI}`];
         let reserveTo = lpReserves[`_reserve${toI}`];

package/dist/src/tokens/TokenExchanges/PancakeswapExchange.js

@@ -10,19 +10,16 @@ const BscWeb3Client_1 = require("@dequanto/clients/BscWeb3Client");
 const _config_1 = require("@dequanto/utils/$config");
 const AmmV2ExchangeBase_1 = require("./AmmV2ExchangeBase");
 const _require_1 = require("@dequanto/utils/$require");
-const config = _config_1.$config.get('pancackeswap');
-const factory = _require_1.$require.Address(config.factory, 'Factory Address');
-const masterChef = _require_1.$require.Address(config.masterChef, 'MasterChef Address');
-const vault = _require_1.$require.Address(config.vault, 'Vault Address');
 class PancakeswapExchange extends AmmV2ExchangeBase_1.AmmV2ExchangeBase {
     constructor(client = a_di_1.default.resolve(BscWeb3Client_1.BscWeb3Client), explorer = a_di_1.default.resolve(Bscscan_1.Bscscan)) {
         super(client, explorer);
         this.client = client;
         this.explorer = explorer;
         this.name = 'pancake';
-        this.factoryAddress = factory;
-        this.masterChefAddress = masterChef;
-        this.vaultAddress = vault;
+        this.config = _config_1.$config.get('pancackeswap');
+        this.factoryAddress = _require_1.$require.Address(this.config.factory, 'Factory Address');
+        this.masterChefAddress = _require_1.$require.Address(this.config.masterChef, 'MasterChef Address');
+        this.vaultAddress = _require_1.$require.Address(this.config.vault, 'Vault Address');
     }
 }
 exports.PancakeswapExchange = PancakeswapExchange;

package/dist/src/tokens/TokenExchanges/SushiswapPolygonExchange.js

@@ -10,18 +10,17 @@ const BscWeb3Client_1 = require("@dequanto/clients/BscWeb3Client");
 const _config_1 = require("@dequanto/utils/$config");
 const AmmV2ExchangeBase_1 = require("./AmmV2ExchangeBase");
 const _require_1 = require("@dequanto/utils/$require");
-const config = _config_1.$config.get('pancackeswap');
-const factory = _require_1.$require.Address(config.factory, 'Factory Address');
-const masterChef = _require_1.$require.Address(config.masterChef, 'MasterChef Address');
-const vault = _require_1.$require.Address(config.vault, 'Vault Address');
 class SushiswapPolygonExchange extends AmmV2ExchangeBase_1.AmmV2ExchangeBase {
+    // private factory = $require.Address(this.config.factory, 'Factory Address');
+    // private vault = $require.Address(this.config.vault, 'Vault Address');
     constructor(client = a_di_1.default.resolve(BscWeb3Client_1.BscWeb3Client), explorer = a_di_1.default.resolve(Bscscan_1.Bscscan)) {
         super(client, explorer);
         this.client = client;
         this.explorer = explorer;
         this.name = 'sushiswap';
+        this.config = _config_1.$config.get('sushiswap');
         this.factoryAddress = '0xc35dadb65012ec5796536bd9864ed8773abc74c4';
-        this.masterChefAddress = masterChef;
+        this.masterChefAddress = _require_1.$require.Address(this.config?.masterChef ?? '0x0769fd68dFb93167989C6f7254cd0D766Fb2841F', 'MasterChef Address');
         this.vaultAddress = '0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506';
     }
 }

package/dist/src/tokens/TokenExchanges/UniswapExchange.js

@@ -10,19 +10,16 @@ const AmmV2ExchangeBase_1 = require("./AmmV2ExchangeBase");
 const Etherscan_1 = require("@dequanto/BlockchainExplorer/Etherscan");
 const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
 const _require_1 = require("@dequanto/utils/$require");
-const config = _config_1.$config.get('uniswapV2');
-const factory = _require_1.$require.Address(config.factory, 'Factory Address');
-const vault = _require_1.$require.Address(config.vault, 'Vault Address');
-const masterChef = config.masterChef;
 class UniswapExchange extends AmmV2ExchangeBase_1.AmmV2ExchangeBase {
     constructor(client = a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client), explorer = a_di_1.default.resolve(Etherscan_1.Etherscan)) {
         super(client, explorer);
         this.client = client;
         this.explorer = explorer;
         this.name = 'uniswap';
-        this.factoryAddress = factory;
-        this.masterChefAddress = masterChef;
-        this.vaultAddress = vault;
+        this.config = _config_1.$config.get('uniswapV2');
+        this.factoryAddress = _require_1.$require.Address(this.config.factory, 'Factory Address');
+        this.masterChefAddress = _require_1.$require.Address(this.config.vault, 'Vault Address');
+        this.vaultAddress = this.config.masterChef;
     }
 }
 exports.UniswapExchange = UniswapExchange;