dequanto 0.0.1

package/dist/src/tokens/TokenOracles/AmmPriceV2Oracle.js

@@ -0,0 +1,319 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenRangePriceService = exports.AmmPriceV2Oracle = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
+const PancakeswapExchange_1 = require("../TokenExchanges/PancakeswapExchange");
+const UniswapExchange_1 = require("../TokenExchanges/UniswapExchange");
+const TokenUtils_1 = require("../utils/TokenUtils");
+const TokensService_1 = require("../TokensService");
+const _address_1 = require("@dequanto/utils/$address");
+const LoggerService_1 = require("@dequanto/loggers/LoggerService");
+const TokenPriceStore_1 = require("./TokenPriceStore");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const AmmPairV2Service_1 = require("../TokenExchanges/AmmBase/V2/AmmPairV2Service");
+const SushiswapPolygonExchange_1 = require("../TokenExchanges/SushiswapPolygonExchange");
+const _logger_1 = require("@dequanto/utils/$logger");
+class AmmPriceV2Oracle {
+    constructor(client, explorer) {
+        this.client = client;
+        this.explorer = explorer;
+        this.tokensService = a_di_1.default.resolve(TokensService_1.TokensService, this.client.platform, this.explorer);
+        this.pairService = a_di_1.default.resolve(AmmPairV2Service_1.AmmPairV2Service, this.client, this.explorer);
+        this.logger = a_di_1.default.resolve(LoggerService_1.LoggerService, nameof(AmmPriceV2Oracle));
+        switch (client.platform) {
+            case 'bsc':
+                this.exchange = a_di_1.default.resolve(PancakeswapExchange_1.PancakeswapExchange, this.client, this.explorer);
+                break;
+            case 'eth':
+                this.exchange = a_di_1.default.resolve(UniswapExchange_1.UniswapExchange, this.client, this.explorer);
+                break;
+            case 'polygon':
+                this.exchange = a_di_1.default.resolve(SushiswapPolygonExchange_1.SushiswapPolygonExchange, this.client, this.explorer);
+                break;
+            default:
+                throw new Error(`Unsupported Platform for exchange yet: ${client.platform}`);
+        }
+    }
+    async getPrice(token, opts) {
+        let amount = opts?.amountWei ?? (BigInt(opts?.amount ?? 1) * 10n ** BigInt(token.decimals));
+        if (TokenUtils_1.TokenUtils.isStable(token.symbol)) {
+            // Assume swap 1:1
+            let usd = _bigint_1.$bigint.divToFloat(amount, 10n ** BigInt(token.decimals));
+            return {
+                result: {
+                    outToken: token,
+                    outAmount: amount,
+                    outUsd: usd,
+                    outUsdPrice: 1,
+                    inToken: token,
+                    inAmount: amount,
+                    inUsd: usd,
+                    inUsdPrice: 1,
+                    route: [],
+                }
+            };
+        }
+        let cacheableDate = opts?.date ?? (opts?.block == null && new Date() || null);
+        if (cacheableDate != null) {
+            let swap = await this.getSwapFromCache(token, amount, cacheableDate);
+            if (swap != null) {
+                return swap;
+            }
+        }
+        let pairs;
+        if (opts?.pairs) {
+            pairs = opts.pairs.map(pair => {
+                let tokens = [pair.from.address, pair.to.address];
+                let sorted = BigInt(tokens[0]) < BigInt(tokens[1]);
+                return {
+                    address: pair.address,
+                    token0: sorted ? tokens[0] : tokens[1],
+                    token1: sorted ? tokens[1] : tokens[0],
+                    from: pair.from,
+                    to: pair.to
+                };
+            });
+        }
+        let route = pairs ?? (opts?.route != null
+            ? await this.pairService.resolveRoute(token.address, opts.route)
+            : await this.pairService.resolveBestStableRoute(this.client.platform, token.address));
+        if (route == null || route.length === 0) {
+            let error = new Error(`Route not found for Token ${token.address}`);
+            this.logger.write(error.message);
+            return { error };
+        }
+        let pools = await (0, alot_1.default)(route).mapAsync(async (lp) => {
+            if (cacheableDate != null) {
+                let price = await this.getPriceInUsdFromCache(lp.from.address, cacheableDate);
+                if (price != null) {
+                    return {
+                        result: {
+                            ...lp,
+                            date: cacheableDate,
+                            priceFrom: price
+                        }
+                    };
+                }
+            }
+            let poolPair = this.exchange.pairContract(lp.address);
+            let lpReserves = await poolPair
+                .forBlock(opts?.block ?? opts?.date)
+                .getReserves();
+            if (lpReserves == null || lpReserves._reserve0 < 1000n) {
+                let error = new Error(`Small reserve in the routed pool ${lp.address}: ${lpReserves._reserve1} - ${lpReserves._reserve0}`);
+                this.logger.write(error.message);
+                return { error };
+            }
+            return {
+                result: {
+                    ...lp,
+                    date: cacheableDate,
+                    reserves: lpReserves
+                }
+            };
+        }).toArrayAsync({ errors: 'reject' });
+        let error = (0, alot_1.default)(pools).first(x => x.error != null)?.error;
+        if (error != null) {
+            return { error };
+        }
+        let swapped = await TokenPrice.swapRouted(token, amount, pools.map(x => x.result), this.tokensService);
+        return { result: swapped };
+    }
+    async getSwapFromCache(token, inAmount, date) {
+        if (date == null) {
+            return null;
+        }
+        let inPrice = await this.getPriceInUsdFromCache(token.address, date);
+        if (inPrice == null) {
+            return null;
+        }
+        let usdcToken = await this.tokensService.getToken('USDC');
+        let outAmount = inAmount
+            * (_bigint_1.$bigint.toBigInt(inPrice * 10 ** 6) * _bigint_1.$bigint.pow(10, usdcToken.decimals - 6))
+            / (_bigint_1.$bigint.pow(10, token.decimals));
+        let outUsd = _bigint_1.$bigint.divToFloat(outAmount, 10n ** BigInt(token.decimals));
+        return {
+            result: {
+                outToken: usdcToken,
+                outAmount: outAmount,
+                outUsd: outUsd,
+                outUsdPrice: 1,
+                inToken: token,
+                inAmount: inAmount,
+                inUsd: outUsd,
+                inUsdPrice: inPrice,
+                route: [],
+            }
+        };
+    }
+    async getPriceInUsdFromCache(token, date) {
+        if (date == null) {
+            return null;
+        }
+        return TokenPriceStore_1.TokenPriceStore.forToken(token).getPrice(date.getTime());
+    }
+    async setPriceInUsdToCache(token, date, price) {
+        if (date == null) {
+            return null;
+        }
+        return TokenPriceStore_1.TokenPriceStore.forToken(token).setPrice(price, date.getTime());
+    }
+}
+exports.AmmPriceV2Oracle = AmmPriceV2Oracle;
+class TokenRangePriceService {
+    constructor(service) {
+        this.service = service;
+        this.cache = new Map();
+        this.INTERVAL = 5 * 60 * 1000;
+    }
+    async getPrice(mix, opts) {
+        let key = typeof mix === 'string'
+            ? mix
+            : mix.address;
+        let byBlock = null;
+        let byDate = null;
+        if (opts?.block != null) {
+            byBlock = opts.block;
+            key += '_' + (byBlock - byBlock % 20) + '';
+        }
+        else {
+            let d = opts.date ?? new Date;
+            byDate = new Date(d);
+            byDate.setMilliseconds(0);
+            byDate.setSeconds(0);
+            let minutes = byDate.getMinutes();
+            minutes -= minutes % 5;
+            byDate.setMinutes(minutes);
+            key += '_' + byDate.toISOString();
+        }
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        let promise = this.service.getPrice(mix, {
+            ...(opts ?? {}),
+            date: byDate,
+            block: byBlock
+        });
+        this.cache.set(key, promise);
+        return promise;
+    }
+}
+exports.TokenRangePriceService = TokenRangePriceService;
+var TokenPrice;
+(function (TokenPrice) {
+    async function swapRouted(fromToken, fromAmount, route, tokenService) {
+        let $step;
+        let $fromToken = fromToken;
+        let $fromAmount = fromAmount;
+        let $route = [];
+        for (let i = 0; i < route.length; i++) {
+            $step = await calcSwap($fromToken, $fromAmount, route[i], tokenService);
+            $fromAmount = $step.toAmount;
+            $fromToken = $step.to;
+            $route.push($step);
+        }
+        calcUsdFromRoute($route);
+        let $stepFirst = $route[0];
+        //console.log('LAST STEP for ', fromToken.symbol, $step);
+        return {
+            outToken: $step.to,
+            outAmount: $step.toAmount,
+            outUsd: $step.toUsd,
+            outUsdPrice: $step.toPrice,
+            inToken: $stepFirst.from,
+            inAmount: $stepFirst.fromAmount,
+            inUsd: $stepFirst.fromUsd,
+            inUsdPrice: $stepFirst.fromPrice,
+            route: $route,
+        };
+    }
+    TokenPrice.swapRouted = swapRouted;
+    function calcUsdFromRoute(route) {
+        let knownUsd = route.find(x => x.fromUsd != null || x.toUsd != null);
+        if (knownUsd == null) {
+            return;
+        }
+        let knownUsdI = route.indexOf(knownUsd);
+        for (let i = knownUsdI - 1; i > -1; i--) {
+            let knownPrice = route[i + 1];
+            let prev = route[i];
+            prev.toUsd = knownPrice.fromUsd;
+            prev.toPrice = TokenUtils_1.TokenUtils.calcPrice(prev.toAmount, prev.to, prev.toUsd);
+            prev.fromUsd = prev.toUsd;
+            prev.fromPrice = TokenUtils_1.TokenUtils.calcPrice(prev.fromAmount, prev.from, prev.fromUsd);
+        }
+        for (let i = knownUsdI + 1; i < route.length; i++) {
+            let knownPrice = route[i - 1];
+            let next = route[i];
+            next.fromUsd = knownPrice.toUsd;
+            next.fromPrice = TokenUtils_1.TokenUtils.calcPrice(next.fromAmount, next.from, next.fromUsd);
+            next.toUsd = next.fromUsd;
+            next.toPrice = TokenUtils_1.TokenUtils.calcPrice(next.toAmount, next.to, next.toUsd);
+        }
+    }
+    async function calcPrices(swapped) {
+    }
+    TokenPrice.calcPrices = calcPrices;
+    async function calcSwap(fromToken, fromAmount, lp, tokenService) {
+        let fromTokenAddress = lp.from.address;
+        let toTokenAddress = lp.to.address;
+        if (_address_1.$address.eq(fromTokenAddress, fromToken.address) === false) {
+            throw new Error(`Invalid from token addres ${fromTokenAddress} != ${fromToken.address}`);
+        }
+        let $fromPrice = lp.fromPrice;
+        if ($fromPrice != null) {
+            let $fromUsd = TokenUtils_1.TokenUtils.calcTotal(fromToken, fromAmount, $fromPrice);
+            return {
+                from: fromToken,
+                fromAmount: fromAmount,
+                fromUsd: $fromUsd,
+                fromPrice: $fromPrice,
+                // Optimistic assume same USD out.
+                toUsd: $fromUsd
+            };
+        }
+        let [fromI, toI] = BigInt(fromToken.address) < BigInt(toTokenAddress) ? [0, 1] : [1, 0];
+        let toToken = lp.to;
+        let reserveFrom = lp.reserves[`_reserve${fromI}`];
+        let reserveTo = lp.reserves[`_reserve${toI}`];
+        let k = reserveFrom * reserveTo;
+        let reserveFromAfter = reserveFrom + fromAmount;
+        let reserveToAfter = k / reserveFromAfter;
+        let amountActual = reserveTo - reserveToAfter;
+        let fromUsd = TokenUtils_1.TokenUtils.calcUsdIfStable(fromAmount, fromToken);
+        let toUsd = TokenUtils_1.TokenUtils.calcUsdIfStable(amountActual, toToken);
+        let fromPrice = TokenUtils_1.TokenUtils.calcPrice(fromAmount, fromToken, fromUsd ?? toUsd);
+        let toPrice = TokenUtils_1.TokenUtils.calcPrice(amountActual, toToken, toUsd ?? fromUsd);
+        //console.log('FromPice', fromPrice, fromAmount, fromToken, fromUsd, toUsd);
+        _logger_1.$logger.log(`Swap: ${fromToken.symbol}(${fromAmount})[${fromUsd}$] > ${toToken.symbol} (${amountActual})[${toUsd}$]; Price ${fromToken.symbol}: ${fromPrice}`);
+        if (lp.date) {
+            // Cache prices
+            let fromStore = TokenPriceStore_1.TokenPriceStore.forToken(fromToken.address);
+            fromStore.setPrice(fromPrice, lp.date.getTime());
+            let toStore = TokenPriceStore_1.TokenPriceStore.forToken(toToken.address);
+            toStore.setPrice(toPrice, lp.date.getTime());
+        }
+        return {
+            from: lp.from,
+            fromAmount: fromAmount,
+            fromUsd: fromUsd ?? toUsd,
+            fromPrice,
+            to: lp.to,
+            toAmount: amountActual,
+            toUsd: toUsd ?? fromUsd,
+            toPrice,
+            usd: 0,
+            date: new Date(Number(lp.reserves._blockTimestampLast * 1000)),
+            pool: {
+                address: lp.address,
+                reserve0: lp.reserves._reserve0,
+                reserve1: lp.reserves._reserve1,
+            }
+        };
+    }
+    TokenPrice.calcSwap = calcSwap;
+})(TokenPrice || (TokenPrice = {}));

package/dist/src/tokens/TokenOracles/TokenPriceStore.js

@@ -0,0 +1,108 @@
+"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.TokenPriceStore = void 0;
+const JsonArrayStore_1 = require("@dequanto/json/JsonArrayStore");
+const memd_1 = __importDefault(require("memd"));
+class TokenPriceStore {
+    constructor(token) {
+        this.token = token;
+        this.prices = null;
+        this.pricesIdx = {};
+        this.store = new JsonArrayStore_1.JsonArrayStore({
+            path: `./db/tokens/${this.token}.json`,
+            key: x => String(x[0])
+        });
+    }
+    static forToken(token) {
+        return stores[token] ?? (stores[token] = new TokenPriceStore(token));
+    }
+    async getPrice(date = Date.now()) {
+        if (this.prices == null) {
+            await this.restore();
+        }
+        let [timestamp, price] = this.get(date) ?? EMPTY;
+        return price;
+    }
+    async setPrice(price, date = Date.now()) {
+        if (this.prices == null) {
+            await this.restore();
+        }
+        this.add(date, price);
+    }
+    async restore() {
+        let prices = await this.store.getAll() ?? [];
+        prices.forEach(([timestamp, price]) => {
+            this.add(timestamp, price);
+        });
+    }
+    async save() {
+        await this.store.saveAll(this.prices);
+    }
+    add(timestamp, price) {
+        let idx = this.pricesIdx;
+        let $minute = pickMinuteArr(idx, timestamp);
+        let tuple = [timestamp, price];
+        $minute.push(tuple);
+        this.prices.push(tuple);
+        this.save();
+    }
+    get(timestamp, tolerance = 1) {
+        let idx = this.pricesIdx;
+        let ms = timestamp;
+        for (let i = 0; i < tolerance + 1; i++) {
+            let $minute = pickMinuteArr(idx, ms - i * MINUTE);
+            if ($minute.length !== 0) {
+                return $minute[0];
+            }
+            if (i === 0) {
+                continue;
+            }
+            let $minuteAfter = pickMinuteArr(idx, ms + i * MINUTE);
+            if ($minuteAfter.length !== 0) {
+                return $minuteAfter[0];
+            }
+        }
+        return null;
+    }
+}
+__decorate([
+    memd_1.default.deco.memoize()
+], TokenPriceStore.prototype, "restore", null);
+__decorate([
+    memd_1.default.deco.throttle(4 * 1000)
+], TokenPriceStore.prototype, "save", null);
+exports.TokenPriceStore = TokenPriceStore;
+const stores = Object.create(null);
+const EMPTY = [null, null];
+const MINUTE = 60 * 1000;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+const keys = ['', '', ''];
+function split(timestamp) {
+    let day = timestamp / DAY | 0;
+    let hour = timestamp % DAY / HOUR | 0;
+    let minute = timestamp % DAY % HOUR / MINUTE | 0;
+    keys[0] = `_${day}`;
+    keys[1] = `_${hour}`;
+    keys[2] = `_${minute}`;
+    return keys;
+}
+function pickMinuteArr(idx, timestamp) {
+    let [day, hour, min] = split(timestamp);
+    let _day = `_${day}`;
+    let _hour = `_${hour}`;
+    let _min = `_${min}`;
+    let $day = idx[_day] ?? (idx[_day] = Object.create(null));
+    let $hour = $day[_hour] ?? ($day[_hour] = Object.create(null));
+    let $minute = $hour[_min] ?? ($hour[_min] = []);
+    return $minute;
+}

package/dist/src/tokens/TokenPriceService.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenPriceServiceCacheable = exports.TokenPriceService = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const TokenUtils_1 = require("./utils/TokenUtils");
+const TokensService_1 = require("./TokensService");
+const _address_1 = require("@dequanto/utils/$address");
+const AmmPriceV2Oracle_1 = require("./TokenOracles/AmmPriceV2Oracle");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const _logger_1 = require("@dequanto/utils/$logger");
+class TokenPriceService {
+    constructor(client, explorer) {
+        this.client = client;
+        this.explorer = explorer;
+        this.tokens = a_di_1.default.resolve(TokensService_1.TokensService, this.client.platform, this.explorer);
+        this.oracle = a_di_1.default.resolve(AmmPriceV2Oracle_1.AmmPriceV2Oracle, this.client, this.explorer);
+    }
+    async getPrice(mix, opts) {
+        let token;
+        try {
+            token = typeof mix === 'string'
+                ? await this.tokens.getKnownToken(mix)
+                : mix;
+        }
+        catch (error) { }
+        if (token == null) {
+            return { error: new Error(`Token ${mix} not found`) };
+        }
+        if (token.decimals == null) {
+            return { error: new Error(`Token has no decimals ${token.symbol}`) };
+        }
+        let { error, result } = await this.oracle.getPrice(token, opts);
+        if (error != null) {
+            return { error };
+        }
+        return {
+            price: result.outUsd,
+            pools: result.route.map(route => {
+                let sorted = BigInt(route.from.address) < BigInt(route.to.address);
+                let t1 = {
+                    price: sorted ? route.fromPrice : route.toPrice,
+                    decimals: sorted ? route.from.decimals : route.to.decimals,
+                    total: sorted ? route.pool.reserve0 : route.pool.reserve1,
+                };
+                let t2 = {
+                    price: sorted ? route.toPrice : route.fromPrice,
+                    decimals: sorted ? route.to.decimals : route.from.decimals,
+                    total: sorted ? route.pool.reserve1 : route.pool.reserve0,
+                };
+                function getTotalToken(t) {
+                    let amount = t.total / 10n ** BigInt(t.decimals);
+                    return _bigint_1.$bigint.multWithFloat(amount, t.price);
+                }
+                return getTotalToken(t1) + getTotalToken(t2);
+            })
+        };
+    }
+}
+exports.TokenPriceService = TokenPriceService;
+class TokenPriceServiceCacheable {
+    constructor(service) {
+        this.service = service;
+        this.cache = new Map();
+        this.INTERVAL = 5 * 60 * 1000;
+    }
+    async getPrice(mix, opts) {
+        let key = typeof mix === 'string'
+            ? mix
+            : mix.address;
+        let byBlock = null;
+        let byDate = null;
+        if (opts?.block != null) {
+            byBlock = opts.block;
+            key += '_' + (byBlock - byBlock % 20) + '';
+        }
+        else {
+            let d = opts.date ?? new Date;
+            byDate = new Date(d);
+            byDate.setMilliseconds(0);
+            byDate.setSeconds(0);
+            let minutes = byDate.getMinutes();
+            minutes -= minutes % 5;
+            byDate.setMinutes(minutes);
+            key += '_' + byDate.toISOString();
+        }
+        if (this.cache.has(key)) {
+            return this.cache.get(key);
+        }
+        let promise = this.service.getPrice(mix, {
+            ...(opts ?? {}),
+            date: byDate,
+            block: byBlock
+        });
+        this.cache.set(key, promise);
+        return promise;
+    }
+}
+exports.TokenPriceServiceCacheable = TokenPriceServiceCacheable;
+var TokenPrice;
+(function (TokenPrice) {
+    async function swapRouted(fromToken, fromAmount, route, tokenService) {
+        let $step;
+        let $fromToken = fromToken;
+        let $fromAmount = fromAmount;
+        let $route = [];
+        for (let i = 0; i < route.length; i++) {
+            $step = await calcSwap($fromToken, $fromAmount, route[i], tokenService);
+            $fromAmount = $step.toAmount;
+            $fromToken = $step.to;
+            $route.push($step);
+        }
+        calcUsdFromRoute($route);
+        let $stepFirst = $route[0];
+        //console.log('LAST STEP for ', fromToken.symbol, $step);
+        return {
+            outToken: $step.to,
+            outAmount: $step.toAmount,
+            outUsd: $step.toUsd,
+            outUsdPrice: $step.toPrice,
+            inToken: $stepFirst.from,
+            inAmount: $stepFirst.fromAmount,
+            inUsd: $stepFirst.fromUsd,
+            inUsdPrice: $stepFirst.fromPrice,
+            route: $route,
+        };
+    }
+    TokenPrice.swapRouted = swapRouted;
+    function calcUsdFromRoute(route) {
+        let knownUsd = route.find(x => x.fromUsd != null || x.toUsd != null);
+        if (knownUsd == null) {
+            return;
+        }
+        let knownUsdI = route.indexOf(knownUsd);
+        for (let i = knownUsdI - 1; i > -1; i--) {
+            let knownPrice = route[i + 1];
+            let prev = route[i];
+            prev.toUsd = knownPrice.fromUsd;
+            prev.toPrice = TokenUtils_1.TokenUtils.calcPrice(prev.toAmount, prev.to, prev.toUsd);
+            prev.fromUsd = prev.toUsd;
+            prev.fromPrice = TokenUtils_1.TokenUtils.calcPrice(prev.fromAmount, prev.from, prev.fromUsd);
+        }
+        for (let i = knownUsdI + 1; i < route.length; i++) {
+            let knownPrice = route[i - 1];
+            let next = route[i];
+            next.fromUsd = knownPrice.toUsd;
+            next.fromPrice = TokenUtils_1.TokenUtils.calcPrice(next.fromAmount, next.from, next.fromUsd);
+            next.toUsd = next.fromUsd;
+            next.toPrice = TokenUtils_1.TokenUtils.calcPrice(next.toAmount, next.to, next.toUsd);
+        }
+    }
+    async function calcPrices(swapped) {
+    }
+    TokenPrice.calcPrices = calcPrices;
+    async function calcSwap(fromToken, fromAmount, lp, tokenService) {
+        let fromTokenAddress = lp.from.address;
+        let toTokenAddress = lp.to.address;
+        if (_address_1.$address.eq(fromTokenAddress, fromToken.address) === false) {
+            throw new Error(`TP: Invalid from token addres ${fromTokenAddress} != ${fromToken.address}`);
+        }
+        let [fromI, toI] = BigInt(fromToken.address) < BigInt(toTokenAddress) ? [0, 1] : [1, 0];
+        let toToken = lp.to;
+        let reserveFrom = lp.reserves[`_reserve${fromI}`];
+        let reserveTo = lp.reserves[`_reserve${toI}`];
+        let k = reserveFrom * reserveTo;
+        let reserveFromAfter = reserveFrom + fromAmount;
+        let reserveToAfter = k / reserveFromAfter;
+        let amountActual = reserveTo - reserveToAfter;
+        let fromUsd = TokenUtils_1.TokenUtils.calcUsdIfStable(fromAmount, fromToken);
+        let toUsd = TokenUtils_1.TokenUtils.calcUsdIfStable(amountActual, toToken);
+        let fromPrice = TokenUtils_1.TokenUtils.calcPrice(fromAmount, fromToken, fromUsd ?? toUsd);
+        let toPrice = TokenUtils_1.TokenUtils.calcPrice(amountActual, toToken, toUsd ?? fromUsd);
+        //console.log('FromPice', fromPrice, fromAmount, fromToken, fromUsd, toUsd);
+        _logger_1.$logger.log(`Swap: ${fromToken.symbol}(${fromAmount})[${fromUsd}$] > ${toToken.symbol} (${amountActual})[${toUsd}$]; Price ${fromToken.symbol}: ${fromPrice}`);
+        return {
+            from: lp.from,
+            fromAmount: fromAmount,
+            fromUsd: fromUsd ?? toUsd,
+            fromPrice,
+            to: lp.to,
+            toAmount: amountActual,
+            toUsd: toUsd ?? fromUsd,
+            toPrice,
+            usd: 0,
+            date: new Date(Number(lp.reserves._blockTimestampLast * 1000)),
+            pool: {
+                address: lp.address,
+                reserve0: lp.reserves._reserve0,
+                reserve1: lp.reserves._reserve1,
+            }
+        };
+    }
+    TokenPrice.calcSwap = calcSwap;
+})(TokenPrice || (TokenPrice = {}));

package/dist/src/tokens/TokenPriceServiceProvider.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenPriceServiceProvider = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const Etherscan_1 = require("@dequanto/BlockchainExplorer/Etherscan");
+const EthWeb3Client_1 = require("@dequanto/clients/EthWeb3Client");
+const TokenPriceService_1 = require("./TokenPriceService");
+const BscWeb3Client_1 = require("@dequanto/clients/BscWeb3Client");
+const Bscscan_1 = require("@dequanto/BlockchainExplorer/Bscscan");
+var TokenPriceServiceProvider;
+(function (TokenPriceServiceProvider) {
+    function create(platform, client, explorer) {
+        if (platform === 'eth') {
+            return a_di_1.default.resolve(TokenPriceService_1.TokenPriceService, client ?? a_di_1.default.resolve(EthWeb3Client_1.EthWeb3Client), explorer ?? a_di_1.default.resolve(Etherscan_1.Etherscan));
+        }
+        if (platform === 'bsc') {
+            return a_di_1.default.resolve(TokenPriceService_1.TokenPriceService, client ?? a_di_1.default.resolve(BscWeb3Client_1.BscWeb3Client), explorer ?? a_di_1.default.resolve(Bscscan_1.Bscscan));
+        }
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+    TokenPriceServiceProvider.create = create;
+    /** To boot performance use cached prices within 5 minutes interval */
+    function createTimeRanged(platform, client, explorer) {
+        let service = TokenPriceServiceProvider.create(platform, client, explorer);
+        return new TokenPriceService_1.TokenPriceServiceCacheable(service);
+    }
+    TokenPriceServiceProvider.createTimeRanged = createTimeRanged;
+})(TokenPriceServiceProvider = exports.TokenPriceServiceProvider || (exports.TokenPriceServiceProvider = {}));

package/dist/src/tokens/TokenProviders/ATokenProvider.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATokenProvider = void 0;
+const _address_1 = require("@dequanto/utils/$address");
+class ATokenProvider {
+    async getByAddress(platform, address) {
+        let tokens = await this.getTokens();
+        let global = tokens.find(x => x.platforms?.some(y => y.platform === platform && _address_1.$address.eq(y.address, address)));
+        if (global == null) {
+            return null;
+        }
+        let p = global.platforms.find(x => x.platform === platform);
+        return {
+            symbol: global.symbol,
+            name: global.name,
+            platform: platform,
+            address: p.address,
+            decimals: p.decimals,
+        };
+    }
+    async getBySymbol(platform, symbol) {
+        let tokens = await this.getTokens();
+        symbol = symbol.toLowerCase();
+        let global = tokens.find(x => x.symbol.toLowerCase() === symbol && x.platforms?.some(y => y.platform === platform));
+        if (global == null) {
+            return null;
+        }
+        let p = global.platforms.find(x => x.platform === platform);
+        return {
+            symbol: global.symbol,
+            name: global.name,
+            platform: platform,
+            address: p.address,
+            decimals: p.decimals,
+        };
+    }
+}
+exports.ATokenProvider = ATokenProvider;