dequanto 0.0.1 → 0.0.7

package/src/utils/$bigint.ts

@@ -1,4 +1,5 @@
 import { $is } from './$is';
+import { $require } from './$require';
 
 export namespace $bigint {
 
@@ -84,7 +85,20 @@ export namespace $bigint {
         return val / round;
     }
 
-    export function toHex (num: bigint) {
+    export function toHex (num: string | bigint | number) {
+        if (num == null) {
+            return '0x0'
+        };
+        if (typeof num === 'string') {
+            if (num.startsWith('0x')) {
+                return num;
+            }
+            try {
+                num = BigInt(num);
+            } catch (error) {
+                throw new Error(`Invalid BigInt ${num}`)
+            }
+        }
         return `0x${num.toString(16)}`;
     }
 
@@ -108,8 +122,8 @@ export namespace $bigint {
     }
 
     export function divToFloat (a: bigint, b: bigint, precision = 100_000n): number {
-        $is.BigInt(a);
-        $is.BigInt(b);
+        $require.BigInt(a);
+        $require.BigInt(b);
 
         let r = (a * precision) / b;
         if (r < Number.MAX_SAFE_INTEGER) {
@@ -124,4 +138,43 @@ export namespace $bigint {
 
         return $base ** $exp;
     }
+
+    export function sign(value: bigint) {
+        if (value > 0n) {
+            return 1n;
+        }
+        if (value < 0n) {
+            return -1n;
+        }
+        return 0n;
+    }
+
+    export function abs(value: bigint) {
+        if (sign(value) === -1n) {
+            return -value;
+        }
+        return value;
+    }
+
+    export function sqrt(value: bigint) {
+        return rootNth(value);
+    }
+
+    function rootNth(value: bigint, k = 2n) {
+        if (value < 0n) {
+            throw Error(`Sqrt of ${value} is not allowed`);
+        }
+
+        let o = 0n;
+        let x = value;
+        let limit = 100;
+
+        while (x ** k !== k && x !== o && --limit) {
+            o = x;
+            x = ((k - 1n) * x + value / x ** (k - 1n)) / k;
+        }
+        return x;
+    }
+
+
 }

package/src/utils/$block.ts

@@ -1,7 +1,20 @@
-import { BlockTransactionBase } from 'web3-eth'
+import di from 'a-di';
+import { BlockDateResolver } from '@dequanto/blocks/BlockDateResolver';
+import type { Web3Client } from '@dequanto/clients/Web3Client';
 
 export namespace $block {
     export function getDate(block: { timestamp: string | number }) {
         return new Date(Number(block.timestamp) * 1000);
     }
+
+    export async function ensureNumber(mix: number | Date, client: Web3Client): Promise<number> {
+        if (typeof mix === 'number') {
+            return mix;
+        }
+        if (mix instanceof Date) {
+            let dateResolver = di.resolve(BlockDateResolver, client)
+            return await dateResolver.getBlockNumberFor(mix);
+        }
+        throw new Error(`Invalid getBlockNumber param: ${mix}`);
+    }
 }

package/src/utils/$bloom.ts

@@ -0,0 +1,43 @@
+import { $contract } from './$contract';
+import { $hex } from './$hex';
+
+export namespace $bloom {
+    export function check (bloomHex: string, hex: string) {
+
+        let masks = LogsBloom.getBits(hex);
+        let matched = masks.every((byte, i) => {
+            let b = $hex.getNumber(bloomHex, byte.index);
+            let has = (b | byte.mask) === b;
+            return has;
+        });
+        return matched;
+    }
+}
+
+
+namespace LogsBloom {
+
+    export function getBits (topicHash: string) {
+        let hashBuf = getHashBuf(topicHash);
+
+        let byte1Mask = 1 << ($hex.getNumber(hashBuf, 1) & 0x7);
+        let byte2Mask = 1 << ($hex.getNumber(hashBuf, 3) & 0x7);
+        let byte3Mask = 1 << ($hex.getNumber(hashBuf, 5) & 0x7);
+
+        const bloomLength = 256;
+        let byte1Pos = bloomLength - (($hex.getNumber(hashBuf, 0, 2) & 0x7FF) >> 3) - 1;
+        let byte2Pos = bloomLength - (($hex.getNumber(hashBuf, 2, 2) & 0x7FF) >> 3) - 1;
+        let byte3Pos = bloomLength - (($hex.getNumber(hashBuf, 4, 2) & 0x7FF) >> 3) - 1;
+
+        return [
+            { index: byte1Pos, mask: byte1Mask },
+            { index: byte2Pos, mask: byte2Mask },
+            { index: byte3Pos, mask: byte3Mask },
+        ]
+    }
+
+    export function getHashBuf (topicHash: string) {
+        let hash = $contract.keccak256($hex.ensure(topicHash));
+        return hash;
+    }
+}

package/src/utils/$buffer.ts

@@ -0,0 +1,114 @@
+import { is_NODE } from 'atma-utils';
+import { type Bytes } from 'ethers';
+
+interface IBufferUtils {
+    fromHex (hex: string): Bytes
+    toHex (buffer: Bytes): string
+
+    fromString (string: string, encoding?: BufferEncoding): Bytes
+    toString (buffer: Bytes, encoding?: BufferEncoding): string
+
+    concat (buffers: Bytes[]): Bytes
+}
+
+export type TBytes = Bytes;
+
+
+
+class NodeBufferUtils implements IBufferUtils {
+    fromString(str: string, encoding?: BufferEncoding): Bytes {
+        return Buffer.from(str, encoding ?? 'utf8');
+    }
+    toString(buffer: Buffer, encoding?: BufferEncoding): string {
+        return buffer.toString(encoding);
+    }
+    fromHex(hex: string): Bytes {
+        return Buffer.from(utils.normalizeHex(hex), 'hex');
+    }
+    toHex(buffer: Buffer): string {
+        let hex = (buffer as Buffer).toString('hex');
+        return `0x${hex}`;
+    }
+
+    concat (buffers: Buffer[]) {
+        return Buffer.concat(buffers);
+    }
+}
+
+const HEX_CHARS = "0123456789abcdef";
+const HEX_DIGITS = {
+    0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, a: 10, b: 11, c: 12, d: 13, e: 14, f: 15, A: 10, B: 11, C: 12, D: 13, E: 14, F: 15
+  };
+
+class WebBufferUtils implements IBufferUtils {
+    fromString(string: string, encoding?: string): Bytes {
+        if (encoding != null && /utf\-?8/.test(encoding) === false) {
+            throw new Error(`Only UTF8 Encoding supported`);
+        }
+        return new TextEncoder().encode(string);
+    }
+    toString(buffer: Uint8Array, encoding?: BufferEncoding): string {
+        if (encoding != null && /utf\-?8/.test(encoding) === false) {
+            throw new Error(`Only UTF8 Encoding supported`);
+        }
+        return new TextDecoder().decode(buffer);
+    }
+    fromHex(hex: string): Uint8Array {
+        hex = utils.normalizeHex(hex);
+
+        let bytes = new Uint8Array(Math.floor(hex.length / 2));
+        let i = 0;
+        for (; i < bytes.length; i++) {
+            const a = HEX_DIGITS[hex[i * 2]];
+            const b = HEX_DIGITS[hex[i * 2 + 1]];
+            if (a == null || b == null) {
+              break;
+            }
+            bytes[i] = (a << 4) | b;
+          }
+          return i === bytes.length
+            ? bytes
+            : bytes.slice(0, i);
+    }
+    toHex(buffer: Uint8Array): string {
+        let hex = '';
+        for (let i = 0; i < buffer.length; i++) {
+            let b = buffer[i];
+            hex += HEX_CHARS[b >> 4] + HEX_CHARS[b & 15];
+        }
+        return '0x' + hex;
+    }
+
+    concat (buffers: Uint8Array[]) {
+        let size = buffers.reduce((a, x) => a + x.length, 0);
+        let buffer = new Uint8Array(size);
+        let offset = 0;
+        for (let i = 0; i < buffers.length; i++) {
+            let buf = buffers[i];
+            buffer.set(buf, offset);
+            offset += buf.length;
+        }
+        return buffer;
+    }
+}
+
+namespace utils {
+    export function normalizeHex (hex: string) {
+        if (hex.startsWith('0x')) {
+            hex = hex.substring(2);
+        }
+        if (hex.length % 2 !== 0) {
+            throw new Error(`Not valid hex buffer. Char count not even: ${hex}`);
+        }
+        if (/^[\da-f]+$/i.test(hex) === false) {
+            throw new Error(`Not valid hex buffer. Invalid char in ${hex}`);
+        }
+        return hex;
+    }
+}
+
+
+export const $buffer: IBufferUtils = is_NODE
+    ? new NodeBufferUtils()
+    : new WebBufferUtils()
+    ;

package/src/utils/$cli.ts

@@ -0,0 +1,16 @@
+export namespace $cli {
+
+    export function getParamValue(flag: string, parameters?: any): string | null {
+        if (parameters != null && parameters[flag] != null) {
+            return parameters[flag];
+        }
+        let args = process.argv;
+        for (let i = 0; i < args.length - 1; i++) {
+            let key = args[i].replace(/^\-+/, '');
+            if (key === flag) {
+                return args[i + 1];
+            }
+        }
+        return null;
+    }
+}

package/src/utils/$color.ts

@@ -0,0 +1,211 @@
+import { is_BROWSER } from './$const';
+
+
+let COLOR: typeof ColorData.ColorAscii;
+
+export function $color (str: string) {
+    if (COLOR == null) {
+        COLOR = is_BROWSER
+            ? ColorData.ColorNone
+            : ColorData.ColorAscii;
+    }
+    return painter.paint(str, COLOR);
+};
+
+export function $color_options(opts: { type: 'none' | 'ascii' }) {
+    COLOR = opts.type === 'none'
+        ? ColorData.ColorNone
+        : ColorData.ColorAscii
+};
+
+namespace ColorData {
+
+    export const ColorAscii = {
+        type: 'ascii',
+        START: '\u001b[',
+        END: '\u001b[0m',
+
+        value: {
+            red: '31m',
+            green: '32m',
+            yellow: '33m',
+            blue: '34m',
+            magenta: '35m',
+            cyan: '36m',
+            white: '37m',
+            black: '30m',
+
+            gray: '90m',
+
+            bg_black: '40m',
+            bg_red: '41m',
+            bg_green: '42m',
+            bg_yellow: '43m',
+            bg_blue: '44m',
+            bg_magenta: '45m',
+            bg_cyan: '46m',
+            bg_white: '47m',
+
+            bold: '1m',
+            italic: '3m',
+            underline: '4m',
+            inverse: '7m'
+        },
+        start (key) {
+            return this.START + this.value[key];
+        },
+        rgx_search: null as RegExp
+    };
+
+    export const ColorNone = {
+        type: 'none',
+        END : '',
+        START : '',
+        value: {
+            red: '',
+            green: '',
+            yellow: '',
+            blue: '',
+            magenta: '',
+            cyan: '',
+            white: '',
+            black: '',
+
+            gray: '',
+
+            bg_black: '',
+            bg_red: '',
+            bg_green: '',
+            bg_yellow: '',
+            bg_blue: '',
+            bg_magenta: '',
+            bg_cyan: '',
+            bg_white: '',
+
+            bold: '',
+            italic: '',
+            underline: '',
+            inverse: ''
+        },
+        start: function(key){
+            return '';
+        },
+        rgx_search: null as RegExp
+    };
+}
+
+
+namespace painter {
+
+    export function paint(str: string, colorData: typeof ColorData['ColorAscii']) {
+
+        prepairColor(colorData);
+        colorData.rgx_search.lastIndex = 0;
+
+        var match,
+            key,
+            end,
+            doRenew = colorData.type === 'ascii',
+            stack = doRenew && [] || null,
+            txt
+            ;
+
+        var out = '', last = 0;
+        while (1) {
+            match = colorData.rgx_search.exec(str);
+            if (match == null)
+                break;
+
+            key = match[1];
+            if (colorData.value[key] == null)
+                continue;
+
+            var index = match.index,
+                bound = index + match[0].length,
+                head, txt;
+
+            if (last !== index)
+                out += createRange(str, last, index, colorData);
+
+
+            end = index_End(str, bound);
+            last = end + 1;
+
+            if (end === -1) {
+                out += createRange(str, index, end, colorData);
+                continue;
+            }
+
+            head = colorData.start(key);
+            txt = str.substring(bound, end);
+            txt = paint(txt, colorData);
+
+            out += head
+                + txt
+                + colorData.END
+                + (doRenew ? stack_renew(stack, end, colorData) : '')
+                ;
+
+            if (doRenew)
+                stack.push({ end: end, key: key });
+
+            colorData.rgx_search.lastIndex = end + 1;
+        }
+
+        if (last < str.length) {
+            out += createRange(str, last, str.length, colorData);
+        }
+
+        return out;
+    };
+
+    function createRange(str, start, end, ColorData) {
+        var txt = str.substring(start, end);
+        if (ColorData.decorator)
+            return ColorData.decorator(txt);
+
+        return txt;
+    }
+    function index_End(str, start) {
+        var count = 1,
+            imax = str.length,
+            i = start,
+            c;
+        for (; i < imax; i++) {
+            c = str.charCodeAt(i);
+
+            if (c === 60 /* < */)
+                count++;
+            if (c === 62 /* > */)
+                count--;
+            if (count === 0)
+                return i;
+        }
+        return -1;
+    }
+    function stack_renew(stack, index, ColorData) {
+        var str = '',
+            imax = stack.length,
+            i = -1, x;
+        while (++i < imax) {
+            x = stack[i];
+
+            if (x.end < index)
+                continue;
+            str += ColorData.start(x.key);
+        }
+        return str;
+    }
+    function prepairColor(colorData: typeof ColorData['ColorAscii']) {
+        if (colorData.rgx_search == null) {
+            var str = '(';
+            for (var key in colorData.value) {
+                str += str === '(' ? key : '|' + key;
+            }
+
+            str += ')<';
+            colorData.rgx_search = new RegExp(str, 'g');
+        }
+        return colorData;
+    }
+}

package/src/utils/$config.ts

@@ -1,16 +1,79 @@
 import { config } from '@dequanto/Config';
-import { obj_getProperty } from 'atma-utils';
-
-declare let global;
+import { obj_getProperty, obj_setProperty } from 'atma-utils';
 
+const $global = typeof global === 'undefined'
+    ? window
+    : global;
 export namespace $config {
+
+    let envOptions = null;
+
     export function get <T = any> (path: string, $default?: T): T {
-        let value = (typeof global.app !== 'undefined' ? global.app.config?.$get?.(path) : null)
+        let value = (typeof $global.app !== 'undefined' ? $global.app.config?.$get?.(path) : null)
             ?? obj_getProperty(config, path)
-            ?? $default;
+            ?? obj_getProperty(envOptions, path);
+
+        if (value == null && envOptions == null) {
+            envOptions = reloadEnv();
+            return get(path, $default);
+        }
+        return value ?? $default;
+    }
+
+    export function set <T = any> (path: string, value: T) {
+        $global.app.config?.$set?.(path, value);
+    }
 
-        if (value == null) {
-            //-throw new Error(`Config data is undefined for ${path}`);
+    /**
+     * Reloads dequanto env config from cli ARGUMENTS and DQ_SETTINGS__** environment
+     */
+    export function reloadEnv(argv?: string[], env?: { [key: string]: string }) {
+
+        if (argv == null && typeof process !== 'undefined' && process.argv) {
+            argv = process.argv;
+        }
+        if (env == null && typeof process !== 'undefined' && process.env) {
+            env = process.env;
+        }
+
+        envOptions = {};
+        if (argv != null) {
+            for (let i = 0; i < argv.length; i++) {
+                let key = argv[i];
+                let value = argv[i + 1];
+                if (key.startsWith('--config=')) {
+                    value = key.replace('--config=', '');
+                    key = '--config';
+                }
+                if (key === '--config') {
+                    value = trimQuotes(value);
+                    if (value === '') {
+                        continue;
+                    }
+                    let [ path, val ] = value.split('=');
+
+                    obj_setProperty(envOptions, path.trim(), val.trim());
+                    i++;
+                }
+            }
+        }
+        if (env != null) {
+            for (let key in env) {
+                if (/DQ_/i.test(key) === false) {
+                    continue;
+                }
+                let path = key.replace(/^dq_/i, '').replace(/__/g, '.').toLowerCase();
+                let val = env[key];
+                obj_setProperty(envOptions, path, val);
+            }
+        }
+        return envOptions;
+    }
+    function trimQuotes(value: string): string {
+        value = value?.trim() ?? '';
+        let q = /^['"]/.exec(value);
+        if (q) {
+            return value.substring(1, value.length - 1);
         }
         return value;
     }

package/src/utils/$const.ts

@@ -0,0 +1 @@
+export const is_BROWSER = typeof window !== 'undefined' && window.navigator?.userAgent != null;

package/src/utils/$contract.ts

@@ -1,5 +1,5 @@
 import Web3 from 'web3';
-import { AbiItem } from 'web3-utils';
+import { type AbiItem } from 'web3-utils';
 import { Log, TransactionReceipt } from 'web3-core';
 import { $abiUtils } from './$abiUtils';
 import { InputDataUtils } from '@dequanto/contracts/utils/InputDataUtils';
@@ -34,6 +34,17 @@ export namespace $contract {
             })
         return logs;
     }
+    // export function formatLogForAbi (log: ITxLogItem) {
+    //     let params = log.arguments.reduce((aggr, arg) => {
+    //         aggr[arg.name] = arg.value;
+    //         return aggr;
+    //     }, {});
+    //     return {
+    //         contract: log.contract,
+    //         arguments: log.arguments,
+    //         ...params
+    //     };
+    // }
 
     export function parseLogWithAbi(log: Log, abiItem: AbiItem): ITxLogItem {
         let inputs = abiItem.inputs.slice();
@@ -57,11 +68,18 @@ export namespace $contract {
                 };
             }));
         }
+        let params = args.reduce((aggr, arg) => {
+            aggr[arg.name] = arg.value;
+            return aggr;
+        }, {});
 
         return {
-            contract: log.address,
-            name: abiItem.name,
+            blockNumber: log.blockNumber,
+            transactionHash: log.transactionHash,
+            address: log.address,
+            event: abiItem.name,
             arguments: args,
+            params: params,
         };
     }
 }

package/src/utils/$crypto.ts

@@ -0,0 +1,33 @@
+import { type BytesLike } from 'ethers';
+
+
+interface ICrypto {
+    randomBytes(size: number): BytesLike;
+}
+
+
+
+class WebCrypto implements ICrypto {
+    crypto = crypto;
+
+    randomBytes(size: number) {
+        let array = new Uint8Array(size);
+        let rnd = this.crypto.getRandomValues(array);
+        return rnd;
+    }
+}
+
+class WebCryptoPolyfill implements ICrypto {
+    crypto = require('crypto');
+
+    randomBytes(size: number) {
+        const bytes = this.crypto.randomBytes(size);
+        return bytes;
+    }
+}
+
+
+export const $crypto: ICrypto = typeof crypto === "undefined"
+    ? new WebCryptoPolyfill()
+    : new WebCrypto()
+    ;