dequanto 0.0.1

package/src/tokens/TokenExchangeService.ts

@@ -0,0 +1,126 @@
+import di from 'a-di';
+import alot from 'alot';
+import { BlockChainExplorerProvider } from '@dequanto/BlockchainExplorer/BlockChainExplorerProvider';
+import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
+import { IToken } from '@dequanto/models/IToken';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $is } from '@dequanto/utils/$is';
+import { AmmV2ExchangeBase } from './TokenExchanges/AmmV2ExchangeBase';
+import { PancakeswapExchange } from './TokenExchanges/PancakeswapExchange';
+//import { UniswapExchange } from './TokenExchanges/UniswapExchange';
+import { TokensService } from './TokensService';
+import { TokenUtils } from './utils/TokenUtils';
+import { ERC20 } from '@dequanto/contracts/common/ERC20';
+import { UniswapExchange } from './TokenExchanges/UniswapExchange';
+import { SushiswapPolygonExchange } from './TokenExchanges/SushiswapPolygonExchange';
+import { $logger } from '@dequanto/utils/$logger';
+import { $require } from '@dequanto/utils/$require';
+
+export class TokenExchangeService {
+
+    client = Web3ClientFactory.get(this.platform);
+    explorer = BlockChainExplorerProvider.get(this.platform);
+
+    exchange: AmmV2ExchangeBase
+    stables: string[]
+
+    constructor (public platform: TPlatform) {
+        switch (platform) {
+            case 'bsc':
+                this.exchange = di.resolve(PancakeswapExchange, this.client, this.explorer);
+                this.stables = ['BUSD', 'USDT'];
+                break;
+            case 'eth':
+                this.exchange = di.resolve(UniswapExchange, this.client, this.explorer);
+                this.stables = ['USDC', 'USDT', 'DAI'];
+                break;
+            case 'polygon':
+                this.exchange = di.resolve(SushiswapPolygonExchange, this.client, this.explorer);
+                this.stables = ['USDC', 'USDT', 'DAI'];
+                break;
+            default:
+                throw new Error(`Unsupported Platform for exchange yet: ${platform}`);
+        }
+    }
+
+    async calcUSD (from: string | Partial<IToken>, fromAmount: number | bigint, date?: Date): Promise<{
+        from: IToken & { amount },
+        to: IToken & { amount },
+        priceImpact: number
+    }> {
+        let tokensService = di.resolve(TokensService, this.platform, this.explorer);
+        let fromToken = typeof from === 'string'
+            ? await tokensService.getToken(from)
+            : <IToken> from;
+        let $fromAmount = typeof fromAmount === 'bigint'
+            ? fromAmount
+            : $bigint.toWei(fromAmount, fromToken.decimals ?? 18);
+
+        $require.Address(fromToken?.address, `Token 404 ${from}`);
+
+        let converted = TokenUtils.isStable(fromToken.symbol) ? {
+            to: {
+                ...fromToken,
+                amount: fromAmount,
+            },
+            priceImpact: 0
+        } : await alot(this.stables)
+            .mapAsync(async stableSymbol => {
+                let toToken = await tokensService.getToken(stableSymbol);
+                try {
+                    let swapped = await this.exchange.calcSwap(fromToken, toToken, $fromAmount) ?? {
+                        amount: 0n,
+                        priceImpact: 0
+                    };
+                    return {
+                        to: {
+                            ...toToken,
+                            amount: swapped.amount
+                        },
+                        priceImpact: swapped.priceImpact,
+                    };
+                } catch (error) {
+                    $logger.log('CalcStable error', error);
+                    return null;
+                }
+            })
+            .filterAsync(x => x != null)
+            .firstAsync();
+
+        if (converted == null) {
+            throw new Error(`Do not know how to convert ${from} Token`);
+        }
+        return {
+            from: {
+                ...fromToken,
+                amount: $fromAmount,
+            },
+            to: converted.to,
+            priceImpact: converted.priceImpact
+        };
+    }
+
+    async calc (from: string, to: string, fromAmount: bigint): Promise<{
+        from: IToken & { amount },
+        to: IToken & { amount },
+        priceImpact: number
+    }> {
+        let tokensService = di.resolve(TokensService, this.platform, this.explorer);
+        let fromToken = await tokensService.getToken(from);
+        let toToken = await tokensService.getToken(to);
+        let swapped = await this.exchange.calcSwap(fromToken, toToken, fromAmount);
+
+        return {
+            from: {
+                ...fromToken,
+                amount: fromAmount,
+            },
+            to: {
+                ...toToken,
+                amount: swapped.amount,
+            },
+            priceImpact: swapped.priceImpact,
+        };
+    }
+}

package/src/tokens/TokenExchanges/AmmBase/AmmUtilts.ts

@@ -0,0 +1,16 @@
+import { IToken } from '@dequanto/models/IToken';
+
+export namespace AmmUtils {
+    export function toSameBase (a: Pick<IToken, 'decimals'>, b: Pick<IToken, 'decimals'>, aAmount: bigint, bAmount: bigint): [bigint, bigint] {
+        return [aAmount, bAmount];
+
+        let diff = (a.decimals ?? 18) - (b.decimals ?? 18);
+        if (diff === 0) {
+            return [aAmount, bAmount];
+        }
+        let aAmountOut = diff > 0 ? aAmount : (aAmount * 10n ** BigInt(diff * -1));
+        let bAmountOut = diff < 0 ? bAmount : (bAmount * 10n ** BigInt(diff));
+
+        return [aAmountOut, bAmountOut];
+    }
+}

package/src/tokens/TokenExchanges/AmmBase/V2/AmmFactoryV2Contract.ts

@@ -0,0 +1,15 @@
+/**
+ * dequanto
+ * name: AmmFactoryV2ContractBase
+ * platform: bsc
+ * source.abi: 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73
+ * output: ./contracts/gen/amm/
+ */
+
+import { AmmFactoryV2ContractBase } from '@dequanto-contracts/gen/amm/AmmFactoryV2ContractBase';
+
+/* https://docs.pancakeswap.finance/code/smart-contracts/pancakeswap-exchange/factory-v2 */
+
+export class AmmFactoryV2Contract extends AmmFactoryV2ContractBase {
+
+}

package/src/tokens/TokenExchanges/AmmBase/V2/AmmMasterChefV2Contract.ts

@@ -0,0 +1,15 @@
+/**
+ * dequanto
+ * name: AmmMasterChefV2ContractBase
+ * platform: bsc
+ * source.abi: 0x73feaa1eE314F8c655E354234017bE2193C9E24E
+ * output: ./contracts/gen/amm/
+ */
+
+import { AmmMasterChefV2ContractBase } from '@dequanto-contracts/gen/amm/AmmMasterChefV2ContractBase';
+
+/* https://docs.pancakeswap.finance/code/smart-contracts/main-staking-masterchef-contract */
+
+export class AmmMasterChefV2Contract extends AmmMasterChefV2ContractBase {
+
+}

package/src/tokens/TokenExchanges/AmmBase/V2/AmmPairV2Contract.ts

@@ -0,0 +1,17 @@
+/**
+* dequanto
+* name: AmmPairContractV2Base
+* platform: bsc
+* source.abi: 0x7752e1fa9f3a2e860856458517008558deb989e3
+* output: ./contracts/gen/amm/
+*/
+
+import { AmmPairContractV2Base } from '@dequanto-contracts/gen/amm/AmmPairContractV2Base';
+
+
+/* https://pancakeswap.info/token/0x8f0528ce5ef7b51152a59745befdd91d97091d2f */
+/* https://pancakeswap.info/pool/0x7752e1fa9f3a2e860856458517008558deb989e3 */
+
+export class AmmPairV2Contract extends AmmPairContractV2Base {
+
+}

package/src/tokens/TokenExchanges/AmmBase/V2/AmmPairV2Service.ts

@@ -0,0 +1,208 @@
+import di from 'a-di';
+import alot from 'alot';
+import memd from 'memd';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { $address } from '@dequanto/utils/$address';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { AmmV2ExchangeBase } from '@dequanto/tokens/TokenExchanges/AmmV2ExchangeBase';
+import { PancakeswapExchange } from '@dequanto/tokens/TokenExchanges/PancakeswapExchange';
+import { UniswapExchange } from '@dequanto/tokens/TokenExchanges/UniswapExchange';
+import { TokensService } from '@dequanto/tokens/TokensService';
+import { IToken } from '@dequanto/models/IToken';
+import { SushiswapPolygonExchange } from '../../SushiswapPolygonExchange';
+
+
+
+export interface ISwapPoolInfo {
+    address: TAddress
+    token0: TAddress
+    token1: TAddress
+
+    from?: IToken
+    to?: IToken
+};
+export interface ISwapPool extends ISwapPoolInfo {
+    date: Date
+    fromPrice?: number
+    reserves?: {
+        _reserve0: bigint
+        _reserve1: bigint
+        _blockTimestampLast: number
+    }
+}
+
+
+export interface ISwapRouted {
+    outToken: IToken
+    outAmount: bigint
+    outUsd: number
+    outUsdPrice: number
+
+    inToken: IToken
+    inAmount: bigint
+    inUsd: number
+    inUsdPrice: number
+
+    route: ISwapped[]
+}
+
+export interface ISwapped {
+    from: IToken
+    fromAmount: bigint
+    fromUsd?: number
+    fromPrice?: number
+
+    to: IToken
+    toAmount: bigint
+    toUsd?: number
+    toPrice?: number
+
+    usd: number
+    date: Date
+    pool: {
+        address: TAddress
+        reserve0: bigint
+        reserve1: bigint
+    }
+}
+
+
+
+export class AmmPairV2Service {
+    exchange: AmmV2ExchangeBase
+    tokensService = di.resolve(TokensService, this.client.platform, this.explorer);
+
+    targetCoins: string[]
+
+    constructor(public client: Web3Client, public explorer: IBlockChainExplorer) {
+        switch (client.platform) {
+            case 'bsc':
+                this.exchange = di.resolve(PancakeswapExchange, this.client, this.explorer);
+                this.targetCoins = ['BUSD', 'USDT'];
+                break;
+            case 'eth':
+                this.exchange = di.resolve(UniswapExchange, this.client, this.explorer);
+                this.targetCoins = ['USDC', 'USDT', 'DAI'];
+                break;
+            case 'polygon':
+                this.exchange = di.resolve(SushiswapPolygonExchange, this.client, this.explorer);
+                this.targetCoins = ['USDC', 'USDT', 'DAI'];
+                break;
+            default:
+                throw new Error(`Unsupported Platform for exchange yet: ${client.platform}`);
+        }
+    }
+
+    @memd.deco.memoize({
+        perInstance: true,
+        trackRef: true,
+        persistance: new memd.FsTransport({ path:  `./cache/pools.json` })
+    })
+    async resolveBestStableRoute (platform: TPlatform, address: TAddress): Promise<ISwapPoolInfo[]> {
+        let pool = await alot(this.targetCoins)
+            .mapAsync(async symbol => {
+                return this.getPoolInfo(address, symbol);
+            })
+            .filterAsync(x => x != null)
+            .sortByAsync(({reserveTo}) => reserveTo, 'desc')
+            .firstAsync();
+
+
+        if (pool == null || pool.reserveTo < (50_000n * 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: TAddress, symbols: string[]): Promise<ISwapPoolInfo[]> {
+
+        let tokens = await alot(symbols)
+            .mapAsync(x => this.tokensService.getTokenOrDefault(x))
+            .toArrayAsync();
+
+        let prev = address;
+        let out = [] as ISwapPoolInfo[];
+        for (let token of tokens) {
+            let poolInfo = await this.getPoolInfo(prev, token.address);
+            out.push(poolInfo.pair);
+            prev = token.address;
+        }
+        return out;
+    }
+
+    private async getPoolInfo (fromAddress: TAddress, symbol: string): Promise<{ pair: ISwapPoolInfo, reserveTo: number }> {
+        let toToken = await this.tokensService.getTokenOrDefault(symbol);
+        if (toToken == null) {
+            return null;
+        }
+
+        let lpAddress = await this.getPair(fromAddress, toToken.address);
+        if ($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: bigint = lpReserves[`_reserve${fromI}`];
+        let reserveTo: bigint = 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)),
+        };
+    }
+
+    @memd.deco.memoize()
+    private async getPair (from: TAddress, to: TAddress) {
+        return await this.exchange.factoryContract.getPair(from, to);
+    }
+}
+
+
+namespace PairUtil {
+    export function createPairInfo (fromToken: IToken, toToken: IToken, lpAddress: TAddress): ISwapPoolInfo {
+        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,
+        };
+    }
+}

package/src/tokens/TokenExchanges/AmmBase/V2/AmmRouterV2Contract.ts

@@ -0,0 +1,15 @@
+/**
+* dequanto
+* name: AmmRouterV2ContractBase
+* platform: bsc
+* source.abi: 0x10ED43C718714eb63d5aA57B78B54704E256024E
+* output: ./contracts/gen/amm/
+*/
+
+import { AmmRouterV2ContractBase } from '@dequanto-contracts/gen/amm/AmmRouterV2ContractBase';
+
+/* https://docs.pancakeswap.finance/code/smart-contracts/pancakeswap-exchange/router-v2 */
+
+export class AmmRouterV2Contract extends AmmRouterV2ContractBase {
+
+}

package/src/tokens/TokenExchanges/AmmBase/V2/AmmVaultV2Contract.ts

@@ -0,0 +1,15 @@
+/**
+* dequanto
+* name: AmmVaultV2ContractBase
+* platform: bsc
+* source.abi: 0xa80240Eb5d7E05d3F250cF000eEc0891d00b51CC
+* output: ./contracts/gen/amm/
+*/
+
+import { AmmVaultV2ContractBase } from '@dequanto-contracts/gen/amm/AmmVaultV2ContractBase';
+
+/* https://docs.pancakeswap.finance/code/smart-contracts/cakevault */
+
+export class AmmVaultV2Contract extends AmmVaultV2ContractBase {
+
+}

package/src/tokens/TokenExchanges/AmmBase/V3/AmmPairV3Contract.ts

@@ -0,0 +1,24 @@
+/**
+* dequanto
+* name: AmmPairContractV3Base
+* platform: eth
+* source.abi: 0x8f8ef111b67c04eb1641f5ff19ee54cda062f163
+* output: ./contracts/gen/amm/
+*/
+
+import { AmmPairContractV3Base } from '@dequanto-contracts/gen/amm/AmmPairContractV3Base';
+import { $bigint } from '@dequanto/utils/$bigint';
+
+
+/* https://info.uniswap.org/#/pools/0x8f8ef111b67c04eb1641f5ff19ee54cda062f163 */
+
+export class AmmPairV3Contract extends AmmPairContractV3Base {
+
+    async getPrice0 () {
+        let slot = await this.slot0();
+        let precision = 10n**10n;
+
+        let priceBigInt = (slot.sqrtPriceX96 * slot.sqrtPriceX96 * BigInt(precision)) >> (2n*96n);
+        return $bigint.divToFloat(priceBigInt, precision, precision);
+    }
+}