dequanto 0.1.7 → 0.1.13

package/src/rpc/transports/RpcTransport.ts

@@ -4,6 +4,8 @@ import { WsTransport } from './WsTransport';
 import { TTransport } from './ITransport';
 import { EIP1193Transport, IEip1193Provider } from './compatibility/EIP1193Transport';
 import { Web3Transport } from './compatibility/Web3Transport';
+import { $is } from '@dequanto/utils/$is';
+import { DeferredTransport } from './DeferredTransport';
 
 export namespace RpcTransport {
 
@@ -40,6 +42,9 @@ export namespace RpcTransport {
             return mix;
         }
         if ('web3' in mix && mix.web3 != null) {
+            if ($is.Promise(mix.web3)) {
+                return new DeferredTransport(mix.web3, create);
+            }
             if ('currentProvider' in mix.web3 && 'eth' in mix.web3) {
                 return new Web3Transport(mix.web3);
             }

package/src/rpc/transports/WsTransport.ts

@@ -1,5 +1,5 @@
 import memd from 'memd';
-import WebSocket from './WsTransportIsomorphic'
+import { WebSocketProvider } from './WsTransportIsomorphic'
 import { TTransport } from './ITransport';
 import { MessageBasedTransport } from './MessageBasedTransport';
 import { RpcSubscription } from '../RpcSubscription';
@@ -52,6 +52,7 @@ class WsTransportSingleton extends MessageBasedTransport {
     @memd.deco.memoize({ perInstance: true })
     private async connect() {
         const { url, clientConfig } = this.options
+        const WebSocket = await WebSocketProvider.get();
         const ws = new WebSocket(url, clientConfig ?? {});
 
         const onMessage = ({ data }) => {

package/src/rpc/transports/WsTransportIsomorphic.ts

@@ -1,3 +1,5 @@
+import { $dependency } from '@dequanto/utils/$dependency';
+
 declare var MozWebSocket;
 declare var window;
 
@@ -19,8 +21,12 @@ if (ws == null && typeof window !== 'undefined') {
 if (ws == null && typeof self !== 'undefined') {
     ws = self.WebSocket || (self as any).MozWebSocket
 }
-if (ws == null) {
-    ws = require('ws');
-}
 
-export default ws;
+export namespace WebSocketProvider {
+    export async function get (): Promise<typeof ws> {
+        if (ws != null) {
+            return ws;
+        }
+        return $dependency.load('ws');
+    }
+}

package/src/rpc/transports/compatibility/Web3Transport.ts

@@ -7,12 +7,10 @@ interface Web3 {
     eth
 }
 
-
 export class Web3Transport implements TTransport.Transport {
 
     private provider
 
-
     constructor (private mix: Web3) {
         this.provider = 'currentProvider' in mix ? mix.currentProvider : mix;
     }
@@ -30,6 +28,4 @@ export class Web3Transport implements TTransport.Transport {
     unsubscribe(req: TTransport.Request & { method: 'eth_unsubscribe'; params: [number]; }): Promise<RpcSubscription<any>> {
         throw new Error('Method not implemented.');
     }
-
-
 }

package/src/utils/$dependency.ts

@@ -0,0 +1,19 @@
+/** ESM and CJS Loader */
+
+export namespace $dependency {
+
+    export async function load<T = any> (name: string): Promise<T> {
+        //#if (CJS)
+        const r = require;
+        return Promise.resolve(require(name));
+        //#endif
+
+        //#if (ESM)
+        // @ts-ignore: Conditional import
+        const exp = await import(name);
+        return exp;
+        //#endif
+    }
+
+}
+

package/src/utils/$is.ts

@@ -36,6 +36,9 @@ export namespace $is {
         // Make addresses like `0x0` also valid (assumed zeros)
         return /^0x[a-fA-F0-9]{1,40}$/g.test(val);
     }
+    export function Promise(val): val is Promise<any> {
+        return typeof val === 'object' && val!== null && 'then' in val;
+    }
 
     export function TxHash (val: string | TEth.Hex): boolean {
         if (Hex(val) === false) {

package/src/utils/$logger.ts

@@ -2,6 +2,7 @@ import memd from 'memd';
 import { $color } from './$color';
 import { $date } from './$date';
 import alot from 'alot';
+import { $dependency } from './$dependency';
 
 
 export enum ELogLevel {
@@ -17,7 +18,9 @@ interface ILoggerOptions {
     level?: ELogLevel
 }
 class Logger {
-    private stdcalls = [];
+    private stdCalls = [];
+    private stdOnHold = false;
+    private stdQueue = [];
 
     constructor(private options?: ILoggerOptions) {
         this.options ??= {};
@@ -122,16 +125,36 @@ class Logger {
     }
 
     private print(row: (string | any)[], params: { method: 'log' | 'warn' | 'error', isToast?: boolean }) {
-        if (this.stdcalls[0]?.isToast) {
+        if (params?.isToast) {
+            if (StdToast.isLoaded !== true) {
+                this.stdOnHold = true;
+                StdToast.initialize().then(x => {
+                    let arr = this.stdQueue;
+                    this.stdOnHold = false;
+                    this.stdQueue = [];
+                    arr.map(([row, params]) => {
+                        this.print(row, params);
+                    });
+
+
+                });
+            }
+        }
+        if (this.stdOnHold) {
+            this.stdQueue.push([row, params]);
+            return;
+        }
+
+        if (this.stdCalls[0]?.isToast) {
             // Last print is the toast, clear it
             StdToast.clean();
         }
 
         console[params.method](...row);
 
-        this.stdcalls.unshift(params);
-        if (this.stdcalls.length > 100) {
-            this.stdcalls.splice(50);
+        this.stdCalls.unshift(params);
+        if (this.stdCalls.length > 100) {
+            this.stdCalls.splice(50);
         }
 
     }
@@ -186,7 +209,7 @@ export function l(strings: TemplateStringsArray, ...values: any[]) {
             case 'bigint':
                 break;
             default:
-                // skip all non-value types.
+                // skip colorizing all non-value types.
                 continue;
         }
         args[i - 1] = `${before}${value}${after}`;
@@ -197,20 +220,21 @@ export function l(strings: TemplateStringsArray, ...values: any[]) {
     $logger.log(...args);
 }
 
-class StdToast {
+namespace StdToast {
+
+    let rl: typeof import('readline');
 
-    static clean() {
-        let rl = StdToast.getRl();
+    export let isLoaded = false;
+    export function clean() {
         rl.clearLine(process.stdout, 0);
         rl.cursorTo(process.stdout, 0, null);
 
         rl.moveCursor(process.stdout, 0, -1);
         rl.clearLine(process.stdout, 0);
     }
-
-    @memd.deco.memoize()
-    static getRl() {
+    export async function initialize() {
         /** lazy */
-        return require('readline')
+        rl = await $dependency.load('readline');
+        isLoaded = true;
     }
 }

package/src/utils/$machine.ts

@@ -1,26 +1,28 @@
+import { $dependency } from './$dependency';
 
 
 
 export namespace $machine {
 
     export function id(original: boolean = false): Promise<string> {
-        return new Promise((resolve: Function, reject: Function): Object => {
+        return new Promise(async (resolve: Function, reject: Function): Promise<Object> => {
+            const { exec } = await $dependency.load<typeof import('child_process')>('child_process');
 
-            const { exec } = require('child_process');
-            return exec(getCommand(), {}, (err: any, stdout: any, stderr: any) => {
+            return exec(getCommand(), {}, async (err: any, stdout: any, stderr: any) => {
                 if (err) {
                     return reject(
                         new Error(`Error while obtaining machine id: ${err.stack}`)
                     );
                 }
                 let id: string = extractId(stdout.toString());
-                return resolve(original ? id : hash(id));
+                let result = original ? id : await hash(id);
+                return resolve(result);
             });
         });
     }
 
-    function hash(guid: string): string {
-        const { createHash } = require('crypto');
+    async function hash(guid: string): Promise<string> {
+        const { createHash } = await $dependency.load<typeof import('crypto')>('crypto');
         return createHash('sha256').update(guid).digest('hex');
     }
 

package/tsconfig-src.json

@@ -7,9 +7,10 @@
         },
         "typeRoots": [
             "node_modules/@types",
-            "typings/globals"
+            "typings/globals",
+            "typings"
         ],
-        "types": ["node", "assertion"],
+        "types": ["node", "assertion", "mocha"],
 
         "outDir": "./lib/types",
         "module": "CommonJS",

package/typings/globals/mocha/index.d.ts

@@ -0,0 +1,8 @@
+
+declare module "mocha" {
+
+}
+
+declare namespace Mocha {
+    export type MochaOptions = any;
+}

package/typings/index.d.ts

@@ -3,4 +3,3 @@
 /// <reference path="globals/mask/index.d.ts" />
 /// <reference path="globals/axios/index.d.ts" />
 
-

package/.circleci/config.yml

@@ -1,54 +0,0 @@
-# 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: Build d.ts Types
-          command: npm run build-types
-      - 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

@@ -1,33 +0,0 @@
-# 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 build-types
-      - run: npm run test-node
-      - run: npm publish --provenance --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}

package/.vscode/settings.json

@@ -1,42 +0,0 @@
-{
-    "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

@@ -1,136 +0,0 @@
-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 [];
-        }
-
-    }
-}