dequanto 0.0.1 → 0.1.3

package/src/tokens/TokensService.ts

@@ -1,140 +1,69 @@
 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 { IBlockChainExplorer } from '@dequanto/explorer/IBlockChainExplorer';
 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';
+import { BlockChainExplorerProvider } from '@dequanto/explorer/BlockChainExplorerProvider';
+import { TokenDataProvider } from './TokenDataProvider';
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
 
 
 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[];
 
+    provider: TokenDataProvider
 
-    constructor(private platform: TPlatform, private explorer?: IBlockChainExplorer) {
-
+    constructor(private platform: TPlatform, private explorer?: IBlockChainExplorer, private forked?: TokenDataProvider) {
+        this.provider = new TokenDataProvider(this.platform, this.explorer, null, this.forked);
     }
 
-    async getTokenOrDefault (address: TAddress, chainLookup: boolean = true): Promise<IToken> {
-        return await this.getToken(address, chainLookup) ?? this.default(address);
+    async getTokenOrDefault (symbol: string, chainLookup?: boolean): Promise<IToken>
+    async getTokenOrDefault (address: TAddress, chainLookup?: boolean): Promise<IToken>
+    async getTokenOrDefault (mix: TAddress | string, chainLookup: boolean = true): Promise<IToken> {
+        return this.provider.getTokenOrDefault(mix, chainLookup);
     }
 
 
     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
+        return this.provider.getToken(mix, chainLookup);
     }
 
-    @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
+    async getKnownToken (mix: string): Promise<IToken> {
+        return this.provider.getKnownToken(mix);
+    }
+    async addKnownToken (token: IToken): Promise<void> {
+        await this.provider.addKnownToken(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);
+        return this.provider.isNative(mix);
     }
 
-    getNative (platform: TPlatform): IToken {
-        return NativeTokens.getNative(platform);
+    getNative (platform: TPlatform = this.platform): IToken {
+        return this.provider.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()
+        return this.provider.redownload();
     }
 
     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];
+        return this.provider.getTokenByAddress(address, chainLookup);
     }
     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 ];
+        return this.provider.getTokenBySymbol(symbol, chainLookup);
     }
 
-    private default (address: TAddress) {
-        return {
-            platform: this.platform,
-            symbol: address,
-            name: address,
-            address: address,
-            decimals: 18,
-        };
-    }
 
     @memd.deco.memoize()
     static async erc20 (
@@ -149,104 +78,31 @@ export class TokensService {
             token = await service.getToken(token);
         }
         if (token == null) {
-            throw new Error(`Token not found: ${arguments[0]}`);
+            throw new Error(`Token not found ${arguments[0]} in ${platform}`);
         }
         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()];
+        return TokensService.erc20(token, this.platform);
+        // 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);
     }
 }
-
-

package/src/tokens/TokensServiceBsc.ts

@@ -1,17 +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');
-    }
-}
+import di from 'a-di';
+import { TokensService } from './TokensService';
+import { Bscscan } from '@dequanto/explorer/Bscscan';
+import { TAddress } from '@dequanto/models/TAddress';
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+
+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

@@ -1,9 +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))
-    }
-}
+import di from 'a-di';
+import { TokensService } from './TokensService';
+import { Etherscan } from '@dequanto/explorer/Etherscan';
+
+export class TokensServiceEth extends TokensService {
+    constructor () {
+        super('eth', di.resolve(Etherscan))
+    }
+}

package/src/tokens/TokensServiceFactory.ts

@@ -4,6 +4,10 @@ import { TokensServiceBsc } from './TokensServiceBsc';
 import { TokensServiceEth } from './TokensServiceEth';
 import { TokensServicePolygon } from './TokensServicePolygon';
 import { TokensServiceXDai } from './TokensServiceXDai';
+import { TokensServiceArbitrum } from '@dequanto/chains/arbitrum/TokensServiceArbitrum';
+import { TokensService } from './TokensService';
+import { config } from '@dequanto/config/Config';
+import { TokenDataProvider } from './TokenDataProvider';
 
 export namespace TokensServiceFactory {
 
@@ -17,8 +21,18 @@ export namespace TokensServiceFactory {
                 return di.resolve(TokensServicePolygon);
             case 'xdai':
                 return di.resolve(TokensServiceXDai);
-            default:
+            case 'arbitrum':
+                return di.resolve(TokensServiceArbitrum);
+            case 'hardhat':
+                let ethProvider = new TokenDataProvider('eth');
+                return new TokensService(platform, null, ethProvider);
+            default: {
+                let cfg = config.web3[platform];
+                if (cfg != null) {
+                    return di.resolve(TokensService, platform);
+                }
                 throw new Error(`Unsupported platform ${platform} for TokensService`);
+            }
         }
     }
 }

package/src/tokens/TokensServicePolygon.ts

@@ -1,17 +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');
-    }
-}
+import di from 'a-di';
+import { TokensService } from './TokensService';
+import { TAddress } from '@dequanto/models/TAddress';
+import { Polyscan } from '@dequanto/explorer/Polyscan';
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+
+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

@@ -1,26 +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);
-    }
-}
+import di from 'a-di';
+import { TokensService } from './TokensService';
+import { TAddress } from '@dequanto/models/TAddress';
+import { XDaiscan } from '@dequanto/chains/xdai/XDaiscan';
+import { IToken } from '@dequanto/models/IToken';
+import { ITokenProvider } from './TokenProviders/ITokenProvider';
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
+
+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

@@ -1,12 +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>
-}
+import { EoAccount } from "@dequanto/models/TAccount";
+import { IToken } from '@dequanto/models/IToken';
+import { TxWriter } from '@dequanto/txs/TxWriter';
+
+export interface ISwapService {
+    swap (account: EoAccount, params: {
+        from: string | IToken
+        to: string | IToken
+        fromAmount: number | bigint
+        slippage?: number
+    }): Promise<TxWriter>
+}