dequanto 0.0.1

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

@@ -0,0 +1,16 @@
+"use strict";
+/**
+* dequanto
+* name: AmmPairContractV2Base
+* platform: bsc
+* source.abi: 0x7752e1fa9f3a2e860856458517008558deb989e3
+* output: ./contracts/gen/amm/
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmmPairV2Contract = void 0;
+const AmmPairContractV2Base_1 = require("@dequanto-contracts/gen/amm/AmmPairContractV2Base");
+/* https://pancakeswap.info/token/0x8f0528ce5ef7b51152a59745befdd91d97091d2f */
+/* https://pancakeswap.info/pool/0x7752e1fa9f3a2e860856458517008558deb989e3 */
+class AmmPairV2Contract extends AmmPairContractV2Base_1.AmmPairContractV2Base {
+}
+exports.AmmPairV2Contract = AmmPairV2Contract;

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

@@ -0,0 +1,144 @@
+"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.AmmPairV2Service = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
+const memd_1 = __importDefault(require("memd"));
+const _address_1 = require("@dequanto/utils/$address");
+const PancakeswapExchange_1 = require("@dequanto/tokens/TokenExchanges/PancakeswapExchange");
+const UniswapExchange_1 = require("@dequanto/tokens/TokenExchanges/UniswapExchange");
+const TokensService_1 = require("@dequanto/tokens/TokensService");
+const SushiswapPolygonExchange_1 = require("../../SushiswapPolygonExchange");
+;
+class AmmPairV2Service {
+    constructor(client, explorer) {
+        this.client = client;
+        this.explorer = explorer;
+        this.tokensService = a_di_1.default.resolve(TokensService_1.TokensService, this.client.platform, this.explorer);
+        switch (client.platform) {
+            case 'bsc':
+                this.exchange = a_di_1.default.resolve(PancakeswapExchange_1.PancakeswapExchange, this.client, this.explorer);
+                this.targetCoins = ['BUSD', 'USDT'];
+                break;
+            case 'eth':
+                this.exchange = a_di_1.default.resolve(UniswapExchange_1.UniswapExchange, this.client, this.explorer);
+                this.targetCoins = ['USDC', 'USDT', 'DAI'];
+                break;
+            case 'polygon':
+                this.exchange = a_di_1.default.resolve(SushiswapPolygonExchange_1.SushiswapPolygonExchange, this.client, this.explorer);
+                this.targetCoins = ['USDC', 'USDT', 'DAI'];
+                break;
+            default:
+                throw new Error(`Unsupported Platform for exchange yet: ${client.platform}`);
+        }
+    }
+    async resolveBestStableRoute(platform, address) {
+        let pool = await (0, alot_1.default)(this.targetCoins)
+            .mapAsync(async (symbol) => {
+            return this.getPoolInfo(address, symbol);
+        })
+            .filterAsync(x => x != null)
+            .sortByAsync(({ reserveTo }) => reserveTo, 'desc')
+            .firstAsync();
+        if (pool == null || pool.reserveTo < (50000n * BigInt(pool.pair.to.decimals))) {
+            const SYMBOL = { eth: 'WETH', bsc: 'WBNB' }[platform];
+            const nativeTokenPool = await this.getPoolInfo(address, SYMBOL);
+            if (nativeTokenPool == null || nativeTokenPool.reserveTo < 10) {
+                return null;
+            }
+            let nativeRoute = await this.resolveBestStableRoute(platform, nativeTokenPool.pair.to.address);
+            if (nativeRoute == null) {
+                return null;
+            }
+            return [
+                nativeTokenPool.pair,
+                ...nativeRoute
+            ];
+        }
+        return [pool.pair];
+    }
+    async resolveRoute(address, symbols) {
+        let tokens = await (0, alot_1.default)(symbols)
+            .mapAsync(x => this.tokensService.getTokenOrDefault(x))
+            .toArrayAsync();
+        let prev = address;
+        let out = [];
+        for (let token of tokens) {
+            let poolInfo = await this.getPoolInfo(prev, token.address);
+            out.push(poolInfo.pair);
+            prev = token.address;
+        }
+        return out;
+    }
+    async getPoolInfo(fromAddress, symbol) {
+        let toToken = await this.tokensService.getTokenOrDefault(symbol);
+        if (toToken == null) {
+            return null;
+        }
+        let lpAddress = await this.getPair(fromAddress, toToken.address);
+        if (_address_1.$address.isEmpty(lpAddress)) {
+            return null;
+        }
+        let poolPair = this.exchange.pairContract(lpAddress);
+        let lpReserves = await poolPair.getReserves();
+        if (lpReserves == null || lpReserves._reserve0 < 1000n) {
+            return null;
+        }
+        let [fromI, toI] = BigInt(fromAddress) < BigInt(toToken.address) ? [0, 1] : [1, 0];
+        let reserveFrom = lpReserves[`_reserve${fromI}`];
+        let reserveTo = lpReserves[`_reserve${toI}`];
+        if (toToken.decimals == null) {
+            toToken.decimals = 18;
+        }
+        if (reserveTo < 10n ** BigInt(toToken.decimals ?? 18)) {
+            return null;
+        }
+        let fromToken = await this.tokensService.getTokenOrDefault(fromAddress);
+        return {
+            pair: PairUtil.createPairInfo(fromToken, toToken, lpAddress),
+            reserveTo: Number(reserveTo / 10n ** BigInt(toToken.decimals ?? 18)),
+        };
+    }
+    async getPair(from, to) {
+        return await this.exchange.factoryContract.getPair(from, to);
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({
+        perInstance: true,
+        trackRef: true,
+        persistance: new memd_1.default.FsTransport({ path: `./cache/pools.json` })
+    })
+], AmmPairV2Service.prototype, "resolveBestStableRoute", null);
+__decorate([
+    memd_1.default.deco.memoize()
+], AmmPairV2Service.prototype, "getPair", null);
+exports.AmmPairV2Service = AmmPairV2Service;
+var PairUtil;
+(function (PairUtil) {
+    function createPairInfo(fromToken, toToken, lpAddress) {
+        let token0 = fromToken.address;
+        let token1 = toToken.address;
+        if (BigInt(token1) < BigInt(token0)) {
+            token0 = toToken.address;
+            token1 = fromToken.address;
+        }
+        return {
+            address: lpAddress,
+            token0,
+            token1,
+            from: fromToken,
+            to: toToken,
+        };
+    }
+    PairUtil.createPairInfo = createPairInfo;
+})(PairUtil || (PairUtil = {}));

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

@@ -0,0 +1,15 @@
+"use strict";
+/**
+* dequanto
+* name: AmmRouterV2ContractBase
+* platform: bsc
+* source.abi: 0x10ED43C718714eb63d5aA57B78B54704E256024E
+* output: ./contracts/gen/amm/
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmmRouterV2Contract = void 0;
+const AmmRouterV2ContractBase_1 = require("@dequanto-contracts/gen/amm/AmmRouterV2ContractBase");
+/* https://docs.pancakeswap.finance/code/smart-contracts/pancakeswap-exchange/router-v2 */
+class AmmRouterV2Contract extends AmmRouterV2ContractBase_1.AmmRouterV2ContractBase {
+}
+exports.AmmRouterV2Contract = AmmRouterV2Contract;

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

@@ -0,0 +1,15 @@
+"use strict";
+/**
+* dequanto
+* name: AmmVaultV2ContractBase
+* platform: bsc
+* source.abi: 0xa80240Eb5d7E05d3F250cF000eEc0891d00b51CC
+* output: ./contracts/gen/amm/
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmmVaultV2Contract = void 0;
+const AmmVaultV2ContractBase_1 = require("@dequanto-contracts/gen/amm/AmmVaultV2ContractBase");
+/* https://docs.pancakeswap.finance/code/smart-contracts/cakevault */
+class AmmVaultV2Contract extends AmmVaultV2ContractBase_1.AmmVaultV2ContractBase {
+}
+exports.AmmVaultV2Contract = AmmVaultV2Contract;

package/dist/src/tokens/TokenExchanges/AmmBase/V3/AmmPairV3Contract.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+* dequanto
+* name: AmmPairContractV3Base
+* platform: eth
+* source.abi: 0x8f8ef111b67c04eb1641f5ff19ee54cda062f163
+* output: ./contracts/gen/amm/
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmmPairV3Contract = void 0;
+const AmmPairContractV3Base_1 = require("@dequanto-contracts/gen/amm/AmmPairContractV3Base");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+/* https://info.uniswap.org/#/pools/0x8f8ef111b67c04eb1641f5ff19ee54cda062f163 */
+class AmmPairV3Contract extends AmmPairContractV3Base_1.AmmPairContractV3Base {
+    async getPrice0() {
+        let slot = await this.slot0();
+        let precision = 10n ** 10n;
+        let priceBigInt = (slot.sqrtPriceX96 * slot.sqrtPriceX96 * BigInt(precision)) >> (2n * 96n);
+        return _bigint_1.$bigint.divToFloat(priceBigInt, precision, precision);
+    }
+}
+exports.AmmPairV3Contract = AmmPairV3Contract;

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

@@ -0,0 +1,194 @@
+"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.AmmV2ExchangeBase = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const memd_1 = __importDefault(require("memd"));
+const alot_1 = __importDefault(require("alot"));
+const ContractReader_1 = require("@dequanto/contracts/ContractReader");
+const JsonArrayStore_1 = require("@dequanto/json/JsonArrayStore");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const AmmFactoryV2Contract_1 = require("./AmmBase/V2/AmmFactoryV2Contract");
+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");
+class AmmV2ExchangeBase {
+    constructor(client, explorer) {
+        this.client = client;
+        this.explorer = explorer;
+    }
+    get pairsStore() {
+        return new JsonArrayStore_1.JsonArrayStore({
+            path: `/cache/dequanto/${this.client.platform}/amm/${this.name}/pairs.json`,
+            key: x => x.address
+        });
+    }
+    get factoryContract() {
+        return a_di_1.default.resolve(AmmFactoryV2Contract_1.AmmFactoryV2Contract, this.factoryAddress, this.client, this.explorer);
+    }
+    get masterChefContract() {
+        return a_di_1.default.resolve(AmmMasterChefV2Contract_1.AmmMasterChefV2Contract, this.masterChefAddress, this.client, this.explorer);
+    }
+    get vaultContract() {
+        return a_di_1.default.resolve(AmmVaultV2Contract_1.AmmVaultV2Contract, this.vaultAddress, this.client, this.explorer);
+    }
+    pairContract(pair) {
+        return a_di_1.default.resolve(AmmPairV2Contract_1.AmmPairV2Contract, pair, this.client, this.explorer);
+    }
+    async calcSwap(from, to, fromAmount) {
+        _is_1.$is.BigInt(fromAmount);
+        if (fromAmount === 0n) {
+            return {
+                amount: 0n,
+                priceImpact: 0
+            };
+        }
+        let lpAddress = await this.factoryContract.getPair(from.address, to.address);
+        if (_address_1.$address.isEmpty(lpAddress)) {
+            return null;
+        }
+        let poolPair = this.pairContract(lpAddress);
+        let lpReserves = await poolPair.getReserves();
+        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}`);
+        let [fromI, toI] = BigInt(from.address) < BigInt(to.address) ? [0, 1] : [1, 0];
+        let reserveFrom = lpReserves[`_reserve${fromI}`];
+        let reserveTo = lpReserves[`_reserve${toI}`];
+        let amountIdeal = fromAmount * reserveTo / reserveFrom;
+        let k = reserveFrom * reserveTo;
+        let reserveFromAfter = reserveFrom + fromAmount;
+        let reserveToAfter = k / reserveFromAfter;
+        let amountActual = reserveTo - reserveToAfter;
+        let priceImpactPercents = (1 - _bigint_1.$bigint.divToFloat(amountActual, amountIdeal)) * 100;
+        return {
+            amount: amountActual,
+            priceImpact: priceImpactPercents,
+        };
+    }
+    async getPairs() {
+        let reader = new ContractReader_1.ContractReader(this.client);
+        let addresses = await reader.readAsync(this.factoryAddress, 'allPairs() returns (address[])');
+        return addresses;
+    }
+    async redownloadPairs() {
+        let pairsCached = await this.readPairs();
+        let max = (0, alot_1.default)(pairsCached).max(x => x.i);
+        let i = Math.max(max - 4, 0);
+        let length = await this.factoryContract.allPairsLength();
+        let all = [...pairsCached];
+        let pairs = await alot_1.default
+            .fromRange(i, Number(length))
+            .mapAsync(async (i) => {
+            console.log(`Loading ${i}/${length}`);
+            let pair = await this.getPairInfoAtIndex(i);
+            all.push(pair);
+            if (i % 100 === 0) {
+                await this.savePairs(all);
+            }
+            return pair;
+        })
+            .toArrayAsync();
+        await this.pairsStore.saveAll(pairs);
+        return pairs;
+    }
+    async getPairInfoAtIndex(i) {
+        let factory = this.factoryContract;
+        let pairAddress = await factory.allPairs(BigInt(i));
+        let pairContract = this.pairContract(pairAddress);
+        let [symbol, token0Addr, token1Addr,] = await Promise.all([
+            pairContract.symbol(),
+            pairContract.token0(),
+            pairContract.token1(),
+        ]);
+        let tokensService = a_di_1.default.resolve(TokensServiceBsc_1.TokensServiceBsc);
+        let [token0, token1] = await Promise.all([
+            tokensService.getTokenOrDefault(token0Addr),
+            tokensService.getTokenOrDefault(token1Addr),
+        ]);
+        return {
+            name: symbol,
+            symbol: symbol,
+            platform: 'bsc',
+            address: pairAddress,
+            i: Number(i),
+            token0: token0,
+            token1: token1,
+        };
+    }
+    async savePairs(pairs) {
+        let jsons = pairs.map(pair => ({
+            address: pair.address,
+            i: pair.i,
+            token0: {
+                "symbol": pair.token0.symbol,
+                "address": pair.token0.address,
+                "decimals": (pair.token0.decimals == null || pair.token0.decimals === 18)
+                    ? void 0
+                    : pair.token0.decimals,
+            },
+            token1: {
+                "symbol": pair.token1.symbol,
+                "address": pair.token1.address,
+                "decimals": (pair.token1.decimals == null || pair.token1.decimals === 18)
+                    ? void 0
+                    : pair.token1.decimals,
+            },
+        }));
+        await this.pairsStore.saveAll(jsons);
+    }
+    async readPairs() {
+        let jsons = await this.pairsStore.getAll();
+        let pairs = jsons.map(pair => ({
+            "name": "LP",
+            "symbol": "LP",
+            "platform": this.client.platform,
+            address: pair.address,
+            i: pair.i,
+            token0: {
+                "platform": this.client.platform,
+                "symbol": pair.token0.symbol,
+                "name": pair.token0.symbol,
+                "address": pair.token0.address,
+                "decimals": pair.token0.decimals ?? 18,
+            },
+            token1: {
+                "platform": this.client.platform,
+                "symbol": pair.token1.symbol,
+                "name": pair.token1.symbol,
+                "address": pair.token1.address,
+                "decimals": pair.token1.decimals ?? 18,
+            },
+        }));
+        return pairs;
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], AmmV2ExchangeBase.prototype, "pairsStore", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], AmmV2ExchangeBase.prototype, "factoryContract", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], AmmV2ExchangeBase.prototype, "masterChefContract", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], AmmV2ExchangeBase.prototype, "vaultContract", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], AmmV2ExchangeBase.prototype, "pairContract", null);
+exports.AmmV2ExchangeBase = AmmV2ExchangeBase;

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

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneInchExchange = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const axios_1 = __importDefault(require("axios"));
+const BlockChainExplorerProvider_1 = require("@dequanto/BlockchainExplorer/BlockChainExplorerProvider");
+const Web3ClientFactory_1 = require("@dequanto/clients/Web3ClientFactory");
+const ERC20_1 = require("@dequanto/contracts/common/ERC20");
+const atma_utils_1 = require("atma-utils");
+const TokensService_1 = require("../TokensService");
+const TxWriter_1 = require("@dequanto/txs/TxWriter");
+const TxDataBuilder_1 = require("@dequanto/txs/TxDataBuilder");
+const PLATFORMS = {
+    eth: 1,
+    bsc: 56,
+    polygon: 137,
+};
+class OneInchExchange {
+    constructor(platform) {
+        this.platform = platform;
+        this.client = Web3ClientFactory_1.Web3ClientFactory.get(this.platform);
+        this.explorer = BlockChainExplorerProvider_1.BlockChainExplorerProvider.get(this.platform);
+    }
+    async approve(account, from, fromAmount, spender) {
+        let tokens = a_di_1.default.resolve(TokensService_1.TokensService, this.platform, this.explorer);
+        let $from = typeof from === 'string' ? await tokens.getToken(from) : from;
+        let erc20 = new ERC20_1.ERC20($from.address, this.client, this.explorer);
+        if (spender != null) {
+            let current = await erc20.allowance(account.address, spender);
+            if (current > 10n ** 25n) {
+                return;
+            }
+        }
+        let query = [
+            `infinity=true`,
+            `tokenAddress=${$from.address}`,
+        ];
+        let callURL = this.getUrl(`/approve/calldata?${query.join('&')}`);
+        let { data: tx } = await axios_1.default.get(callURL);
+        let txWriter = await this.sendTx(account, tx);
+        let receipt = await txWriter.onCompleted;
+        return txWriter;
+    }
+    async swap(account, from, to, fromAmount) {
+        let tokens = a_di_1.default.resolve(TokensService_1.TokensService, this.platform, this.explorer);
+        let $owner = account.address;
+        let $from = typeof from === 'string' ? await tokens.getToken(from) : from;
+        let $to = typeof to === 'string' ? await tokens.getToken(to) : to;
+        let $amount = await this.getAmount($owner, $from, fromAmount);
+        let query = [
+            `fromTokenAddress=${$from.address}`,
+            `toTokenAddress=${$to.address}`,
+            `amount=${$amount}`,
+            `fromAddress=${$owner}`,
+            `slippage=3`
+        ];
+        let callURL = this.getUrl(`/swap?${query.join('&')}`);
+        let { data } = await axios_1.default.get(callURL);
+        await this.approve(account, from, Infinity, data.tx.to);
+        return this.sendTx(account, data.tx);
+    }
+    getUrl(path) {
+        let chainId = PLATFORMS[this.platform];
+        return atma_utils_1.class_Uri.combine(`https://api.1inch.exchange/v3.0/${chainId}/`, path);
+    }
+    async getAmount(owner, token, amount) {
+        if (amount === Infinity) {
+            let erc20 = new ERC20_1.ERC20(token.address, this.client, this.explorer);
+            let balance = await erc20.balanceOf(owner);
+            return balance;
+        }
+        let decimals = Number(token.decimals);
+        if (isNaN(decimals)) {
+            throw new Error(`Decimals are not defined for ${token.symbol} in ${this.platform}`);
+        }
+        return BigInt(amount) * 10n ** BigInt(decimals);
+    }
+    async sendTx(account, calldata) {
+        let txData = TxDataBuilder_1.TxDataBuilder.normalize(calldata);
+        let $txData = txData;
+        let gas = $txData.gas;
+        delete $txData.gas;
+        $txData.gasLimit = BigInt(gas) * 2n;
+        let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, account, txData);
+        await txBuilder.setNonce();
+        return TxWriter_1.TxWriter.write(this.client, txBuilder, account);
+    }
+}
+exports.OneInchExchange = OneInchExchange;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PancakeswapExchange = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const Bscscan_1 = require("@dequanto/BlockchainExplorer/Bscscan");
+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;
+    }
+}
+exports.PancakeswapExchange = PancakeswapExchange;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SushiswapPolygonExchange = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const Bscscan_1 = require("@dequanto/BlockchainExplorer/Bscscan");
+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 {
+    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.factoryAddress = '0xc35dadb65012ec5796536bd9864ed8773abc74c4';
+        this.masterChefAddress = masterChef;
+        this.vaultAddress = '0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506';
+    }
+}
+exports.SushiswapPolygonExchange = SushiswapPolygonExchange;

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapExchange = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const _config_1 = require("@dequanto/utils/$config");
+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;
+    }
+}
+exports.UniswapExchange = UniswapExchange;