dequanto 0.0.1 → 0.1.3

package/.circleci/config.yml

@@ -0,0 +1,51 @@
+# See: https://circleci.com/docs/2.0/configuration-reference
+version: 2.1
+
+orbs:
+  # See the orb documentation here: https://circleci.com/developer/orbs/orb/circleci/browser-tools
+  browser-tools: circleci/browser-tools@1.4.8
+
+
+jobs:
+  build-and-test:
+    # These next lines define a Docker executor: https://circleci.com/docs/2.0/executor-types/
+    # https://circleci.com/developer/images/image/cimg/node
+    docker:
+      - image: cimg/node:20.4.0-browsers
+    steps:
+      - browser-tools/install-firefox
+      - checkout
+      - run:
+          name: NPM Install
+          command: npm install --force
+      - run:
+          name: Build Project
+          command: npm run build
+      - run:
+          name: Launch Server
+          command: npm run server
+          background: true
+      - run:
+          command: sleep 5;
+      - run:
+          name: Launch Web
+          command: sleep 10 && firefox "http://127.0.0.1:5777/utest/"
+          background: true
+      - run:
+          command: sleep 5;
+      - run:
+          name: Run tests
+          command: npm run test
+
+workflows:
+  # Inside the workflow, you provide the jobs you want to run, e.g this workflow runs the build-and-test job above.
+  # CircleCI will run this workflow on every commit.
+  # https://circleci.com/docs/2.0/configuration-reference/#workflows
+  TestRunner:
+    jobs:
+      - build-and-test:
+          filters:
+            branches:
+              ignore:
+                # runs the github action
+                - release

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,32 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  push:
+    branches:
+      - 'release'
+
+jobs:
+  build-test-publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 20
+          registry-url: 'https://registry.npmjs.org'
+          cache: npm
+
+      - run: npm ci
+      - run: npm run build
+      - run: npm run test-node
+      - run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}

package/.vscode/settings.json

@@ -1,11 +1,42 @@
-{
-    "git.ignoreLimitWarning": true,
-    "typescript.tsdk": "node_modules\\typescript\\lib",
-    "files.exclude": {
-        "**/.git": true,
-        "**/.svn": true,
-        "**/.hg": true,
-        "**/dist": true,
-        "**/.DS_Store": true
-    }
-}
+{
+    "git.ignoreLimitWarning": true,
+    "typescript.tsdk": "node_modules\\typescript\\lib",
+    "files.exclude": {
+        "**/.git": true,
+        "**/.svn": true,
+        "**/.hg": true,
+        "**/dist": true,
+        "**/.DS_Store": true
+    },
+    "cSpell.words": [
+        "APPDATA",
+        "Arbiscan",
+        "arbitrum",
+        "bigfloat",
+        "bignumber",
+        "Bscscan",
+        "chainlink",
+        "Daiscan",
+        "Everlog",
+        "Evmscan",
+        "Fetchable",
+        "Flashbot",
+        "Flashbots",
+        "IPFS",
+        "ipns",
+        "mult",
+        "multichain",
+        "multiprotocol",
+        "Pancakeswap",
+        "Polyscan",
+        "Promi",
+        "scure",
+        "secp",
+        "Sushiswap",
+        "Timelock",
+        "timelocks",
+        "Timespan",
+        "tsgen",
+        "xdai"
+    ]
+}

package/actions/chains.act.ts

@@ -0,0 +1,136 @@
+import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client';
+import { EvmWeb3Client } from '@dequanto/clients/EvmWeb3Client';
+import { $date } from '@dequanto/utils/$date';
+import { $http } from '@dequanto/utils/$http';
+import { $logger } from '@dequanto/utils/$logger';
+import { $promise } from '@dequanto/utils/$promise';
+import alot from 'alot';
+import { File } from 'atma-io';
+import { UAction } from 'atma-utest';
+
+UAction.create({
+    async 'update chains' () {
+        let { data: chains } = await $http.get<{
+            chainId: number
+            shortName: string
+            rpc: string[]
+            nativeCurrency: {
+                name: string
+                symbol: string
+                decimals: number
+            }
+        }[]>('https://chainid.network/chains.json');
+
+        // Skip with Keys
+        chains.forEach(chain => {
+            chain.rpc = chain.rpc.filter(x => x.includes('${') === false)
+        });
+
+
+        let arr = chains.map(chain => {
+            return {
+                platform: chain.shortName,
+                chainId: chain.chainId,
+                chainToken: chain.nativeCurrency.symbol,
+                endpoints: chain.rpc.map(url => ({ url })),
+            };
+        });
+
+        arr = arr.filter(x => x.endpoints.length > 0);
+
+        let clients = alot(arr).map(chain => {
+            let client = new EvmWeb3Client({
+                platform: chain.platform,
+                chainId: chain.chainId,
+                endpoints: chain.endpoints
+            });
+            return client;
+        })
+        .toArray();
+
+        let liveUrls = await new EndpointChecker(clients).live();
+
+        arr.forEach(chain => {
+            chain.endpoints = chain.endpoints.filter(endpoint => liveUrls.includes(endpoint.url));
+        });
+
+        let arrWithLiveNodes = arr.filter(x => x.endpoints.length > 0);
+        if (arrWithLiveNodes.length !== arr.length) {
+            $logger.log(`Skipped ${arr.length - arrWithLiveNodes.length} chains because they are not reachable`);
+        }
+
+        await File.writeAsync('./data/chains/chains.json', arrWithLiveNodes);
+    }
+})
+
+class EndpointChecker {
+    constructor (public clients: EvmWeb3Client[]) {
+
+    }
+
+    async live () {
+        return await alot(this.clients)
+            .mapManyAsync((client, i) => {
+                return this.ping(client, i, this.clients.length);
+            })
+            .toArrayAsync();
+    }
+    private async ping (client: EvmWeb3Client, clientIdx, clientsTotal) {
+        try {
+            let infos = await client.getNodeInfos({
+                timeout: 1000,
+                calls: [ 'eth_blockNumber' ]
+            });
+            let block = alot(infos).max(x => x.blockNumber);
+            let nodesStatuses = await alot(infos)
+                .mapAsync(async info => {
+                    let diff = block - info.blockNumber;
+                    let ok = info.status === 'live' && diff < 5 && info.pingMs < 1000;
+
+                    if (ok) {
+                        let wClient = await client.getRpc({ node: { url: info.url } });
+                        let { error, result: blockData } = await $promise.caught(
+                            $promise.timeout(wClient.eth_getBlockByNumber(block, false), 1000)
+                        );
+                        if (error != null) {
+                            ok = false;
+                            info.error = error;
+                        } else if (blockData.timestamp) {
+                            let ageMs = Date.now() - blockData.timestamp * 1000;
+                            if (isNaN(ageMs) || ageMs > $date.parseTimespan('10min')) {
+                                ok = false;
+                                info.error = new Error(`Block AGE: ${$date.formatTimespan(ageMs)}`);
+                            }
+                        }
+                    }
+
+                    let message = `${ok ? '✅' : '⛔'} yellow<${info.pingMs}>ms cyan<${diff}> yellow<${ ok ? '' : info.status }> gray<${info.url}> ${info.error ? info.error.message.substring(0, 50) : ''}`
+                    return {
+                        message,
+                        ok,
+                        url: info.url,
+                    };
+                })
+                .toArrayAsync();
+
+            let totalCount = nodesStatuses.length;
+            let okCount = nodesStatuses.filter(x => x.ok).length;
+            let message = `${client.platform}(gray<${client.chainId}>) ${okCount}/${totalCount} | Progress: ${clientIdx}/${clientsTotal}`;
+            message = okCount > 0? `✅ green<${message}>` : `⛔ red<${message}>`;
+
+            $logger.log(message);
+            nodesStatuses.forEach(x => {
+                $logger.log('        ', x.message);
+            });
+
+
+            return nodesStatuses
+                .filter(x => x.ok)
+                .map(x => x.url);
+        } catch (error) {
+            console.error(`${client.chainId} network failed:`, error.message);
+            return [];
+        }
+
+    }
+}

package/actions/contracts.act.ts

@@ -0,0 +1,178 @@
+import { UAction } from 'atma-utest';
+import { Generator } from '@dequanto/gen/Generator';
+import { Directory, File } from 'atma-io';
+import alot from 'alot';
+import { TAddress } from '@dequanto/models/TAddress';
+import { TAbiItem } from '@dequanto/types/TAbi';
+import { TPlatform } from '@dequanto/models/TPlatform';
+import { HopAddresses } from '@dequanto/bridges/hop/HopAddresses';
+import { IBlockChainExplorer } from '@dequanto/explorer/IBlockChainExplorer';
+import { BlockChainExplorerProvider } from '@dequanto/explorer/BlockChainExplorerProvider';
+import { $platform } from '@dequanto/utils/$platform';
+import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
+
+UAction.create({
+
+    async 'safe'() {
+        const files = await Directory.readFilesAsync('./src/safe/abi/', '**.json');
+        await alot(files)
+            .forEachAsync(async file => {
+                let path = file.uri.toLocalFile();
+
+                let name = file.uri.file.replace(/\.\w+$/, '');
+                let generator = new Generator({
+                    name: name,
+                    source: {
+                        abi: path
+                    },
+                    platform: 'eth',
+                    output: `./src/prebuilt/safe/${name}.ts`
+                });
+                await generator.generate();
+            })
+            .toArrayAsync();
+    },
+    async 'openzeppelin'() {
+        const files = await Directory.readFilesAsync('./node_modules/@openzeppelin/contracts/build/contracts/', '**.json');
+        await alot(files)
+            .forEachAsync(async file => {
+                let path = file.uri.toLocalFile();
+                let json = await file.readAsync<{ abi: TAbiItem[] }>();
+                if (json.abi == null || json.abi.some(x => x.type === 'function') === false) {
+                    return;
+                }
+
+                let name = file.uri.file.replace(/\.\w+$/, '');
+                let generator = new Generator({
+                    name: name,
+                    source: {
+                        abi: path
+                    },
+                    platform: 'eth',
+                    output: `./src/prebuilt/openzeppelin/${name}.ts`,
+                    saveSources: false
+                });
+
+                await generator.generate();
+
+                let content = await file.readAsync<{ abi }>();
+                await File.writeAsync(`./src/prebuilt/openzeppelin/${name}.json`, content.abi);
+            })
+            .toArrayAsync();
+    },
+    async 'openzeppelin compiled' () {
+        let generator = new Generator({
+            name: 'TransparentUpgradeableProxy',
+            source: {
+                path: './node_modules/@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol'
+            },
+            platform: 'eth',
+            output: `./src/prebuilt/openzeppelin/compiled/`,
+            saveSources: false
+        });
+
+        await generator.generate();
+
+
+        //ProxyAdmin: '@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol',
+    },
+    async 'account-abstraction'() {
+        await generate(`erc4337`, `eth`, 'EntryPoint', { abi: `0x5ff137d4b0fdcd49dca30c7cf57e578a026d2789` });
+        await generate(`erc4337`, `eth`, 'SimpleAccount', { path: './test/fixtures/erc4337/samples/SimpleAccount.sol' });
+        await generate(`erc4337`, `eth`, 'SimpleAccountFactory', { path: './test/fixtures/erc4337/samples/SimpleAccountFactory.sol' });
+    },
+    async 'ammV2' () {
+        /* https://docs.pancakeswap.finance/code/smart-contracts/pancakeswap-exchange/factory-v2 */
+        await generate(`amm`, `bsc`, 'AmmFactoryV2Contract', { abi: '0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73' });
+        /* https://docs.pancakeswap.finance/code/smart-contracts/main-staking-masterchef-contract */
+        await generate(`amm`, `bsc`, 'AmmMasterChefV2Contract', { abi: '0x73feaa1eE314F8c655E354234017bE2193C9E24E' });
+        /* https://pancakeswap.info/token/0x8f0528ce5ef7b51152a59745befdd91d97091d2f */
+        /* https://pancakeswap.info/pool/0x7752e1fa9f3a2e860856458517008558deb989e3 */
+        await generate(`amm`, `bsc`, 'AmmPairV2Contract', { abi: '0x7752e1fa9f3a2e860856458517008558deb989e3' });
+        /* https://docs.pancakeswap.finance/code/smart-contracts/pancakeswap-exchange/router-v2 */
+        await generate(`amm`, `bsc`, 'AmmRouterV2Contract', { abi: '0x10ED43C718714eb63d5aA57B78B54704E256024E' });
+        /* https://docs.pancakeswap.finance/code/smart-contracts/cakevault */
+        await generate(`amm`, `bsc`, 'AmmVaultV2Contract', { abi: '0xa80240Eb5d7E05d3F250cF000eEc0891d00b51CC' });
+    },
+    async 'ammV3' () {
+        /* https://info.uniswap.org/#/pools/0x8f8ef111b67c04eb1641f5ff19ee54cda062f163 */
+        await generate(`amm`, `eth`, 'AmmPairV3Contract', { abi: '0x8f8ef111b67c04eb1641f5ff19ee54cda062f163' });
+    },
+    async '1inch' () {
+        await generate(`1inch`, `bsc`, 'OneInchRouterContract', { abi: '0x11111112542d85b3ef69ae05771c2dccff4faa26' });
+    },
+    async 'weth' () {
+        await generate(`weth`, `eth`, 'WETH', { abi: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2' });
+    },
+
+    async 'ens' () {
+        // https://docs.ens.domains/ens-deployments
+        await generate(`ens`, `eth`, 'EnsBaseRegistrar', { abi: '0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85' });
+        await generate(`ens`, `eth`, 'EnsDnsRegistrar', { abi: '0x58774Bb8acD458A640aF0B88238369A167546ef2' });
+        await generate(`ens`, `eth`, 'EnsEthRegistrarController', { abi: '0x253553366Da8546fC250F225fe3d25d0C782303b' });
+        await generate(`ens`, `eth`, 'EnsNameWrapper', { abi: '0xD4416b13d2b3a9aBae7AcD5D6C2BbDBE25686401' });
+        await generate(`ens`, `eth`, 'EnsPublicResolver', { abi: '0x231b0Ee14048e9dCcD1d247744d114a4EB5E8E63' });
+        await generate(`ens`, `eth`, 'EnsRegistry', { abi: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e' });
+        await generate(`ens`, `eth`, 'EnsReverseRegistrar', { abi: '0xa58E81fe9b61B5c3fE2AFD33CF304c454AbFc7Cb' });
+
+    },
+
+    /** HOP protocol was partially implemented, but will take some time to implement bridges packages */
+    async '//hop' () {
+        const GENERATE_FOR = ['l2AmmWrapper', 'l2Bridge', 'l2SaddleSwap'];
+
+        await alot.fromObject(HopAddresses.bridges).forEachAsync(async tokenEntry => {
+
+            let tokenSymbol = tokenEntry.key.replace(/(\w)(\w+)/g, (full, firstLetter, rest) => `${firstLetter}${rest.toLowerCase()}`)
+
+            await alot.fromObject(tokenEntry.value).forEachAsync(async chainEntry => {
+
+                let scan: IBlockChainExplorer;
+                let platform: TPlatform;
+                if (chainEntry.key === 'polygon') {
+                    platform = 'polygon';
+                    scan = BlockChainExplorerProvider.get('polygon');
+                }
+
+                if (scan != null) {
+
+                    await alot.fromObject(chainEntry.value)
+                    .filter(x => GENERATE_FOR.includes(x.key))
+                    .forEachAsync(async contractEntry => {
+
+                        let name = `${tokenSymbol}_${contractEntry.key}Contract`;
+                        let generator = new Generator({
+                            platform: platform,
+                            name: name,
+                            source: {
+                                abi: contractEntry.value,
+                            },
+                            output: `./src/prebuilt/hop/${ $platform.toPath(platform) }/`,
+                            saveSources: false
+                        });
+                        await generator.generate();
+
+                    }).toArrayAsync();
+                }
+            }).toArrayAsync();
+
+        }).toArrayAsync();
+    }
+});
+
+async function generate(
+    outputDir: string,
+    platform: TPlatform,
+    contractName: string,
+    source: ConstructorParameters<typeof Generator>[0]['source'],
+) {
+
+    let generator = new Generator({
+        name: contractName,
+        source: source,
+        platform: platform,
+        output: `./src/prebuilt/${outputDir}/`,
+        saveSources: false
+    });
+    await generator.generate();
+}

package/actions/gen.act.ts

@@ -1,38 +1,38 @@
-import { UAction } from 'atma-utest';
-import { Generator } from '@dequanto/gen/Generator';
-
-// File header example
-
-/**
- * dequanto
- * name: SushiFactoryContractBase
- * platform: polygon
- * source.abi: 0xc35dadb65012ec5796536bd9864ed8773abc74c4
- * output: ./contracts/gen/polygon/
- */
-
-UAction.create({
-    // atma act ./dequanto/actions/gen.act.ts -q genc --path ./some/file.ts
-    async '!genc' () {
-        let app = global.app;
-        let path = app.config.$get('path');
-
-        await Generator.generateForClass(path);
-    },
-    async 'cli' () {
-        let app = global.app;
-        let address = app.config.$get('address');
-        let net = app.config.$get('net') as 'bsc' | 'eth';
-        let name = app.config.$get('name');
-        let opts = {
-            platform: net,
-            name: name,
-            source: {
-                abi: address,
-            },
-            output: `./contracts/${net}/`
-        };
-        let generator = new Generator(opts);
-        await generator.generate();
-    }
-});
+import { UAction } from 'atma-utest';
+import { Generator } from '@dequanto/gen/Generator';
+
+// File header example
+
+/**
+ * dequanto
+ * name: SushiFactoryContractBase
+ * platform: polygon
+ * source.abi: 0xc35dadb65012ec5796536bd9864ed8773abc74c4
+ * output: ./contracts/gen/polygon/
+ */
+
+UAction.create({
+    // atma act ./dequanto/actions/gen.act.ts -q genc --path ./some/file.ts
+    async '!genc' () {
+        let app = global.app;
+        let path = app.config.$get('path');
+
+        await Generator.generateForClass(path);
+    },
+    async 'cli' () {
+        let app = global.app;
+        let address = app.config.$get('address');
+        let net = app.config.$get('net') as 'bsc' | 'eth';
+        let name = app.config.$get('name');
+        let opts = {
+            platform: net,
+            name: name,
+            source: {
+                abi: address,
+            },
+            output: `./contracts/${net}/`
+        };
+        let generator = new Generator(opts);
+        await generator.generate();
+    }
+});

package/actions/logs.act.ts

@@ -0,0 +1,7 @@
+import { UAction } from 'atma-utest';
+
+UAction.create({
+    async 'get logs' () {
+
+    }
+})