dequanto 0.0.1 → 0.0.7

package/hardhat.config.js

@@ -1,6 +1,26 @@
+require("@nomiclabs/hardhat-web3");
+require("@nomiclabs/hardhat-ethers");
+require("@0xweb/hardhat");
+
 /**
  * @type import('hardhat/config').HardhatUserConfig
  */
 module.exports = {
-  solidity: "0.7.3",
+    solidity: {
+        version: "0.8.2",
+        settings: {
+            optimizer: {
+                enabled: true,
+                runs: 200
+            }
+        }
+    },
+    networks: {
+        hardhat: {
+            chainId: 1337
+        },
+        localhost: {
+            chainId: 1337
+        }
+    }
 };

package/package.json

@@ -1,30 +1,44 @@
 {
   "name": "dequanto",
-  "version": "0.0.1",
+  "version": "0.0.7",
   "scripts": {
-    "hardhat": "hardhat node",
-    "build": "tsc -p tsconfig-src.json"
+    "hardhat": "node --openssl-legacy-provider ./node_modules/hardhat/internal/cli/cli.js node --hostname 127.0.0.1 --verbose",
+    "build": "tsc -p tsconfig-src.json",
+    "test": "atma --openssl-legacy-provider test --config='settings.base=./'",
+    "contracts": "atma act ./actions/contracts.act.ts"
   },
   "devDependencies": {
-    "atma-loader-ts": "^1.1.18",
-    "hardhat": "^2.6.7",
-    "shellbee": "^0.5.16"
+    "@0xweb/hardhat": "^0.1.15",
+    "@nomiclabs/hardhat-ethers": "^2.0.5",
+    "@nomiclabs/hardhat-web3": "^2.0.0",
+    "@openzeppelin/contracts": "^4.7.0",
+    "@types/sinon": "^10.0.13",
+    "atma-utest": "^0.21.30",
+    "evm": "^0.2.0",
+    "hardhat": "^2.12.6",
+    "shellbee": "^0.5.16",
+    "ts-nameof": "^5.0.0"
   },
   "dependencies": {
-    "@ethereumjs/common": "^2.5.0",
-    "@ethereumjs/tx": "^3.3.2",
+    "@gnosis.pm/safe-core-sdk": "^2.1.0",
+    "@gnosis.pm/safe-ethers-lib": "^1.1.0",
+    "@gnosis.pm/safe-service-client": "^1.1.2",
+    "@gnosis.pm/safe-web3-lib": "^1.1.0",
+    "@solidity-parser/parser": "^0.14.5",
     "a-di": "^1.0.25",
-    "alot": "^0.2.96",
-    "atma": "^0.15.12",
-    "atma-io": "^1.2.59",
+    "alot": "^0.3.3",
+    "appcfg": "^0.4.64",
+    "atma": "^0.15.17",
+    "atma-io": "^1.2.67",
+    "atma-loader-ts": "^1.1.18",
     "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",
+    "everlog": "^1.0.10",
+    "includejs": "^0.16.9",
+    "memd": "^0.3.12",
     "papaparse": "^5.3.1",
-    "ts-nameof": "^5.0.0",
     "web3": "^1.6.0",
     "web3-core": "^1.6.0",
     "web3-core-subscriptions": "^1.6.0"

package/readme.md

@@ -1,22 +1,26 @@
 # dequanto
 
+[![Documentation Link](https://img.shields.io/badge/%E2%9D%93-documentation-green.svg)](https://docs.0xweb.org/dequanto)
+[![CircleCI](https://circleci.com/gh/0xweb-org/dequanto.svg?style=svg)](https://circleci.com/gh/0xweb-org/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
+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
+9. OpenZeppelin contracts
 
 
-### Distribution `as-Source-Code`
+###  **`Source-Code`** Distribution
 
 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.
+a) you can `import` any `class`, `namespace` and `utility` method.
 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_
 
@@ -25,7 +29,8 @@ And path prefix (alias) to your `tsconfig.json`
 {
     "compilerOptions": {
         "paths": {
-            "@dequanto/*": [ "your-sub-module-folder/src/*" ]
+            "@dequanto/*": [ "your-sub-module-folder/src/*" ],
+            "@dequanto-contract/*": [ "your-sub-module-folder/contract/*" ]
         }
     }
 }
@@ -74,3 +79,15 @@ Start listening the blockchain with less code
 ## 8. Utils
 
 Lots of Utility methods. BigInt are the first-class citizens in the code.
+
+
+### 9. OpenZeppelin contracts
+
+We prebuild generic OpenZeppelin contracts
+
+```
+import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20
+
+let erc20 = new ERC20(`0x...`);
+let balance = await erc20.balanceOf('0x...');
+```

package/src/BlockchainExplorer/BlockChainExplorerFactory.ts

@@ -3,30 +3,49 @@ import memd from 'memd';
 import axios from 'axios'
 import { IBlockChainExplorer, IBlockChainTransferEvent } from './IBlockChainExplorer';
 import { Transaction } from 'web3-core';
-import { AbiItem } from 'web3-utils';
+import { type 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';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { $address } from '@dequanto/utils/$address';
+import { $require } from '@dequanto/utils/$require';
+import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
+import { $config } from '@dequanto/utils/$config';
+
+export interface IBlockChainExplorerParams {
+
+    platform?: string
+    ABI_CACHE?: string
+    CONTRACTS?: IContractDetails[]
+    getWeb3?: (platform?: TPlatform) => Web3Client
+    getConfig?: (platform?: TPlatform) => { key: string, host: string, www: string }
+}
 
 export namespace BlockChainExplorerFactory {
 
-    export function create (opts: {
-        ABI_CACHE: string
-        CONTRACTS: IContractDetails[]
-        getWeb3: () => Web3Client
-        getConfig: () => { key: string, host: string }
-    }) {
+
+    type TxFilter = {
+        fromBlockNumber?: number,
+        page?: number,
+        size?: number,
+        sort?: 'asc' | 'desc'
+    }
+
+    export function create (opts: IBlockChainExplorerParams) {
 
         const client = new Client();
 
+        opts = ensureDefaults(opts);
+
         return class implements IBlockChainExplorer {
 
             localDb: IContractDetails[] = opts.CONTRACTS
-            config = opts.getConfig()
+            config = opts.getConfig(this.platform)
 
-            constructor () {
+            constructor (public platform?: TPlatform) {
                 this.getContractAbi = memd.fn.memoize(this.getContractAbi, {
                     trackRef: true,
                     persistance: new memd.FsTransport({
@@ -44,10 +63,9 @@ export namespace BlockChainExplorerFactory {
             async getContractMeta (name: string)
             async getContractMeta (address: string)
             async getContractMeta (q: string): Promise<IContractDetails> {
-                q = q.toLowerCase();
 
+                q = q.toLowerCase();
                 let info = this.localDb.find(x => x.address.toLowerCase() === q || x.name?.toLowerCase() === q);
-
                 return info;
             }
 
@@ -58,19 +76,27 @@ export namespace BlockChainExplorerFactory {
                 }
 
                 let url = `${this.config.host}/api?module=contract&action=getabi&address=${address}&apikey=${this.config.key}`;
-                let abi: string = await client.get(url);
+                let abi: string;
+
+                try {
+                    abi = await client.get(url);
+                } catch (err) {
+                    let addressByByteCode = await this.getSimilarContract(address);
+                    if (addressByByteCode != null) {
+                        $logger.log(`Found similar byte code address: ${addressByByteCode}`);
+                        return this.getContractAbi(addressByByteCode);
+                    }
+                    throw err;
+                }
 
                 let abiJson = JSON.parse(abi);
                 if (params?.implementation) {
                     if (/0x.{64}/.test(params.implementation)) {
-                        let web3 = opts.getWeb3();
+                        let web3 = opts.getWeb3(this.platform);
 
-                        let stat = await web3.getNodeInfos();
-
-                        //-let x = (BigInt($contract.keccak256("eip1967.proxy.implementation")) - 1n).toString(16);
                         let uin256Hex = await web3.getStorageAt(
-                        '0x5a58505a96d1dbf8df91cb21b54419fc36e93fde',
-                        `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
+                            '0x5a58505a96d1dbf8df91cb21b54419fc36e93fde',
+                            `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
                         );
                         let hex = uin256Hex.replace(/0x0+/, '0x');
                         return this.getContractAbi(hex)
@@ -78,17 +104,19 @@ export namespace BlockChainExplorerFactory {
                     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');
+                    let web3 = opts.getWeb3(this.platform);
+                    // (BigInt($contract.keccak256("eip1967.proxy.implementation")) - 1n).toString(16);
+                    let uint256Hex = await web3.getStorageAt(address,`0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`);
+                    if ($address.isEmpty(uint256Hex)) {
+                        // keccak-256 hash of "org.zeppelinos.proxy.implementation"
+                        uint256Hex = await web3.getStorageAt(address, `0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3`);
+                    }
+                    let hex = uint256Hex.replace(/0x0+/, '0x');
                     return this.getContractAbi(hex)
                 }
 
                 if (hasImplementationSlot(abiJson)) {
-                    let web3 = opts.getWeb3();
+                    let web3 = opts.getWeb3(this.platform);
                     let uin256Hex = await web3.readContract({
                         address: address,
                         abi: abiJson,
@@ -99,7 +127,7 @@ export namespace BlockChainExplorerFactory {
                     return this.getContractAbi(hex);
                 }
                 if (hasTargetSlot(abiJson)) {
-                    let web3 = opts.getWeb3();
+                    let web3 = opts.getWeb3(this.platform);
                     let uin256Hex = await web3.readContract({
                         address: address,
                         abi: abiJson,
@@ -122,15 +150,15 @@ export namespace BlockChainExplorerFactory {
                 return Array.isArray(result) ? result[0] : result;
             }
 
-            async getTransactions (addr: TAddress, params?: { fromBlockNumber?: number, page?: number, size?: number, sort?: 'asc' | 'desc' }): Promise<Transaction[]> {
+            async getTransactions (addr: TAddress, params?: TxFilter): Promise<Transaction[]> {
                 return this.loadTxs('txlist', addr, params);
             }
-            async getTransactionsAll (addr: TAddress): Promise<Transaction[]> {
-                return this.loadTxsAll('txlist', addr);
+            async getTransactionsAll (addr: TAddress, params?: TxFilter): Promise<Transaction[]> {
+                return this.loadTxsAll('txlist', addr, params);
             }
 
 
-            async getInternalTransactions (addr: TAddress, params?: { fromBlockNumber?: number, page?: number, size?: number, sort?: 'asc' | 'desc' }): Promise<Transaction[]> {
+            async getInternalTransactions (addr: TAddress, params?: TxFilter): Promise<Transaction[]> {
                 return this.loadTxs('txlistinternal', addr, params);
             }
             async getInternalTransactionsAll (addr: TAddress): Promise<Transaction[]> {
@@ -159,6 +187,26 @@ export namespace BlockChainExplorerFactory {
                 return events;
             }
 
+            async getSimilarContract(address: TAddress) {
+                let url = `${this.config.www}/address/${address}#code`;
+                let html = await client.getHtml(url);
+                let rgx = /This contract matches/ig;
+                let match = rgx.exec(html);
+                if (match == null) {
+                    return null;
+                }
+
+                let rgxAddress = /0x[a-f\d]{40}/g;
+
+                rgxAddress.lastIndex = match.index;
+
+                let matchAddress = rgxAddress.exec(html);
+                if (matchAddress == null) {
+                    return null;
+                }
+                return matchAddress[0];
+            }
+
 
             async loadTxs(type: 'tokentx' | 'txlistinternal' | 'txlist', address: TAddress, params?: {
                 fromBlockNumber?: number,
@@ -180,12 +228,12 @@ export namespace BlockChainExplorerFactory {
                 return txs;
             }
 
-            async loadTxsAll (type: 'tokentx' | 'txlistinternal' | 'txlist', address: TAddress): Promise<Transaction[]> {
+            async loadTxsAll (type: 'tokentx' | 'txlistinternal' | 'txlist', address: TAddress, params?: TxFilter): Promise<Transaction[]> {
 
                 let page = 1;
                 let size = 1000;
                 let out = [] as Transaction[];
-                let fromBlockNumber = null as number;
+                let fromBlockNumber = params?.fromBlockNumber;
                 while(true) {
                     let arr = await this.loadTxs(type, address, { fromBlockNumber, sort: 'asc' });
                     out.push(...arr);
@@ -206,22 +254,75 @@ export namespace BlockChainExplorerFactory {
 function isOpenZeppelinProxy(abi: AbiItem[]) {
     let $interface = ['upgradeTo', 'implementation'];
     return $interface.every(name => {
-        return abi.some(item => item.type === 'function' && item.name === name);
-    })
+        return hasMethod(abi, name);
+    });
 }
 function hasImplementationSlot (abi: AbiItem[]) {
-    let $interface = ['proxyOwner', 'implementation'];
-    return $interface.every(name => {
-        return abi.some(item => item.type === 'function' && item.name === name);
-    })
+    let $required = [ 'implementation' ];
+    let hasRequired = $required.every(name => {
+        return hasMethod(abi, name);
+    });
+    if (hasRequired === false) {
+        return false;
+    }
+    let $some = ['proxyOwner', 'proxyType'];
+    let hasOneOf = $some.some(name => {
+        return hasMethod(abi, name);
+    });
+    if (hasOneOf === false) {
+        return false;
+    }
+    return true;
 }
 function hasTargetSlot (abi: AbiItem[]) {
     let $interface = ['upgrade', 'getTarget'];
     return $interface.every(name => {
-        return abi.some(item => item.type === 'function' && item.name === name);
+        return hasMethod(abi, name);
     })
 }
+function hasMethod (abi: AbiItem[], name: string) {
+    return abi.some(item => item.type === 'function' && item.name === name);
+}
+
+function ensureDefaults (opts: IBlockChainExplorerParams) {
+    opts ??= {};
+
+    let hasNull = opts.ABI_CACHE == null
+        || opts.CONTRACTS == null
+        || opts.getConfig == null
+        || opts.getWeb3 == null;
 
+    if (hasNull === false) {
+        return opts;
+    }
+
+    let platform = opts.platform;
+    $require.notNull(platform, `Generic Blockchain Explorer Config should contain platform name`);
+
+    opts.ABI_CACHE ??= `./cache/${platform}/abis.json`
+    opts.CONTRACTS ??= [];
+    opts.getWeb3 ??= (_) => {
+        return Web3ClientFactory.get(platform);
+    };
+    opts.getConfig ??= () => {
+        let config = $config.get(`blockchainExplorer.${platform}`);
+
+        let mainnet = /(?<mainnet>\w+):/.exec(platform)?.groups?.mainnet;
+        if (mainnet != null) {
+            let mainnetConfig = $config.get(`blockchainExplorer.${mainnet}`);
+            config = {
+                ...(mainnetConfig ?? {}),
+                ...(config ?? {})
+            };
+        }
+        return {
+            key: config?.key,
+            host: config?.host,
+            www: config?.www,
+        };
+    };
+    return opts;
+}
 
 
 class Client {
@@ -231,6 +332,15 @@ class Client {
         return this.getInner(url)
     }
 
+    @memd.deco.queued({ throttle: 1000 / 5 })
+    async getHtml (url: string) {
+        let resp = await axios.get(url);
+        if (resp.status !== 200) {
+            throw new Error(`${url} not loaded with status ${resp.status}.`);
+        }
+        return resp.data;
+    }
+
     async getPaged (url: string) {
         let arr = [];
         let page = 1;

package/src/BlockchainExplorer/BlockChainExplorerProvider.ts

@@ -5,6 +5,9 @@ import { Bscscan } from './Bscscan';
 import { Etherscan } from './Etherscan';
 import { Polyscan } from './Polyscan';
 import { XDaiscan } from '@dequanto/chains/xdai/XDaiscan';
+import { $config } from '@dequanto/utils/$config';
+import { BlockChainExplorerFactory } from './BlockChainExplorerFactory';
+import { Evmscan } from './Evmscan';
 
 export namespace BlockChainExplorerProvider {
     export function get (platform: TPlatform) {
@@ -19,8 +22,15 @@ export namespace BlockChainExplorerProvider {
                 return di.resolve(Arbiscan);
             case 'xdai':
                 return di.resolve(XDaiscan);
+            case 'hardhat':
+                return null;
             default:
+                let cfg = $config.get(`blockchainExplorer.${platform}`);
+                if (cfg != null) {
+                    return Evmscan({ platform });
+                }
                 throw new Error(`Unsupported platform ${platform} for block chain explorer`);
         }
     }
 }
+

package/src/BlockchainExplorer/Bscscan.ts

@@ -16,6 +16,7 @@ export class Bscscan extends BlockChainExplorerFactory.create({
         return {
             key: config?.key,
             host: config?.host,
+            www: config?.www,
         };
     }
 }) {

package/src/BlockchainExplorer/Etherscan.ts

@@ -1,8 +1,8 @@
-import { BlockChainExplorerFactory } from './BlockChainExplorerFactory';
-
+import di from 'a-di';
 import { $config } from '@dequanto/utils/$config';
 import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
-import di from 'a-di';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { BlockChainExplorerFactory } from './BlockChainExplorerFactory';
 
 
 const contracts = $config.get('contracts.eth', [])
@@ -12,11 +12,23 @@ export class Etherscan extends BlockChainExplorerFactory.create({
     getWeb3 () {
         return di.resolve(EthWeb3Client)
     },
-    getConfig () {
-        const config = $config.get('blockchainExplorer.eth');
+    getConfig (platform: TPlatform) {
+        platform ??= 'eth';
+
+        let config = $config.get(`blockchainExplorer.${platform}`);
+
+        let mainnet = /(?<mainnet>\w+):/.exec(platform)?.groups?.mainnet;
+        if (mainnet != null) {
+            let mainnetConfig = $config.get(`blockchainExplorer.${mainnet}`);
+            config = {
+                ...(mainnetConfig ?? {}),
+                ...(config ?? {})
+            };
+        }
         return {
             key: config?.key,
             host: config?.host,
+            www: config?.www,
         };
     }
 }) {

package/src/BlockchainExplorer/Evmscan.ts

@@ -0,0 +1,8 @@
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { BlockChainExplorerFactory } from './BlockChainExplorerFactory';
+
+
+export function Evmscan (options: { platform: TPlatform }) {
+    const ClientConstructor = BlockChainExplorerFactory.create(options);
+    return new ClientConstructor();
+}

package/src/BlockchainExplorer/IBlockChainExplorer.ts

@@ -1,12 +1,13 @@
 import { TAddress } from '@dequanto/models/TAddress';
 import { IContractDetails } from '@dequanto/models/IContractDetails';
-import { Transaction } from 'web3-core';
 import { IAbiProvider } from './IAbiProvider';
+import { type Transaction } from 'web3-core';
+
 
 export interface IBlockChainExplorer extends IAbiProvider {
     localDb: IContractDetails[]
     getContractMeta(q: string): Promise<IContractDetails>;
-    getContractAbi (address: TAddress, opts?: { implementation: string }): Promise<{ abi: string, implementation: TAddress }>
+    getContractAbi (address: TAddress, opts?: { implementation?: string }): Promise<{ abi: string, implementation: TAddress }>
     getContractSource (address: string): Promise<{
         SourceCode: string
         ContractName: string

package/src/BlockchainExplorer/Polyscan.ts

@@ -16,6 +16,7 @@ export class Polyscan extends BlockChainExplorerFactory.create({
         return {
             key: config?.key,
             host: config?.host,
+            www: config?.www,
         };
     }
 }) {

package/src/ChainAccountProvider.ts

@@ -0,0 +1,84 @@
+import memd from 'memd';
+import { TAddress } from './models/TAddress'
+import { TPlatform } from './models/TPlatform'
+import { $config } from './utils/$config'
+import { Wallet } from 'ethers';
+import { $address } from './utils/$address';
+import { $crypto } from './utils/$crypto';
+import { $buffer } from './utils/$buffer';
+import { ChainAccount, IAccount, SafeAccount } from './models/TAccount';
+
+
+export namespace ChainAccountProvider {
+    export function get (platform: TPlatform, name: string): IAccount {
+        let accounts = AccountsConfigProvider.get();
+        let acc: ChainAccount = accounts?.[platform]?.[name];
+        if (acc == null) {
+            throw new Error(`Account not resolved by name: ${name} in ${platform}`);
+        }
+        acc.name = name;
+        acc.platform = platform;
+        return acc;
+    }
+    export function tryGet (mix: string | TAddress, platform?): IAccount {
+        let all = this.getAll();
+
+        let accounts = all.filter(x => ($address.eq(mix, x.address) || x.name == mix));
+        if (accounts.length === 0) {
+            return null;
+        }
+        let acc = accounts[0];
+        return {
+            ... acc,
+            platform: platform ?? acc.platform
+        };
+    }
+    export function getAll (): IAccount[] {
+       return AccountsConfigProvider.get();
+    }
+    export function getAddressFromKey (key: string) {
+        const bytes = $buffer.fromHex(key);
+        const wallet = new Wallet(bytes);
+        return wallet.address;
+    }
+
+    export function generate (opts?: { name?: string, platform?: TPlatform }): ChainAccount {
+        const bytes = $crypto.randomBytes(32);
+        const wallet = new Wallet(bytes);
+        return {
+            ...(opts ?? {}),
+            address: wallet.address,
+            key: wallet.privateKey,
+        };
+    }
+
+    class AccountsConfigProvider {
+        @memd.deco.memoize()
+        static get (): IAccount[] {
+
+            type TDictionary = {
+                [platform: string]: {
+                    [name: string]: ChainAccount | SafeAccount
+                }
+            };
+
+            let accounts: TDictionary | (ChainAccount | SafeAccount)[] = $config.get('accounts');
+            if (accounts == null) {
+                return [];
+            }
+            if (Array.isArray(accounts)) {
+                return accounts;
+            }
+            let out = [];
+            for (let platform in accounts) {
+                for (let name in accounts[platform]) {
+                    let account = accounts[platform][name];
+                    account.name = name;
+                    account.platform = platform as TPlatform;
+                    out.push(account);
+                }
+            }
+            return out;
+        }
+    }
+}