dequanto 0.0.1

package/src/tokens/TokensService.ts

@@ -0,0 +1,252 @@
+import di from 'a-di';
+import alot from 'alot';
+import memd from 'memd';
+import { TAddress } from '@dequanto/models/TAddress';
+import { IBlockChainExplorer } from '@dequanto/BlockchainExplorer/IBlockChainExplorer';
+import { TPSushiswap } from './TokenProviders/TPSushiswap';
+import { TPUniswap } from './TokenProviders/TPUniswap';
+import { TPCoinmarketcap } from './TokenProviders/TPCoinmarketcap';
+import { TPOneInch } from './TokenProviders/TPOneInch';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TPChain } from './TokenProviders/TPChain';
+import { IToken } from '@dequanto/models/IToken';
+import { ITokenProvider } from './TokenProviders/ITokenProvider';
+import { ERC20 } from '@dequanto/contracts/common/ERC20';
+import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
+import { BlockChainExplorerProvider } from '@dequanto/BlockchainExplorer/BlockChainExplorerProvider';
+import { $address } from '@dequanto/utils/$address';
+import { ArbTokenProvider } from '@dequanto/chains/arbitrum/ArbTokenProvider';
+import { $require } from '@dequanto/utils/$require';
+
+
+export class TokensService {
+
+    private providers = [
+        new TPOneInch(),
+        new TPSushiswap(),
+        // @TODO uniswap thegraph api doesn't work any more
+        // new TPUniswap(),
+        new TPCoinmarketcap(),
+        new ArbTokenProvider(),
+        new TPChain(this.platform, this.explorer),
+    ] as ITokenProvider[];
+
+
+    constructor(private platform: TPlatform, private explorer?: IBlockChainExplorer) {
+
+    }
+
+    async getTokenOrDefault (address: TAddress, chainLookup: boolean = true): Promise<IToken> {
+        return await this.getToken(address, chainLookup) ?? this.default(address);
+    }
+
+
+    async getToken (symbol: string, chainLookup?: boolean): Promise<IToken>
+    async getToken (address: TAddress, chainLookup?: boolean): Promise<IToken>
+
+    @memd.deco.memoize({ perInstance: true })
+    async getToken (mix: string, chainLookup: boolean = true): Promise<IToken> {
+        let [ token, provider ] = mix.startsWith('0x')
+            ? await this.getTokenByAddress(mix, chainLookup)
+            : await this.getTokenBySymbol(mix, chainLookup);
+
+        return token
+    }
+
+    @memd.deco.memoize({ perInstance: true })
+    async getKnownToken (mix: string): Promise<IToken> {
+        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 (token: IToken): boolean
+    isNative (address: TAddress): boolean
+    isNative (symbol: string): boolean
+    isNative (mix): boolean {
+        $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: TPlatform): IToken {
+        return NativeTokens.getNative(platform);
+    }
+
+    /** Download tokens with various exchange/swap providers and merge them into one collection. */
+    async redownload () {
+        return await alot(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: TAddress, chainLookup: boolean = true): Promise<[IToken, ITokenProvider]> {
+        let [ token, provider ] = await alot(this.providers)
+            .mapAsync(async provider => {
+                if (provider instanceof 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: string, chainLookup: boolean = true): Promise<[IToken, ITokenProvider]> {
+        let [ token, provider ] = await alot(this.providers)
+            .mapAsync(async provider => {
+                if (provider instanceof 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 ];
+    }
+
+    private default (address: TAddress) {
+        return {
+            platform: this.platform,
+            symbol: address,
+            name: address,
+            address: address,
+            decimals: 18,
+        };
+    }
+
+    @memd.deco.memoize()
+    static async erc20 (
+        token: string | IToken,
+        platform: TPlatform
+    ): Promise<ERC20> {
+        let client = Web3ClientFactory.get(platform);
+        let explorer = BlockChainExplorerProvider.get(platform);
+
+        if (typeof token === 'string') {
+            let service = di.resolve(TokensService, platform, explorer);
+            token = await service.getToken(token);
+        }
+        if (token == null) {
+            throw new Error(`Token not found: ${arguments[0]}`);
+        }
+        return new ERC20(token.address, client, explorer);
+    }
+
+    @memd.deco.memoize()
+    async erc20 (token: string | IToken): Promise<ERC20> {
+        let client = Web3ClientFactory.get(this.platform);
+        let explorer = BlockChainExplorerProvider.get(this.platform);
+
+        let t = typeof token === 'string'
+            ? await this.getToken(token)
+            : token;
+        if (t == null) {
+            if (typeof token === 'string' && $address.isValid(token)) {
+                t = {
+                    address: token,
+                    decimals: 18,
+                    platform: this.platform
+                };
+            }
+            throw new Error(`Token not found: ${arguments[0]}`);
+        }
+        return new ERC20(t.address, client, explorer);
+    }
+}
+
+namespace NativeTokens {
+    const T1 = `0x0000000000000000000000000000000000000000`;
+    const T2 = `0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee`;
+    const tokens = {
+        'ETH': <Partial<IToken>>{
+            name: 'Ethereum Native Token',
+            symbol: 'ETH',
+            decimals: 18,
+            icon: null,
+            platform: 'eth',
+            address: T2,
+        },
+        'BNB': <Partial<IToken>>{
+            name: 'BSC Native Token',
+            symbol: 'BNB',
+            decimals: 18,
+            icon: null,
+            platform: 'bsc',
+            address: T1,
+        },
+        'MATIC': <Partial<IToken>>{
+            name: 'Polygon Native Token',
+            symbol: 'MATIC',
+            decimals: 18,
+            icon: null,
+            platform: 'polygon',
+            address: T2,
+        },
+        'XDAI': <Partial<IToken>>{
+            name: 'xDai Native Token',
+            symbol: 'XDAI',
+            decimals: 18,
+            icon: null,
+            platform: 'xdai',
+            address: T1,
+        },
+    };
+    const PLATFORMS = {
+        'eth': 'ETH',
+        'bsc': 'BNB',
+        'polygon': 'MATIC',
+        'xdai': 'xDAI',
+    };
+
+    export function isNativeBySymbol (platform: TPlatform, symbol: string) {
+        if (symbol == null) {
+            return false;
+        }
+        symbol = symbol.toUpperCase();
+        return symbol in tokens;
+    }
+
+    export function isNativeByAddress (address: TAddress) {
+        const check = address.toLowerCase();
+        return $address.eq(T1, check) || $address.eq(T2, check);
+    }
+
+    export function toNativeByAddress (platform: TPlatform, address: TAddress) {
+        const token = tokens[platform?.toUpperCase()];
+        return {
+            ...token,
+            address: address
+        };
+    }
+    export function getNative (platform: TPlatform): IToken {
+        let symbol = PLATFORMS[platform]
+        if (symbol == null) {
+            throw new Error(`${platform} platform is not support`);
+        }
+        return tokens[symbol.toUpperCase()];
+    }
+}
+
+

package/src/tokens/TokensServiceBsc.ts

@@ -0,0 +1,17 @@
+import di from 'a-di';
+import { TokensService } from './TokensService';
+import { Bscscan } from '@dequanto/BlockchainExplorer/Bscscan';
+import { ERC20 } from '@dequanto/contracts/common/ERC20';
+import { TAddress } from '@dequanto/models/TAddress';
+
+export class TokensServiceBsc extends TokensService {
+    constructor () {
+        super('bsc', di.resolve(Bscscan))
+    }
+
+    static async erc20 (address: TAddress): Promise<ERC20>
+    static async erc20 (symbol: string): Promise<ERC20>
+    static async erc20 (mix: string): Promise<ERC20> {
+        return TokensService.erc20(mix, 'bsc');
+    }
+}

package/src/tokens/TokensServiceEth.ts

@@ -0,0 +1,9 @@
+import di from 'a-di';
+import { TokensService } from './TokensService';
+import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan';
+
+export class TokensServiceEth extends TokensService {
+    constructor () {
+        super('eth', di.resolve(Etherscan))
+    }
+}

package/src/tokens/TokensServiceFactory.ts

@@ -0,0 +1,24 @@
+import di from 'a-di';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TokensServiceBsc } from './TokensServiceBsc';
+import { TokensServiceEth } from './TokensServiceEth';
+import { TokensServicePolygon } from './TokensServicePolygon';
+import { TokensServiceXDai } from './TokensServiceXDai';
+
+export namespace TokensServiceFactory {
+
+    export function get (platform: TPlatform) {
+        switch (platform) {
+            case 'bsc':
+                return di.resolve(TokensServiceBsc);
+            case 'eth':
+                return di.resolve(TokensServiceEth);
+            case 'polygon':
+                return di.resolve(TokensServicePolygon);
+            case 'xdai':
+                return di.resolve(TokensServiceXDai);
+            default:
+                throw new Error(`Unsupported platform ${platform} for TokensService`);
+        }
+    }
+}

package/src/tokens/TokensServicePolygon.ts

@@ -0,0 +1,17 @@
+import di from 'a-di';
+import { TokensService } from './TokensService';
+import { ERC20 } from '@dequanto/contracts/common/ERC20';
+import { TAddress } from '@dequanto/models/TAddress';
+import { Polyscan } from '@dequanto/BlockchainExplorer/Polyscan';
+
+export class TokensServicePolygon extends TokensService {
+    constructor () {
+        super('polygon', di.resolve(Polyscan))
+    }
+
+    static async erc20 (address: TAddress): Promise<ERC20>
+    static async erc20 (symbol: string): Promise<ERC20>
+    static async erc20 (mix: string): Promise<ERC20> {
+        return TokensService.erc20(mix, 'polygon');
+    }
+}

package/src/tokens/TokensServiceXDai.ts

@@ -0,0 +1,26 @@
+import di from 'a-di';
+import { TokensService } from './TokensService';
+import { ERC20 } from '@dequanto/contracts/common/ERC20';
+import { TAddress } from '@dequanto/models/TAddress';
+import { XDaiscan } from '@dequanto/chains/xdai/XDaiscan';
+import { IToken } from '@dequanto/models/IToken';
+import { ITokenProvider } from './TokenProviders/ITokenProvider';
+
+export class TokensServiceXDai extends TokensService {
+    constructor () {
+        super('xdai', di.resolve(XDaiscan))
+    }
+
+    static async erc20 (address: TAddress): Promise<ERC20>
+    static async erc20 (symbol: string): Promise<ERC20>
+    static async erc20 (mix: string): Promise<ERC20> {
+        return TokensService.erc20(mix, 'xdai');
+    }
+
+    public async getTokenBySymbol (symbol: string, chainLookup: boolean = true): Promise<[IToken, ITokenProvider]> {
+        if (symbol === 'DAI') {
+            symbol = 'wxDAI';
+        }
+        return super.getTokenBySymbol(symbol, chainLookup);
+    }
+}

package/src/tokens/defi/ISwapService.ts

@@ -0,0 +1,12 @@
+import { ChainAccount } from '@dequanto/ChainAccounts';
+import { IToken } from '@dequanto/models/IToken';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+
+export interface ISwapService {
+    swap (account: ChainAccount, params: {
+        from: string | IToken
+        to: string | IToken
+        fromAmount: number | bigint
+        slippage?: number
+    }): Promise<TxWriter>
+}

package/src/tokens/defi/paraswap/Paraswap.ts

@@ -0,0 +1,244 @@
+import di from 'a-di';
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+import { THex } from '@dequanto/models/THex';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { TokensServiceFactory } from '@dequanto/tokens/TokensServiceFactory';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { ParaSwap, NetworkID } from "paraswap";
+import { OptimalRate, SwapSide } from "paraswap-core";
+import { ChainAccount, ChainAccountProvider } from '@dequanto/ChainAccounts';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
+import { PolyWeb3Client } from '@dequanto/clients/PolyWeb3Client';
+import { TokensServicePolygon } from '@dequanto/tokens/TokensServicePolygon';
+import { TokensService } from '@dequanto/tokens/TokensService';
+import { ISwapService } from '../ISwapService';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+
+
+interface TransactionParams {
+    to: TAddress;
+    from: TAddress;
+    value: THex;
+    data: THex;
+    gasPrice: THex;
+    gas?: THex;
+    chainId: number;
+}
+
+
+export class Paraswap implements ISwapService {
+
+    private tokensProvider = TokensServiceFactory.get(this.platform);
+
+    constructor(public platform: TPlatform, public client: Web3Client = di.resolve(PolyWeb3Client)) {
+
+    }
+
+    async balanceOf(address: TAddress, token: string): Promise<bigint> {
+        let erc20 = await TokensService.erc20(token, this.client.platform);
+        let balance = await erc20.balanceOf(address);
+        return balance;
+    }
+
+    async swap (account: ChainAccount, params: {
+        from: string | IToken
+        to: string | IToken
+        fromAmount: number | bigint
+        slippage?: number
+    }) {
+
+        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: ChainAccount, token: string | IToken, amount: bigint | number) {
+
+        token = await this.getToken(token);
+
+        const SPENDER = `0x216b4b4ba9f3e719726886d34a177484278bfcae`;
+        const erc20 = await TokensService.erc20(token.address, this.client.platform);
+
+        let approved = await erc20
+            .allowance(account.address, SPENDER);
+
+        let toApprove = typeof amount === 'bigint'
+            ? amount
+            : $bigint.toWei(amount, token.decimals);
+
+
+        if ((toApprove * 2n) > approved) {
+            return await erc20.approve(account, SPENDER, toApprove * 2n);
+        }
+        return null;
+    }
+
+    private async getSwapTransaction(params: {
+        from: string | IToken;
+        to: string | IToken;
+        fromAmount: number | bigint
+        userAddress: TAddress;
+        slippage?: number;
+        partner?: string;
+        receiver?: TAddress;
+
+    }): Promise<TransactionParams> {
+
+        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 = di.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
+            .multWithFloat(BigInt(priceRoute.destAmount), 1 - slippage / 100)
+            .toString()
+
+        const transactionRequest = await swapper.buildSwap({
+            from: from,
+            to: to,
+            fromAmount: srcAmount,
+            toMinAmount: minAmount,
+            priceRoute: priceRoute as any,
+            userAddress: params.userAddress,
+            receiver: params.receiver,
+            partner: params.partner
+        });
+        return transactionRequest;
+    }
+
+    private async sendTx (account: ChainAccount, calldata) {
+        let txData = TxDataBuilder.normalize(calldata);
+        let $txData = txData as any;
+
+        let gas = $txData.gas;
+        delete $txData.gas;
+        $txData.gasLimit = BigInt(gas) * 2n;
+
+        let txBuilder = new TxDataBuilder(this.client, account, txData as any );
+        await txBuilder.setNonce();
+
+        return TxWriter.write(this.client, txBuilder, account);
+    }
+
+    private async getTokens (from: string | TAddress | IToken, to: string | TAddress | IToken) {
+        return await Promise.all([
+            this.getToken(from),
+            this.getToken(to)
+        ]);
+    }
+
+    private async getToken(mix: string | IToken): Promise<IToken> {
+        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;
+    }
+}
+
+
+
+
+
+const NETWORK_IDS = {
+    'polygon': 137,
+} as {
+        [platform in TPlatform]: NetworkID
+    }
+
+
+class Swapper {
+    paraswap = new ParaSwap(
+        NETWORK_IDS[this.platform],
+        //apiURL,
+        //web3ProividersURLs[networkID]
+    );
+
+    constructor(public platform: TPlatform) {
+    }
+
+    async getRate(params: {
+        from: IToken,
+        to: IToken,
+        fromAmount: string,
+        userAddress: TAddress,
+        partner?
+    }) {
+        const priceRouteOrError = await this.paraswap.getRate(
+            params.from.address,
+            params.to.address,
+            params.fromAmount,
+            params.userAddress,
+            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: {
+        from: IToken
+        to: IToken
+        fromAmount: string
+        toMinAmount: string
+        priceRoute: OptimalRate
+        userAddress
+        receiver?
+        partner?
+    }) {
+
+        const transactionRequestOrError = await this.paraswap.buildTx(
+            params.from.address,
+            params.to.address,
+            params.fromAmount,
+            params.toMinAmount,
+            params.priceRoute as any,
+            params.userAddress,
+            params.partner,
+            undefined,
+            undefined,
+            params.receiver
+        );
+
+        if ('message' in transactionRequestOrError) {
+            throw new Error(transactionRequestOrError.message);
+        }
+        return transactionRequestOrError as TransactionParams;
+    };
+}

package/src/tokens/erc20/eth/WETH.ts

@@ -0,0 +1,13 @@
+/**
+ * dequanto
+ * name: WETHBase
+ * platform: eth
+ * source.abi: 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
+ * output: ./contracts/gen/eth/
+ */
+
+import { WETHBase } from '@dequanto-contracts/gen/eth/WETHBase';
+
+export class WETH extends WETHBase {
+
+}

package/src/tokens/utils/TokenUtils.ts

@@ -0,0 +1,63 @@
+import { IToken } from '@dequanto/models/IToken';
+import { ITokenGlob } from '@dequanto/models/ITokenGlob';
+import { $bigint } from '@dequanto/utils/$bigint';
+import { $number } from '@dequanto/utils/$number';
+import alot from 'alot';
+
+export namespace TokenUtils {
+    export function isStable (symbol: string) {
+        return /^[tb]?usd[tc]?$/i.test(symbol) || /^(dai)$/i.test(symbol);
+    }
+    export function calcUsdIfStable (amount: bigint, token: IToken) {
+        if (isStable(token.symbol) === false) {
+            return null;
+        }
+        let tokenBase = 10n ** BigInt(token.decimals);
+        return $bigint.divToFloat(amount, tokenBase, 10n**8n);
+    }
+    export function calcPrice (amount: bigint, token: IToken, usd: number) {
+        if (usd == null) {
+            return null;
+        }
+        let tokenBase = 10n ** BigInt(token.decimals);
+        let tokenAmount = $bigint.divToFloat(amount, tokenBase, 10n**8n);
+        return $number.div(usd, tokenAmount);
+    }
+    export function calcTotal (token: IToken, amount: bigint, price: number) {
+        if (price == null) {
+            return null;
+        }
+        let tokenBase = 10n ** BigInt(token.decimals);
+        let tokenAmount = $bigint.divToFloat(amount, tokenBase, 10n**8n);
+        return tokenAmount * price;
+    }
+
+
+
+    export function merge (...tokens: IToken[][]): ITokenGlob[] {
+        let all = alot(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 <ITokenGlob> {
+                    symbol: token.symbol,
+                    name: token.name,
+                    logo: logo,
+
+                    platforms: group.values.map(t => {
+                        return <ITokenGlob['platforms'][0]>{
+                            address: t.address,
+                            decimals: t.decimals,
+                            platform: t.platform,
+                        };
+                    })
+                };
+            })
+            .toArray();
+
+        return all;
+    }
+}