dequanto 0.0.1

package/dist/src/tokens/TokensService.js

@@ -0,0 +1,236 @@
+"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.TokensService = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
+const memd_1 = __importDefault(require("memd"));
+const TPSushiswap_1 = require("./TokenProviders/TPSushiswap");
+const TPCoinmarketcap_1 = require("./TokenProviders/TPCoinmarketcap");
+const TPOneInch_1 = require("./TokenProviders/TPOneInch");
+const TPChain_1 = require("./TokenProviders/TPChain");
+const ERC20_1 = require("@dequanto/contracts/common/ERC20");
+const Web3ClientFactory_1 = require("@dequanto/clients/Web3ClientFactory");
+const BlockChainExplorerProvider_1 = require("@dequanto/BlockchainExplorer/BlockChainExplorerProvider");
+const _address_1 = require("@dequanto/utils/$address");
+const ArbTokenProvider_1 = require("@dequanto/chains/arbitrum/ArbTokenProvider");
+const _require_1 = require("@dequanto/utils/$require");
+class TokensService {
+    constructor(platform, explorer) {
+        this.platform = platform;
+        this.explorer = explorer;
+        this.providers = [
+            new TPOneInch_1.TPOneInch(),
+            new TPSushiswap_1.TPSushiswap(),
+            // @TODO uniswap thegraph api doesn't work any more
+            // new TPUniswap(),
+            new TPCoinmarketcap_1.TPCoinmarketcap(),
+            new ArbTokenProvider_1.ArbTokenProvider(),
+            new TPChain_1.TPChain(this.platform, this.explorer),
+        ];
+    }
+    async getTokenOrDefault(address, chainLookup = true) {
+        return await this.getToken(address, chainLookup) ?? this.default(address);
+    }
+    async getToken(mix, chainLookup = true) {
+        let [token, provider] = mix.startsWith('0x')
+            ? await this.getTokenByAddress(mix, chainLookup)
+            : await this.getTokenBySymbol(mix, chainLookup);
+        return token;
+    }
+    async getKnownToken(mix) {
+        let [token, provider] = mix.startsWith('0x')
+            ? await this.getTokenByAddress(mix, false)
+            : await this.getTokenBySymbol(mix, false);
+        if (token == null) {
+            throw new Error(`Token ${mix} not found`);
+        }
+        return token;
+    }
+    isNative(mix) {
+        _require_1.$require.notNull(mix, `Token is undefined`);
+        if (typeof mix === 'object') {
+            return this.isNative(mix.symbol ?? mix.address);
+        }
+        if (mix.startsWith('0x')) {
+            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 TPChain_1.TPChain && 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 TPChain_1.TPChain && 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,
+        };
+    }
+    static async erc20(token, platform) {
+        let client = Web3ClientFactory_1.Web3ClientFactory.get(platform);
+        let explorer = BlockChainExplorerProvider_1.BlockChainExplorerProvider.get(platform);
+        if (typeof token === 'string') {
+            let service = a_di_1.default.resolve(TokensService, platform, explorer);
+            token = await service.getToken(token);
+        }
+        if (token == null) {
+            throw new Error(`Token not found: ${arguments[0]}`);
+        }
+        return new ERC20_1.ERC20(token.address, client, explorer);
+    }
+    async erc20(token) {
+        let client = Web3ClientFactory_1.Web3ClientFactory.get(this.platform);
+        let explorer = BlockChainExplorerProvider_1.BlockChainExplorerProvider.get(this.platform);
+        let t = typeof token === 'string'
+            ? await this.getToken(token)
+            : token;
+        if (t == null) {
+            if (typeof token === 'string' && _address_1.$address.isValid(token)) {
+                t = {
+                    address: token,
+                    decimals: 18,
+                    platform: this.platform
+                };
+            }
+            throw new Error(`Token not found: ${arguments[0]}`);
+        }
+        return new ERC20_1.ERC20(t.address, client, explorer);
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], TokensService.prototype, "getToken", null);
+__decorate([
+    memd_1.default.deco.memoize({ perInstance: true })
+], TokensService.prototype, "getKnownToken", null);
+__decorate([
+    memd_1.default.deco.memoize()
+], TokensService.prototype, "erc20", null);
+__decorate([
+    memd_1.default.deco.memoize()
+], TokensService, "erc20", null);
+exports.TokensService = TokensService;
+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,
+        },
+    };
+    const PLATFORMS = {
+        'eth': 'ETH',
+        'bsc': 'BNB',
+        'polygon': 'MATIC',
+        'xdai': 'xDAI',
+    };
+    function isNativeBySymbol(platform, symbol) {
+        if (symbol == null) {
+            return false;
+        }
+        symbol = symbol.toUpperCase();
+        return symbol in tokens;
+    }
+    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) {
+        let symbol = PLATFORMS[platform];
+        if (symbol == null) {
+            throw new Error(`${platform} platform is not support`);
+        }
+        return tokens[symbol.toUpperCase()];
+    }
+    NativeTokens.getNative = getNative;
+})(NativeTokens || (NativeTokens = {}));

package/dist/src/tokens/TokensServiceBsc.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokensServiceBsc = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const TokensService_1 = require("./TokensService");
+const Bscscan_1 = require("@dequanto/BlockchainExplorer/Bscscan");
+class TokensServiceBsc extends TokensService_1.TokensService {
+    constructor() {
+        super('bsc', a_di_1.default.resolve(Bscscan_1.Bscscan));
+    }
+    static async erc20(mix) {
+        return TokensService_1.TokensService.erc20(mix, 'bsc');
+    }
+}
+exports.TokensServiceBsc = TokensServiceBsc;

package/dist/src/tokens/TokensServiceEth.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokensServiceEth = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const TokensService_1 = require("./TokensService");
+const Etherscan_1 = require("@dequanto/BlockchainExplorer/Etherscan");
+class TokensServiceEth extends TokensService_1.TokensService {
+    constructor() {
+        super('eth', a_di_1.default.resolve(Etherscan_1.Etherscan));
+    }
+}
+exports.TokensServiceEth = TokensServiceEth;

package/dist/src/tokens/TokensServiceFactory.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokensServiceFactory = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const TokensServiceBsc_1 = require("./TokensServiceBsc");
+const TokensServiceEth_1 = require("./TokensServiceEth");
+const TokensServicePolygon_1 = require("./TokensServicePolygon");
+const TokensServiceXDai_1 = require("./TokensServiceXDai");
+var TokensServiceFactory;
+(function (TokensServiceFactory) {
+    function get(platform) {
+        switch (platform) {
+            case 'bsc':
+                return a_di_1.default.resolve(TokensServiceBsc_1.TokensServiceBsc);
+            case 'eth':
+                return a_di_1.default.resolve(TokensServiceEth_1.TokensServiceEth);
+            case 'polygon':
+                return a_di_1.default.resolve(TokensServicePolygon_1.TokensServicePolygon);
+            case 'xdai':
+                return a_di_1.default.resolve(TokensServiceXDai_1.TokensServiceXDai);
+            default:
+                throw new Error(`Unsupported platform ${platform} for TokensService`);
+        }
+    }
+    TokensServiceFactory.get = get;
+})(TokensServiceFactory = exports.TokensServiceFactory || (exports.TokensServiceFactory = {}));

package/dist/src/tokens/TokensServicePolygon.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokensServicePolygon = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const TokensService_1 = require("./TokensService");
+const Polyscan_1 = require("@dequanto/BlockchainExplorer/Polyscan");
+class TokensServicePolygon extends TokensService_1.TokensService {
+    constructor() {
+        super('polygon', a_di_1.default.resolve(Polyscan_1.Polyscan));
+    }
+    static async erc20(mix) {
+        return TokensService_1.TokensService.erc20(mix, 'polygon');
+    }
+}
+exports.TokensServicePolygon = TokensServicePolygon;

package/dist/src/tokens/TokensServiceXDai.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokensServiceXDai = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const TokensService_1 = require("./TokensService");
+const XDaiscan_1 = require("@dequanto/chains/xdai/XDaiscan");
+class TokensServiceXDai extends TokensService_1.TokensService {
+    constructor() {
+        super('xdai', a_di_1.default.resolve(XDaiscan_1.XDaiscan));
+    }
+    static async erc20(mix) {
+        return TokensService_1.TokensService.erc20(mix, 'xdai');
+    }
+    async getTokenBySymbol(symbol, chainLookup = true) {
+        if (symbol === 'DAI') {
+            symbol = 'wxDAI';
+        }
+        return super.getTokenBySymbol(symbol, chainLookup);
+    }
+}
+exports.TokensServiceXDai = TokensServiceXDai;

package/dist/src/tokens/defi/ISwapService.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/tokens/defi/paraswap/Paraswap.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Paraswap = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const TokensServiceFactory_1 = require("@dequanto/tokens/TokensServiceFactory");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const paraswap_1 = require("paraswap");
+const paraswap_core_1 = require("paraswap-core");
+const TxWriter_1 = require("@dequanto/txs/TxWriter");
+const TxDataBuilder_1 = require("@dequanto/txs/TxDataBuilder");
+const PolyWeb3Client_1 = require("@dequanto/clients/PolyWeb3Client");
+const TokensService_1 = require("@dequanto/tokens/TokensService");
+class Paraswap {
+    constructor(platform, client = a_di_1.default.resolve(PolyWeb3Client_1.PolyWeb3Client)) {
+        this.platform = platform;
+        this.client = client;
+        this.tokensProvider = TokensServiceFactory_1.TokensServiceFactory.get(this.platform);
+    }
+    async balanceOf(address, token) {
+        let erc20 = await TokensService_1.TokensService.erc20(token, this.client.platform);
+        let balance = await erc20.balanceOf(address);
+        return balance;
+    }
+    async swap(account, params) {
+        const [fromToken, toToken] = await this.getTokens(params.from, params.to);
+        let approveTx = await this.ensureApproved(account, fromToken, params.fromAmount);
+        if (approveTx) {
+            await approveTx.onCompleted;
+        }
+        let txData = await this.getSwapTransaction({
+            from: fromToken,
+            to: toToken,
+            userAddress: account.address,
+            fromAmount: params.fromAmount,
+        });
+        let tx = await this.sendTx(account, txData);
+        return tx;
+    }
+    async ensureApproved(account, token, amount) {
+        token = await this.getToken(token);
+        const SPENDER = `0x216b4b4ba9f3e719726886d34a177484278bfcae`;
+        const erc20 = await TokensService_1.TokensService.erc20(token.address, this.client.platform);
+        let approved = await erc20
+            .allowance(account.address, SPENDER);
+        let toApprove = typeof amount === 'bigint'
+            ? amount
+            : _bigint_1.$bigint.toWei(amount, token.decimals);
+        if ((toApprove * 2n) > approved) {
+            return await erc20.approve(account, SPENDER, toApprove * 2n);
+        }
+        return null;
+    }
+    async getSwapTransaction(params) {
+        let [from, to] = await this.getTokens(params.from, params.to);
+        const srcAmount = typeof params.fromAmount === 'bigint'
+            ? String(params.fromAmount)
+            : String(BigInt(params.fromAmount) * 10n ** BigInt(from.decimals));
+        const swapper = a_di_1.default.resolve(Swapper, this.platform);
+        const priceRoute = await swapper.getRate({
+            from: from,
+            to: to,
+            userAddress: params.userAddress,
+            fromAmount: srcAmount,
+        });
+        const slippage = params.slippage ?? 1;
+        const minAmount = _bigint_1.$bigint
+            .multWithFloat(BigInt(priceRoute.destAmount), 1 - slippage / 100)
+            .toString();
+        const transactionRequest = await swapper.buildSwap({
+            from: from,
+            to: to,
+            fromAmount: srcAmount,
+            toMinAmount: minAmount,
+            priceRoute: priceRoute,
+            userAddress: params.userAddress,
+            receiver: params.receiver,
+            partner: params.partner
+        });
+        return transactionRequest;
+    }
+    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);
+    }
+    async getTokens(from, to) {
+        return await Promise.all([
+            this.getToken(from),
+            this.getToken(to)
+        ]);
+    }
+    async getToken(mix) {
+        let token = typeof mix === 'string'
+            ? await this.tokensProvider.getKnownToken(mix)
+            : mix;
+        if (token == null || token.address == null) {
+            throw new Error(`Address undefined: ${token}`);
+        }
+        return token;
+    }
+}
+exports.Paraswap = Paraswap;
+const NETWORK_IDS = {
+    'polygon': 137,
+};
+class Swapper {
+    constructor(platform) {
+        this.platform = platform;
+        this.paraswap = new paraswap_1.ParaSwap(NETWORK_IDS[this.platform]);
+    }
+    async getRate(params) {
+        const priceRouteOrError = await this.paraswap.getRate(params.from.address, params.to.address, params.fromAmount, params.userAddress, paraswap_core_1.SwapSide.SELL, { partner: params.partner }, params.from.decimals, params.to.decimals);
+        if ('message' in priceRouteOrError) {
+            throw new Error(priceRouteOrError.message);
+        }
+        return priceRouteOrError;
+    }
+    ;
+    async buildSwap(params) {
+        const transactionRequestOrError = await this.paraswap.buildTx(params.from.address, params.to.address, params.fromAmount, params.toMinAmount, params.priceRoute, params.userAddress, params.partner, undefined, undefined, params.receiver);
+        if ('message' in transactionRequestOrError) {
+            throw new Error(transactionRequestOrError.message);
+        }
+        return transactionRequestOrError;
+    }
+    ;
+}

package/dist/src/tokens/erc20/eth/WETH.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * dequanto
+ * name: WETHBase
+ * platform: eth
+ * source.abi: 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
+ * output: ./contracts/gen/eth/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WETH = void 0;
+const WETHBase_1 = require("@dequanto-contracts/gen/eth/WETHBase");
+class WETH extends WETHBase_1.WETHBase {
+}
+exports.WETH = WETH;

package/dist/src/tokens/utils/TokenUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenUtils = void 0;
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const _number_1 = require("@dequanto/utils/$number");
+const alot_1 = __importDefault(require("alot"));
+var TokenUtils;
+(function (TokenUtils) {
+    function isStable(symbol) {
+        return /^[tb]?usd[tc]?$/i.test(symbol) || /^(dai)$/i.test(symbol);
+    }
+    TokenUtils.isStable = isStable;
+    function calcUsdIfStable(amount, token) {
+        if (isStable(token.symbol) === false) {
+            return null;
+        }
+        let tokenBase = 10n ** BigInt(token.decimals);
+        return _bigint_1.$bigint.divToFloat(amount, tokenBase, 10n ** 8n);
+    }
+    TokenUtils.calcUsdIfStable = calcUsdIfStable;
+    function calcPrice(amount, token, usd) {
+        if (usd == null) {
+            return null;
+        }
+        let tokenBase = 10n ** BigInt(token.decimals);
+        let tokenAmount = _bigint_1.$bigint.divToFloat(amount, tokenBase, 10n ** 8n);
+        return _number_1.$number.div(usd, tokenAmount);
+    }
+    TokenUtils.calcPrice = calcPrice;
+    function calcTotal(token, amount, price) {
+        if (price == null) {
+            return null;
+        }
+        let tokenBase = 10n ** BigInt(token.decimals);
+        let tokenAmount = _bigint_1.$bigint.divToFloat(amount, tokenBase, 10n ** 8n);
+        return tokenAmount * price;
+    }
+    TokenUtils.calcTotal = calcTotal;
+    function merge(...tokens) {
+        let all = (0, alot_1.default)(tokens)
+            .mapMany(arr => arr)
+            .groupBy(x => x.symbol)
+            .map(group => {
+            let logo = group.values.find(x => x.logo)?.logo;
+            let token = group.values[0];
+            return {
+                symbol: token.symbol,
+                name: token.name,
+                logo: logo,
+                platforms: group.values.map(t => {
+                    return {
+                        address: t.address,
+                        decimals: t.decimals,
+                        platform: t.platform,
+                    };
+                })
+            };
+        })
+            .toArray();
+        return all;
+    }
+    TokenUtils.merge = merge;
+})(TokenUtils = exports.TokenUtils || (exports.TokenUtils = {}));

package/dist/src/txs/ITxConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });