dequanto 0.0.1

package/src/tokens/TokenPriceService.ts

@@ -0,0 +1,276 @@
+import di from 'a-di';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { IToken } from '@dequanto/models/IToken';
+import { AmmV2ExchangeBase } from './TokenExchanges/AmmV2ExchangeBase';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TokenUtils } from './utils/TokenUtils';
+import { TokensService } from './TokensService';
+import { $address } from '@dequanto/utils/$address';
+import { LoggerService } from '@dequanto/loggers/LoggerService';
+import { TResultAsync } from '@dequanto/models/TResult';
+import { AmmPairV2Service, ISwapped, ISwapPool, ISwapRouted } from './TokenExchanges/AmmBase/V2/AmmPairV2Service';
+import { AmmPriceV2Oracle } from './TokenOracles/AmmPriceV2Oracle';
+import { TokenPriceStore } from './TokenOracles/TokenPriceStore';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $logger } from '@dequanto/utils/$logger';
+
+
+
+interface ITokenPriceOptions {
+    /** default: 1 */
+    amount?: number
+
+    amountWei?: bigint
+
+    date?: Date
+    block?: number
+    route?: string[]
+
+    pairs?: any[]
+}
+interface ITokenPrice {
+    error?: Error
+    price?: number
+    pools?: any[]
+}
+
+export class TokenPriceService {
+
+    private tokens = di.resolve(TokensService, this.client.platform, this.explorer)
+    private oracle = di.resolve(
+        AmmPriceV2Oracle
+        , this.client
+        , this.explorer
+    );
+
+    constructor(private client: Web3Client, private explorer: IBlockChainExplorer) {
+
+    }
+
+    async getPrice (symbol: string, opts?: ITokenPriceOptions): Promise<ITokenPrice>
+    async getPrice (address: TAddress, opts?: ITokenPriceOptions): Promise<ITokenPrice>
+    async getPrice (token: IToken, opts?: ITokenPriceOptions): Promise<ITokenPrice>
+    async getPrice (mix: IToken | TAddress | string, opts?: ITokenPriceOptions): Promise<ITokenPrice> {
+
+        let token: IToken;
+
+        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: { price: number, total: bigint, decimals: number }): bigint {
+                    let amount = t.total / 10n** BigInt(t.decimals);
+                    return $bigint.multWithFloat(amount, t.price);
+                }
+
+                return getTotalToken(t1) + getTotalToken(t2);
+            })
+        };
+    }
+}
+
+
+export class TokenPriceServiceCacheable {
+
+    private cache = new Map<string, ReturnType<TokenPriceService['getPrice']>>()
+    private INTERVAL = 5 * 60 * 1000;
+
+    constructor (private service: TokenPriceService) {
+
+    }
+
+
+    async getPrice (symbol: string, opts?: ITokenPriceOptions): TResultAsync<ISwapRouted>
+    async getPrice (address: TAddress, opts?: ITokenPriceOptions): TResultAsync<ISwapRouted>
+    async getPrice (token: IToken, opts?: ITokenPriceOptions): TResultAsync<ISwapRouted>
+    async getPrice (mix: IToken | TAddress | string, opts?: ITokenPriceOptions): TResultAsync<ISwapRouted> {
+
+        let key: string = typeof mix === 'string'
+            ? mix
+            : mix.address;
+
+        let byBlock: number = null;
+        let byDate: Date = 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(<any> mix, {
+            ...(opts ?? {}),
+            date: byDate,
+            block: byBlock
+        });
+        this.cache.set(key, promise);
+        return promise;
+    }
+}
+
+
+namespace TokenPrice {
+
+
+    export async function swapRouted (fromToken: IToken, fromAmount: bigint, route: ISwapPool[], tokenService: TokensService): Promise<ISwapRouted> {
+        let $step: ISwapped;
+        let $fromToken = fromToken;
+        let $fromAmount = fromAmount;
+        let $route = [] as ISwapped[];
+
+        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,
+        };
+    }
+
+    function calcUsdFromRoute (route: ISwapped[]) {
+        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.calcPrice(prev.toAmount, prev.to, prev.toUsd);
+            prev.fromUsd = prev.toUsd;
+            prev.fromPrice = 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.calcPrice(next.fromAmount, next.from, next.fromUsd);
+            next.toUsd = next.fromUsd;
+            next.toPrice = TokenUtils.calcPrice(next.toAmount, next.to, next.toUsd);
+        }
+    }
+
+    export async function calcPrices (swapped: ISwapped) {
+
+    }
+
+    export async function calcSwap (fromToken: IToken, fromAmount: bigint, lp: ISwapPool, tokenService: TokensService) {
+
+        let fromTokenAddress: TAddress = lp.from.address;
+        let toTokenAddress: TAddress = lp.to.address;
+
+        if ($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: bigint = lp.reserves[`_reserve${fromI}`];
+        let reserveTo: bigint = lp.reserves[`_reserve${toI}`];
+
+        let k = reserveFrom * reserveTo;
+        let reserveFromAfter = reserveFrom + fromAmount;
+        let reserveToAfter = k / reserveFromAfter;
+        let amountActual = reserveTo - reserveToAfter;
+        let fromUsd = TokenUtils.calcUsdIfStable(fromAmount, fromToken);
+        let toUsd = TokenUtils.calcUsdIfStable(amountActual, toToken);
+
+        let fromPrice = TokenUtils.calcPrice(fromAmount, fromToken, fromUsd ?? toUsd);
+        let toPrice = TokenUtils.calcPrice(amountActual, toToken, toUsd ?? fromUsd);
+
+        //console.log('FromPice', fromPrice, fromAmount, fromToken, fromUsd, toUsd);
+        $logger.log(`Swap: ${fromToken.symbol}(${fromAmount})[${fromUsd}$] > ${toToken.symbol} (${amountActual})[${toUsd}$]; Price ${fromToken.symbol}: ${fromPrice}`);
+
+        return <ISwapped> {
+            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,
+            }
+        };
+    }
+}

package/src/tokens/TokenPriceServiceProvider.ts

@@ -0,0 +1,36 @@
+import di from 'a-di';
+import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan';
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TokenPriceService, TokenPriceServiceCacheable } from './TokenPriceService';
+import { BscWeb3Client } from '@dequanto/clients/BscWeb3Client';
+import { Bscscan } from '@dequanto/BlockchainExplorer/Bscscan';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+
+export namespace TokenPriceServiceProvider {
+
+    export function create (platform: TPlatform, client?: Web3Client, explorer?: IBlockChainExplorer) {
+        if (platform === 'eth') {
+            return di.resolve(
+                TokenPriceService,
+                client ?? di.resolve(EthWeb3Client),
+                explorer ?? di.resolve(Etherscan),
+            );
+        }
+        if (platform === 'bsc') {
+            return di.resolve(
+                TokenPriceService,
+                client ?? di.resolve(BscWeb3Client),
+                explorer ?? di.resolve(Bscscan),
+            );
+        }
+        throw new Error(`Unsupported platform: ${platform}`);
+    }
+
+    /** To boot performance use cached prices within 5 minutes interval */
+    export function createTimeRanged (platform: TPlatform, client?: Web3Client, explorer?: IBlockChainExplorer) {
+        let service = TokenPriceServiceProvider.create(platform, client, explorer);
+        return new TokenPriceServiceCacheable(service);
+    }
+}

package/src/tokens/TokenProviders/ATokenProvider.ts

@@ -0,0 +1,42 @@
+import { $address } from '@dequanto/utils/$address';
+import { IToken } from '@dequanto/models/IToken';
+import { ITokenGlob } from '@dequanto/models/ITokenGlob';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+
+export abstract class ATokenProvider {
+    abstract getTokens (): Promise<ITokenGlob[]>
+
+    async getByAddress (platform: TPlatform, address: TAddress): Promise<IToken> {
+        let tokens = await this.getTokens();
+        let global = tokens.find(x => x.platforms?.some(y => y.platform === platform && $address.eq(y.address, address)));
+        if (global == null) {
+            return null;
+        }
+        let p = global.platforms.find(x => x.platform === platform);
+        return <IToken> {
+            symbol: global.symbol,
+            name: global.name,
+            platform: platform,
+            address: p.address,
+            decimals: p.decimals,
+        };
+    }
+    async getBySymbol (platform: TPlatform, symbol: string) {
+        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 <IToken> {
+            symbol: global.symbol,
+            name: global.name,
+            platform: platform,
+            address: p.address,
+            decimals: p.decimals,
+        };
+    }
+}

package/src/tokens/TokenProviders/ITokenProvider.ts

@@ -0,0 +1,9 @@
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+
+export interface ITokenProvider {
+    getByAddress (platform: TPlatform, address: TAddress)
+    getBySymbol  (platform: TPlatform, symbol: string)
+
+    redownloadTokens(): Promise<any>
+}

package/src/tokens/TokenProviders/TPChain.ts

@@ -0,0 +1,41 @@
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { ITokenProvider } from './ITokenProvider';
+
+export class TPChain implements ITokenProvider {
+
+    constructor (public platform: TPlatform, public explorer?: IBlockChainExplorer) {
+
+    }
+
+    async getByAddress(platform: TPlatform, address: TAddress) {
+        if (this.platform !== platform) {
+            return null;
+        }
+
+        try {
+            let source = await this.explorer?.getContractSource(address);
+            return <Partial<IToken>> {
+                address: address,
+                symbol: source
+                    .ContractName
+                    ?.replace(/bep20/i, ''),
+            };
+
+        } catch (error) {
+            // just ignore if not resolved
+            return null;
+        }
+    }
+    getBySymbol(platform: TPlatform, symbol: string) {
+        // Does not support by name
+        return null;
+    }
+
+    async redownloadTokens(): Promise<any> {
+        return [];
+    }
+
+}

package/src/tokens/TokenProviders/TPCoinmarketcap.ts

@@ -0,0 +1,82 @@
+import axios from 'axios'
+import { class_Uri } from 'atma-utils';
+import { JsonArrayStore } from '@dequanto/json/JsonArrayStore';
+import { $config } from '@dequanto/utils/$config';
+
+import { ITokenGlob } from '@dequanto/models/ITokenGlob';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { ATokenProvider } from './ATokenProvider';
+import { ITokenProvider } from './ITokenProvider';
+
+
+const coinmarketcap = $config.get('coinmarketcap') as {
+    key: string
+    cache?: string
+};
+
+const tokensStore = new JsonArrayStore<ITokenGlob>({
+    path: class_Uri.combine(coinmarketcap?.cache ?? './data/tokens/coinmarketcap/', 'tokens.json'),
+    key: (x) => x.symbol
+});
+
+const HOST = `https://pro-api.coinmarketcap.com/`
+
+export class TPCoinmarketcap extends ATokenProvider implements ITokenProvider {
+
+    getTokens(): Promise<ITokenGlob[]> {
+        return tokensStore.getAll();
+    }
+
+    async redownloadTokens() {
+        if (coinmarketcap == null) {
+            console.warn(`No ApiKey for coinmarketcap found. Skipping this token provider`);
+            return [];
+        }
+        let url = class_Uri.combine(HOST, `/v1/cryptocurrency/map?CMC_PRO_API_KEY=${coinmarketcap.key}`);
+        let resp = await axios.get(url);
+        let tokens = resp.data.data as {
+            "name": string
+            "symbol": string
+            "platform": {
+                "name": "Binance Smart Chain" | "Ethereum" | "Polygon" | "xDai"
+                "token_address": TAddress
+            }
+        }[];
+
+        let arr = tokens.map(token => {
+            if (token.platform == null) {
+                return null;
+            }
+            let platform: TPlatform;
+            switch (token.platform.name) {
+                case "Binance Smart Chain":
+                    platform = "bsc";
+                    break;
+                case "Ethereum":
+                    platform = "eth";
+                    break;
+                case "Polygon":
+                    platform = "polygon";
+                    break;
+                case "xDai":
+                    platform = "xdai";
+                    break;
+                default:
+                    return null;
+            }
+
+            return <ITokenGlob>{
+                symbol: token.symbol,
+                name: token.name,
+                platforms: [{
+                    platform,
+                    address: token.platform.token_address
+                }]
+            };
+        }).filter(Boolean);
+
+
+        await tokensStore.saveAll(arr);
+    }
+}

package/src/tokens/TokenProviders/TPOneInch.ts

@@ -0,0 +1,71 @@
+import axios from 'axios'
+import { JsonArrayStore } from '@dequanto/json/JsonArrayStore';
+import { IToken } from '@dequanto/models/IToken';
+import { ITokenGlob } from '@dequanto/models/ITokenGlob';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TokenUtils } from '../utils/TokenUtils';
+import { ITokenProvider } from './ITokenProvider';
+import { ATokenProvider } from './ATokenProvider';
+import { $path } from '@dequanto/utils/$path';
+
+
+
+export class TPOneInch extends ATokenProvider implements ITokenProvider {
+
+    store = new JsonArrayStore<ITokenGlob> ({
+        path: $path.resolve('/data/tokens/1inch.json'),
+        key: x => x.symbol,
+        format: true,
+    });
+
+    getTokens(): Promise<ITokenGlob[]> {
+        return this.store.getAll();
+    }
+
+    async redownloadTokens () {
+
+        let tokensByPlatform = await Promise.all([
+            this.downloadForPlatform('eth'),
+            this.downloadForPlatform('bsc'),
+            this.downloadForPlatform('polygon'),
+        ]);
+
+        let globals = TokenUtils.merge(...tokensByPlatform);
+        await this.store.saveAll(globals);
+        return globals;
+    }
+
+    private async downloadForPlatform(platform: TPlatform) {
+        let url: string;
+        switch (platform) {
+            case 'eth':
+                url = `https://api.1inch.exchange/v3.0/1/tokens`;
+                break;
+            case 'bsc':
+                url = `https://api.1inch.exchange/v3.0/56/tokens`;
+                break;
+            case 'polygon':
+                url = `https://api.1inch.exchange/v3.0/137/tokens`;
+                break;
+            default:
+                throw new Error(`Invalid Platform ${platform}`)
+        }
+
+        let resp = await axios.get(url);
+        let hash = resp.data.tokens;
+
+        let arr = Object.keys(hash).map(key => {
+            let t = hash[key];
+            return <IToken> {
+                symbol: t.symbol,
+                name: t.name,
+                decimals: t.decimals,
+                logo: t.logoURI,
+                platform: platform,
+                address: t.address,
+            }
+        });
+        return arr;
+    }
+
+}

package/src/tokens/TokenProviders/TPSushiswap.ts

@@ -0,0 +1,96 @@
+import axios, { AxiosResponse } from 'axios';
+import { $address } from '@dequanto/utils/$address';
+import { JsonArrayStore } from '@dequanto/json/JsonArrayStore';
+import { IToken } from '@dequanto/models/IToken';
+import { ITokenGlob } from '@dequanto/models/ITokenGlob';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TokenUtils } from '../utils/TokenUtils';
+import { ITokenProvider } from './ITokenProvider';
+import { ATokenProvider } from './ATokenProvider';
+import { $path } from '@dequanto/utils/$path';
+
+
+export class TPSushiswap extends ATokenProvider implements ITokenProvider  {
+    store = new JsonArrayStore<ITokenGlob> ({
+        path: $path.resolve('/data/tokens/sushi.json'),
+        key: x => x.symbol,
+        format: true,
+    });
+
+    getTokens(): Promise<ITokenGlob[]> {
+        return this.store.getAll();
+    }
+
+    /** Finds remote  */
+    async find (address: string) {
+        throw new Error('Not implemented')
+    }
+
+    async redownloadTokens () {
+        let tokensByPlatform = await Promise.all([
+            this.downloadForPlatform('eth'),
+            this.downloadForPlatform('polygon'),
+            this.downloadForPlatform('xdai'),
+        ]);
+
+        let globals = TokenUtils.merge(...tokensByPlatform);
+        await this.store.saveAll(globals);
+        return globals;
+    }
+
+    private async downloadForPlatform(platform: TPlatform) {
+        let url: string;
+        let mapper: (resp: AxiosResponse) => IToken[];
+
+        function mapperApi (resp: AxiosResponse): IToken[] {
+            let arr = resp.data[1];
+            return arr.map(t => {
+                return <IToken> {
+                    symbol: t.Symbol,
+                    name: t.Name,
+                    decimals: t.Decimals,
+                    platform: platform,
+                    address: t.Contract,
+                }
+            })
+        }
+        function mapperGithub (resp: AxiosResponse): IToken[] {
+            let arr = resp.data;
+            return arr.map(t => {
+                return <IToken> {
+                    symbol: t.symbol,
+                    name: t.name,
+                    decimals: t.decimals,
+                    platform: platform,
+                    address: t.address,
+                }
+            })
+        }
+
+        switch (platform) {
+            case 'eth':
+                url = `https://api2.sushipro.io/?action=all_tokens&chainID=1`;
+                mapper = mapperApi;
+                break;
+            case 'bsc':
+                throw new Error(`Bsc is not supported by sushiswap api`);
+                break;
+            case 'polygon':
+                url = `https://api2.sushipro.io/?action=all_tokens&chainID=137`;
+                mapper = mapperApi;
+                break;
+            case 'xdai':
+                url = `https://raw.githubusercontent.com/sushiswap/default-token-list/master/tokens/xdai.json`;
+                mapper = mapperGithub;
+                break;
+            default:
+                throw new Error(`Invalid Platform ${platform}`)
+        }
+
+        let resp = await axios.get<[{}, { Contract, Symbol, Name, Decimals }[]] | {symbol, name, decimals, address } >(url);
+        let tokens = mapper(resp);
+
+        return tokens;
+    }
+}