dequanto 0.0.1

package/dist/src/wallets/Wallet.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Wallet = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const ERC20_1 = require("@dequanto/contracts/common/ERC20");
+const TokensService_1 = require("@dequanto/tokens/TokensService");
+class Wallet {
+    constructor(account, client, explorer) {
+        this.account = account;
+        this.client = client;
+        this.explorer = explorer;
+        this.tokensService = a_di_1.default.resolve(TokensService_1.TokensService, this.account.platform, this.explorer);
+    }
+    async balanceOf(mix) {
+        let token = await this.tokensService.getToken(mix);
+        if (token == null) {
+            throw new Error(`Token ${mix} not found`);
+        }
+        let erc20 = new ERC20_1.ERC20(token.address, this.client, this.explorer);
+        return erc20.balanceOf(this.account.address);
+    }
+}
+exports.Wallet = Wallet;

package/dist/src/wallets/WalletBsc.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletBsc = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const BscWeb3Client_1 = require("@dequanto/clients/BscWeb3Client");
+const Wallet_1 = require("./Wallet");
+const Bscscan_1 = require("@dequanto/BlockchainExplorer/Bscscan");
+/** @deprecated use generic Wallet.ts */
+class WalletBsc extends Wallet_1.Wallet {
+    constructor(account) {
+        super(account, a_di_1.default.resolve(BscWeb3Client_1.BscWeb3Client), a_di_1.default.resolve(Bscscan_1.Bscscan));
+    }
+}
+exports.WalletBsc = WalletBsc;

package/dist/src/wallets/WalletService.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletService = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
+const TokensService_1 = require("@dequanto/tokens/TokensService");
+class WalletService {
+    constructor(wallet) {
+        this.wallet = wallet;
+    }
+    async getTokens(fromBlock) {
+        let wallet = this.wallet;
+        let account = wallet.account;
+        let events = await wallet.explorer.getErc20Transfers(account.address, fromBlock);
+        let service = a_di_1.default.resolve(TokensService_1.TokensService, account.platform, wallet.explorer);
+        let tokens = await (0, alot_1.default)(events)
+            .map(x => x.contractAddress)
+            .distinct()
+            .mapAsync(async (address) => {
+            let token = await service.getKnownToken(address);
+            if (token?.address == null) {
+                return null;
+            }
+            return token;
+        })
+            .toArrayAsync({ threads: 10 });
+        return tokens.filter(Boolean);
+    }
+}
+exports.WalletService = WalletService;
+class WalletTokensEntity {
+}

package/dist/src/www/utils/BlockChainExplorerFormatter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockChainExplorerFormatter = void 0;
+var BlockChainExplorerFormatter;
+(function (BlockChainExplorerFormatter) {
+    function getAddressLink(address, platform) {
+        if (platform === 'bsc') {
+            return `https://bscscan.com/address/${address}`;
+        }
+        if (platform === 'eth') {
+            return `https://etherscan.io/address/${address}`;
+        }
+    }
+    BlockChainExplorerFormatter.getAddressLink = getAddressLink;
+})(BlockChainExplorerFormatter = exports.BlockChainExplorerFormatter || (exports.BlockChainExplorerFormatter = {}));

package/hardhat.config.js

@@ -0,0 +1,6 @@
+/**
+ * @type import('hardhat/config').HardhatUserConfig
+ */
+module.exports = {
+  solidity: "0.7.3",
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "dequanto",
+  "version": "0.0.1",
+  "scripts": {
+    "hardhat": "hardhat node",
+    "build": "tsc -p tsconfig-src.json"
+  },
+  "devDependencies": {
+    "atma-loader-ts": "^1.1.18",
+    "hardhat": "^2.6.7",
+    "shellbee": "^0.5.16"
+  },
+  "dependencies": {
+    "@ethereumjs/common": "^2.5.0",
+    "@ethereumjs/tx": "^3.3.2",
+    "a-di": "^1.0.25",
+    "alot": "^0.2.96",
+    "atma": "^0.15.12",
+    "atma-io": "^1.2.59",
+    "atma-utils": "^0.2.51",
+    "axios": "^0.21.1",
+    "bcrypt": "^5.0.1",
+    "ethers": "^5.5.1",
+    "everlog": "^1.0.8",
+    "memd": "^0.3.10",
+    "papaparse": "^5.3.1",
+    "ts-nameof": "^5.0.0",
+    "web3": "^1.6.0",
+    "web3-core": "^1.6.0",
+    "web3-core-subscriptions": "^1.6.0"
+  },
+  "atma": {
+    "configs": "./configs/**.yml",
+    "plugins": [
+      "atma-loader-ts"
+    ],
+    "settings": {
+      "include": {
+        "amd": true,
+        "extentionDefault": {
+          "js": "ts"
+        },
+        "routes": "#import ./tsconfig-build.json compilerOptions.paths",
+        "map": {}
+      },
+      "atma-loader-ts": {
+        "sourceMap": true,
+        "typescript": "#import ./tsconfig-build.json"
+      }
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,76 @@
+# dequanto
+
+
+Here we share our library to work with Ethereum Virtual Machine RPC Nodes: Ethereum, Polygon, BSC, Arbitrum, etc. We use web3 and ethers to provide new Features and to simplify the API.
+
+1. RPC Client Pool
+2. Transaction Builder
+3. Generated TypeScript classes for contracts
+4. Etherscan&Co clients
+5. Tokens provider - get token data by symbol, address, platform.
+6. Tokens service - transfer and swap
+7. Transaction **Indexers** - listens to blocks and parse new transactions to simplify further processing
+8. Native **`BigInt`** types and various utility methods
+
+
+### Distribution `as-Source-Code`
+
+Not as a library, but as the source code. Clone or fork it and use it as a **submodule**. Means:
+a) you can `import` any `class`, `namespace` and `utility` methods.
+b) you can easily extend and modify any `class`, `namespace` and `utility` method.
+c) you get the documentation direct from the code. _We don't have much time yet to document all the parts_
+
+And path prefix (alias) to your `tsconfig.json`
+```json
+{
+    "compilerOptions": {
+        "paths": {
+            "@dequanto/*": [ "your-sub-module-folder/src/*" ]
+        }
+    }
+}
+```
+
+### Configuration
+
+Before you use the code, you should prepare the configuration for it: Node RPC URLs, Accounts, Blockchain Explorer API Keys, etc.
+
+## 1. RPC Client Pool
+
+Provide multiple RPC Node URLs, this will make your application much more reliable. Even if one of the Nodes goes down or for some reason is not in-sync, all your RPC calls will still work.
+
+[Web3Client](src/clients/Web3Client.ts) is the base class for all the EVM Platforms. This wraps web3 to provide pool-based communication with nodes. It handles also Gas and Nonce Values.
+
+
+## 2. Transaction Builder
+
+[TxDataBuilder](src/txs/TxDataBuilder.ts) and [TxWriter](src/txs/TxWriter.ts) to create and submit transaction.
+
+
+## 3. Generated TypeScript classes for contracts
+
+With auto-generated classes you can
+
+a) type-safe method read and write(transaction) calls to blockchain
+b) parse receipts of the contract transactions
+c) easily subscribe to event streams of the contract
+
+## 4. Etherscan&Co clients
+
+Ready to use Etherscan&Co classes to consume their API. Just drop-in the KEYs.
+
+## 5. Tokens provider
+
+Get Tokens Data (`address`, `decimals`, etc) by `symbol` and `platform`
+
+## 6. Tokens service
+
+One-liners to transfer tokens from A to B, or swap the tokens using popular DEXes
+
+## 7. Transaction **Indexers**
+
+Start listening the blockchain with less code
+
+## 8. Utils
+
+Lots of Utility methods. BigInt are the first-class citizens in the code.

package/src/BlockchainExplorer/BlockChainExplorerFactory.ts

@@ -0,0 +1,273 @@
+import alot from 'alot';
+import memd from 'memd';
+import axios from 'axios'
+import { IBlockChainExplorer, IBlockChainTransferEvent } from './IBlockChainExplorer';
+import { Transaction } from 'web3-core';
+import { AbiItem } from 'web3-utils';
+import { IContractDetails } from '@dequanto/models/IContractDetails';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { TAddress } from '@dequanto/models/TAddress';
+import { $logger } from '@dequanto/utils/$logger';
+import { $promise } from '@dequanto/utils/$promise';
+
+export namespace BlockChainExplorerFactory {
+
+    export function create (opts: {
+        ABI_CACHE: string
+        CONTRACTS: IContractDetails[]
+        getWeb3: () => Web3Client
+        getConfig: () => { key: string, host: string }
+    }) {
+
+        const client = new Client();
+
+        return class implements IBlockChainExplorer {
+
+            localDb: IContractDetails[] = opts.CONTRACTS
+            config = opts.getConfig()
+
+            constructor () {
+                this.getContractAbi = memd.fn.memoize(this.getContractAbi, {
+                    trackRef: true,
+                    persistance: new memd.FsTransport({
+                        path: opts.ABI_CACHE
+                    })
+                });
+                this.getContractSource = memd.fn.memoize(this.getContractSource, {
+                    trackRef: true,
+                    persistance: new memd.FsTransport({
+                        path: opts.ABI_CACHE.replace('.json', '-source.json')
+                    })
+                });
+            }
+
+            async getContractMeta (name: string)
+            async getContractMeta (address: string)
+            async getContractMeta (q: string): Promise<IContractDetails> {
+                q = q.toLowerCase();
+
+                let info = this.localDb.find(x => x.address.toLowerCase() === q || x.name?.toLowerCase() === q);
+
+                return info;
+            }
+
+            async getContractAbi (address: TAddress, params?: { implementation: string }): Promise<{ abi: string, implementation: TAddress }> {
+                let info = await this.getContractMeta(address);
+                if (info?.proxy) {
+                    address = info.proxy;
+                }
+
+                let url = `${this.config.host}/api?module=contract&action=getabi&address=${address}&apikey=${this.config.key}`;
+                let abi: string = await client.get(url);
+
+                let abiJson = JSON.parse(abi);
+                if (params?.implementation) {
+                    if (/0x.{64}/.test(params.implementation)) {
+                        let web3 = opts.getWeb3();
+
+                        let stat = await web3.getNodeInfos();
+
+                        //-let x = (BigInt($contract.keccak256("eip1967.proxy.implementation")) - 1n).toString(16);
+                        let uin256Hex = await web3.getStorageAt(
+                        '0x5a58505a96d1dbf8df91cb21b54419fc36e93fde',
+                        `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
+                        );
+                        let hex = uin256Hex.replace(/0x0+/, '0x');
+                        return this.getContractAbi(hex)
+                    }
+                    throw new Error(`Implement ${params.implementation} support`);
+                }
+                if (isOpenZeppelinProxy(abiJson)) {
+                    let web3 = opts.getWeb3();
+                    let uin256Hex = await web3.getStorageAt(
+                        address,
+                        `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
+                    );
+                    let hex = uin256Hex.replace(/0x0+/, '0x');
+                    return this.getContractAbi(hex)
+                }
+
+                if (hasImplementationSlot(abiJson)) {
+                    let web3 = opts.getWeb3();
+                    let uin256Hex = await web3.readContract({
+                        address: address,
+                        abi: abiJson,
+                        method: 'implementation',
+                        arguments: []
+                    });
+                    let hex = uin256Hex.replace(/0x0+/, '0x');
+                    return this.getContractAbi(hex);
+                }
+                if (hasTargetSlot(abiJson)) {
+                    let web3 = opts.getWeb3();
+                    let uin256Hex = await web3.readContract({
+                        address: address,
+                        abi: abiJson,
+                        method: 'getTarget',
+                        arguments: []
+                    });
+                    let hex = uin256Hex.replace(/0x0+/, '0x');
+                    return this.getContractAbi(hex);
+                }
+                return { abi, implementation: address };
+            }
+
+            async getContractSource (address: string): Promise<{
+                SourceCode: string
+                ContractName: string
+                ABI: string
+            }> {
+                let url = `${this.config.host}/api?module=contract&action=getsourcecode&address=${address}&apikey=${this.config.key}`;
+                let result = await client.get(url);
+                return Array.isArray(result) ? result[0] : result;
+            }
+
+            async getTransactions (addr: TAddress, params?: { fromBlockNumber?: number, page?: number, size?: number, sort?: 'asc' | 'desc' }): Promise<Transaction[]> {
+                return this.loadTxs('txlist', addr, params);
+            }
+            async getTransactionsAll (addr: TAddress): Promise<Transaction[]> {
+                return this.loadTxsAll('txlist', addr);
+            }
+
+
+            async getInternalTransactions (addr: TAddress, params?: { fromBlockNumber?: number, page?: number, size?: number, sort?: 'asc' | 'desc' }): Promise<Transaction[]> {
+                return this.loadTxs('txlistinternal', addr, params);
+            }
+            async getInternalTransactionsAll (addr: TAddress): Promise<Transaction[]> {
+                return this.loadTxsAll('txlistinternal', addr);
+            }
+
+
+            async getErc20Transfers (addr: TAddress, fromBlockNumber?: number): Promise<IBlockChainTransferEvent[]> {
+                let events: IBlockChainTransferEvent[] = await this.loadTxs('tokentx', addr, { fromBlockNumber });
+                events.forEach(transfer => {
+                    transfer.timeStamp = new Date((Number(transfer.timeStamp) * 1000))
+                    transfer.value = BigInt(transfer.value);
+                    transfer.blockNumber = Number(transfer.blockNumber);
+                    transfer.tokenDecimal = Number(transfer.tokenDecimal);
+                });
+                return events;
+            }
+            async getErc20TransfersAll (addr: TAddress, fromBlockNumber?: number): Promise<IBlockChainTransferEvent[]> {
+                let events = await this.loadTxsAll('tokentx', addr) as any as IBlockChainTransferEvent[];
+                events.forEach(transfer => {
+                    transfer.timeStamp = new Date((Number(transfer.timeStamp) * 1000))
+                    transfer.value = BigInt(transfer.value);
+                    transfer.blockNumber = Number(transfer.blockNumber);
+                    transfer.tokenDecimal = Number(transfer.tokenDecimal);
+                });
+                return events;
+            }
+
+
+            async loadTxs(type: 'tokentx' | 'txlistinternal' | 'txlist', address: TAddress, params?: {
+                fromBlockNumber?: number,
+                page?: number,
+                size?: number,
+                sort?: 'asc' | 'desc'
+            }) {
+                let url = `${this.config.host}/api?module=account&action=${type}&address=${address}&sort=${params.sort ?? 'desc'}&apikey=${this.config.key}`;
+                if (params.fromBlockNumber != null) {
+                    url += `&startblock=${params.fromBlockNumber}`
+                }
+                if (params.page != null) {
+                    url += `&page=${params.page}`
+                }
+                if (params.size != null) {
+                    url += `&offset=${params.size}`
+                }
+                let txs = await client.get(url);
+                return txs;
+            }
+
+            async loadTxsAll (type: 'tokentx' | 'txlistinternal' | 'txlist', address: TAddress): Promise<Transaction[]> {
+
+                let page = 1;
+                let size = 1000;
+                let out = [] as Transaction[];
+                let fromBlockNumber = null as number;
+                while(true) {
+                    let arr = await this.loadTxs(type, address, { fromBlockNumber, sort: 'asc' });
+                    out.push(...arr);
+                    $logger.log(`Got transactions(${type}) for ${address}. Page: ${arr.length}; Received: ${out.length}. Latest Block: ${fromBlockNumber}`);
+
+                    if (arr.length < size) {
+                        break;
+                    }
+                    page++;
+                    fromBlockNumber = Number(arr[arr.length - 1].blockNumber);
+                }
+                return alot(out).distinctBy(x => x.hash).toArray();
+            }
+        }
+    }
+}
+
+function isOpenZeppelinProxy(abi: AbiItem[]) {
+    let $interface = ['upgradeTo', 'implementation'];
+    return $interface.every(name => {
+        return abi.some(item => item.type === 'function' && item.name === name);
+    })
+}
+function hasImplementationSlot (abi: AbiItem[]) {
+    let $interface = ['proxyOwner', 'implementation'];
+    return $interface.every(name => {
+        return abi.some(item => item.type === 'function' && item.name === name);
+    })
+}
+function hasTargetSlot (abi: AbiItem[]) {
+    let $interface = ['upgrade', 'getTarget'];
+    return $interface.every(name => {
+        return abi.some(item => item.type === 'function' && item.name === name);
+    })
+}
+
+
+
+class Client {
+
+    @memd.deco.queued({ throttle: 1000 / 5 })
+    async get (url: string) {
+        return this.getInner(url)
+    }
+
+    async getPaged (url: string) {
+        let arr = [];
+        let page = 1;
+        let size = 200;
+        while (true) {
+            let path = `${url}&page=${page}&offset=${size}`;
+            let pageArr: any[] = await this.get(path);
+            arr = arr.concat(pageArr);
+            if (pageArr.length < size) {
+                break;
+            }
+            page++;
+        }
+        return arr;
+    }
+
+    private async getInner (url: string, opts?: { retryCount: number }) {
+        let resp = await axios.get(url);
+        let data = resp.data as { status: string, message: 'OK' | 'NOTOK', result: any };
+        if (data.message === 'NOTOK') {
+            let str = data.result;
+            if (/Max rate/i.test(str)) {
+                let count = opts?.retryCount ?? 3;
+                if (--count === 0) {
+                    throw new Error(str);
+                }
+                await $promise.wait(200);
+                return this.getInner(url, {
+                    retryCount: count
+                });
+            }
+            throw new Error(str);
+        }
+        if (data.result == null) {
+            console.warn(`Blockchain "${url}" explorer returned empty result`, data);
+        }
+        return data.result;
+    }
+}
+

package/src/BlockchainExplorer/BlockChainExplorerProvider.ts

@@ -0,0 +1,26 @@
+import di from 'a-di';
+import { Arbiscan } from '@dequanto/chains/arbitrum/Arbiscan';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { Bscscan } from './Bscscan';
+import { Etherscan } from './Etherscan';
+import { Polyscan } from './Polyscan';
+import { XDaiscan } from '@dequanto/chains/xdai/XDaiscan';
+
+export namespace BlockChainExplorerProvider {
+    export function get (platform: TPlatform) {
+        switch (platform) {
+            case 'bsc':
+                return di.resolve(Bscscan);
+            case 'eth':
+                return di.resolve(Etherscan);
+            case 'polygon':
+                return di.resolve(Polyscan);
+            case 'arbitrum':
+                return di.resolve(Arbiscan);
+            case 'xdai':
+                return di.resolve(XDaiscan);
+            default:
+                throw new Error(`Unsupported platform ${platform} for block chain explorer`);
+        }
+    }
+}

package/src/BlockchainExplorer/BlockNumberCache.ts

@@ -0,0 +1,46 @@
+import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
+import { JsonArrayStore } from '@dequanto/json/JsonArrayStore';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import memd from 'memd';
+
+
+interface IBlockNumberCache {
+    address: TAddress
+    blockNumber: number
+}
+
+export class BlockNumberCache {
+    store: JsonArrayStore<IBlockNumberCache>;
+
+
+    constructor (public platform: TPlatform, public name: string) {
+
+        this.store = new JsonArrayStore<IBlockNumberCache>({
+            path: `/cache/${platform}/blockNumber-${name}.json`,
+            key: x => x.address
+        });
+    }
+
+    async getCached (address: TAddress) {
+        let entry = await this.store.getSingle(address);
+        return entry ?? {
+            address: address,
+            blockNumber: null,
+        };
+    }
+
+    async saveCached (cache: IBlockNumberCache) {
+        await this.store.upsert(cache);
+    }
+
+    async updateCache (cache: IBlockNumberCache) {
+        let client = Web3ClientFactory.get(this.platform);
+        let toleranz = 5;
+
+        let number = await client.getBlockNumberCached() - toleranz;
+
+        cache.blockNumber = Math.max(number, cache.blockNumber);
+        await this.store.upsert(cache);
+    }
+}

package/src/BlockchainExplorer/Bscscan.ts

@@ -0,0 +1,23 @@
+import di from 'a-di';
+import { BlockChainExplorerFactory } from './BlockChainExplorerFactory';
+
+import { $config } from '@dequanto/utils/$config';
+import { BscWeb3Client } from '@dequanto/clients/BscWeb3Client';
+
+const contracts = $config.get('contracts.bsc', []);
+export class Bscscan extends BlockChainExplorerFactory.create({
+    ABI_CACHE: `./cache/bsc/abis.json`,
+    CONTRACTS: contracts,
+    getWeb3 () {
+        return di.resolve(BscWeb3Client)
+    },
+    getConfig () {
+        const config = $config.get('blockchainExplorer.bsc');
+        return {
+            key: config?.key,
+            host: config?.host,
+        };
+    }
+}) {
+
+}

package/src/BlockchainExplorer/Etherscan.ts

@@ -0,0 +1,25 @@
+import { BlockChainExplorerFactory } from './BlockChainExplorerFactory';
+
+import { $config } from '@dequanto/utils/$config';
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import di from 'a-di';
+
+
+const contracts = $config.get('contracts.eth', [])
+export class Etherscan extends BlockChainExplorerFactory.create({
+    ABI_CACHE: `./cache/eth/abis.json`,
+    CONTRACTS: contracts,
+    getWeb3 () {
+        return di.resolve(EthWeb3Client)
+    },
+    getConfig () {
+        const config = $config.get('blockchainExplorer.eth');
+        return {
+            key: config?.key,
+            host: config?.host,
+        };
+    }
+}) {
+
+}
+

package/src/BlockchainExplorer/IAbiProvider.ts

@@ -0,0 +1,5 @@
+import { TAddress } from '@dequanto/models/TAddress';
+
+export interface IAbiProvider {
+    getContractAbi (address: TAddress, opts: { implementation: string }): Promise<{ abi: string, implementation: TAddress }>
+}

package/src/BlockchainExplorer/IBlockChainExplorer.ts

@@ -0,0 +1,37 @@
+import { TAddress } from '@dequanto/models/TAddress';
+import { IContractDetails } from '@dequanto/models/IContractDetails';
+import { Transaction } from 'web3-core';
+import { IAbiProvider } from './IAbiProvider';
+
+export interface IBlockChainExplorer extends IAbiProvider {
+    localDb: IContractDetails[]
+    getContractMeta(q: string): Promise<IContractDetails>;
+    getContractAbi (address: TAddress, opts?: { implementation: string }): Promise<{ abi: string, implementation: TAddress }>
+    getContractSource (address: string): Promise<{
+        SourceCode: string
+        ContractName: string
+        ABI: string
+    }>
+
+    getTransactions (address: TAddress, params?: { fromBlockNumber?: number, page?: number, size?: number }): Promise<Transaction[]>
+    getTransactionsAll (address: TAddress): Promise<Transaction[]>
+
+    getInternalTransactions (address: TAddress, params?: { fromBlockNumber?: number, page?: number, size?: number }): Promise<Transaction[]>
+    getInternalTransactionsAll (address: TAddress): Promise<Transaction[]>
+
+    getErc20Transfers(address: TAddress, fromBlockNumber?: number): Promise<IBlockChainTransferEvent[]>
+    getErc20TransfersAll(address: TAddress, fromBlockNumber?: number): Promise<IBlockChainTransferEvent[]>
+}
+
+export interface IBlockChainTransferEvent {
+    blockNumber: number,
+    timeStamp: Date,
+    hash: string
+    from: string
+    contractAddress: string
+    to: string
+    value: bigint,
+    tokenName: string
+    tokenSymbol: string
+    tokenDecimal: number
+}