dequanto 0.0.1 → 0.0.7

package/dist/src/utils/$color.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$color_options = exports.$color = void 0;
+const _const_1 = require("./$const");
+let COLOR;
+function $color(str) {
+    if (COLOR == null) {
+        COLOR = _const_1.is_BROWSER
+            ? ColorData.ColorNone
+            : ColorData.ColorAscii;
+    }
+    return painter.paint(str, COLOR);
+}
+exports.$color = $color;
+;
+function $color_options(opts) {
+    COLOR = opts.type === 'none'
+        ? ColorData.ColorNone
+        : ColorData.ColorAscii;
+}
+exports.$color_options = $color_options;
+;
+var ColorData;
+(function (ColorData) {
+    ColorData.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
+    };
+    ColorData.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
+    };
+})(ColorData || (ColorData = {}));
+var painter;
+(function (painter) {
+    function paint(str, colorData) {
+        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;
+    }
+    painter.paint = paint;
+    ;
+    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) {
+        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;
+    }
+})(painter || (painter = {}));

package/dist/src/utils/$config.js

@@ -3,16 +3,76 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.$config = void 0;
 const Config_1 = require("@dequanto/Config");
 const atma_utils_1 = require("atma-utils");
+const $global = typeof global === 'undefined'
+    ? window
+    : global;
 var $config;
 (function ($config) {
+    let envOptions = null;
     function get(path, $default) {
-        let value = (typeof global.app !== 'undefined' ? global.app.config?.$get?.(path) : null)
+        let value = (typeof $global.app !== 'undefined' ? $global.app.config?.$get?.(path) : null)
             ?? (0, atma_utils_1.obj_getProperty)(Config_1.config, path)
-            ?? $default;
-        if (value == null) {
-            //-throw new Error(`Config data is undefined for ${path}`);
+            ?? (0, atma_utils_1.obj_getProperty)(envOptions, path);
+        if (value == null && envOptions == null) {
+            envOptions = reloadEnv();
+            return get(path, $default);
         }
-        return value;
+        return value ?? $default;
     }
     $config.get = get;
+    function set(path, value) {
+        $global.app.config?.$set?.(path, value);
+    }
+    $config.set = set;
+    /**
+     * Reloads dequanto env config from cli ARGUMENTS and DQ_SETTINGS__** environment
+     */
+    function reloadEnv(argv, env) {
+        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('=');
+                    (0, atma_utils_1.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];
+                (0, atma_utils_1.obj_setProperty)(envOptions, path, val);
+            }
+        }
+        return envOptions;
+    }
+    $config.reloadEnv = reloadEnv;
+    function trimQuotes(value) {
+        value = value?.trim() ?? '';
+        let q = /^['"]/.exec(value);
+        if (q) {
+            return value.substring(1, value.length - 1);
+        }
+        return value;
+    }
 })($config = exports.$config || (exports.$config = {}));

package/dist/src/utils/$const.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.is_BROWSER = void 0;
+exports.is_BROWSER = typeof window !== 'undefined' && window.navigator?.userAgent != null;

package/dist/src/utils/$contract.js

@@ -38,6 +38,17 @@ var $contract;
         return logs;
     }
     $contract.extractLogsForAbi = extractLogsForAbi;
+    // 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
+    //     };
+    // }
     function parseLogWithAbi(log, abiItem) {
         let inputs = abiItem.inputs.slice();
         let args = log.topics.slice(1).map((bytes, i) => {
@@ -57,10 +68,17 @@ var $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,
         };
     }
     $contract.parseLogWithAbi = parseLogWithAbi;

package/dist/src/utils/$crypto.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$crypto = void 0;
+class WebCrypto {
+    constructor() {
+        this.crypto = crypto;
+    }
+    randomBytes(size) {
+        let array = new Uint8Array(size);
+        let rnd = this.crypto.getRandomValues(array);
+        return rnd;
+    }
+}
+class WebCryptoPolyfill {
+    constructor() {
+        this.crypto = require('crypto');
+    }
+    randomBytes(size) {
+        const bytes = this.crypto.randomBytes(size);
+        return bytes;
+    }
+}
+exports.$crypto = typeof crypto === "undefined"
+    ? new WebCryptoPolyfill()
+    : new WebCrypto();

package/dist/src/utils/$csv.js

@@ -1,32 +1,19 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$csv = void 0;
-const Papa = __importStar(require("papaparse"));
 var $csv;
 (function ($csv) {
+    class CSV {
+        constructor() {
+            /** Lazy library reference */
+            this.papa = require('papaparse');
+        }
+        parse(csv) {
+            return this.papa.parse(csv);
+        }
+        serialize(params) {
+        }
+    }
     function stringify(data) {
         if (Array.isArray(data.rows) === false) {
             console.error('Rows', data.rows);
@@ -40,7 +27,8 @@ var $csv;
                 }
             });
         }
-        let str = Papa.unparse({
+        let csv = new CSV();
+        let str = csv.serialize({
             fields: data.header,
             data: data.rows
         });
@@ -48,7 +36,8 @@ var $csv;
     }
     $csv.stringify = stringify;
     function parseToObjects(csv, columns, opts) {
-        let result = Papa.parse(csv);
+        let csvParser = new CSV();
+        let result = csvParser.parse(csv);
         let rows = result.data;
         if (opts?.hasHeader === true) {
             rows = rows.slice(1);
@@ -71,7 +60,8 @@ var $csv;
     }
     $csv.parseToObjects = parseToObjects;
     function parseToRows(csv) {
-        let result = Papa.parse(csv);
+        let csvParser = new CSV();
+        let result = csvParser.parse(csv);
         let rows = result.data;
         return rows;
     }

package/dist/src/utils/$date.js

@@ -1,30 +1,6 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$date = exports.DateTool = void 0;
-const Formatter = __importStar(require("atma-formatter"));
 class DateTool {
     constructor(date = new Date()) {
         this.date = date;
@@ -154,7 +130,7 @@ var $date;
         if (typeof date === 'string' || typeof date === 'number') {
             date = parse(date);
         }
-        return Formatter.formatDate(date, format);
+        return Formatter.format(date, format);
     }
     $date.format = format;
     function formatTimespan(ms) {
@@ -493,4 +469,132 @@ var $date;
         return Math.floor(date.getTime() / 1000);
     }
     $date.toUnixTimestamp = toUnixTimestamp;
+    let Formatter;
+    (function (Formatter) {
+        const _cultureInfo = {
+            MONTH: [
+                'January',
+                'February',
+                'March',
+                'April',
+                'May',
+                'June',
+                'July',
+                'August',
+                'September',
+                'October',
+                'November',
+                'December',
+            ],
+            MONTH_SHORT: [
+                'Jan',
+                'Feb',
+                'Mar',
+                'Apr',
+                'May',
+                'June',
+                'July',
+                'Aug',
+                'Sept',
+                'Oct',
+                'Nov',
+                'Dec',
+            ],
+            DAY: [
+                'Sunday',
+                'Monday',
+                'Tuesday',
+                'Wednesday',
+                'Thursday',
+                'Friday',
+                'Saturday',
+            ],
+            DAY_SHORT: [
+                'Mon',
+                'Tues',
+                'Weds',
+                'Thurs',
+                'Fri',
+                'Sat',
+                'Sun',
+            ],
+        };
+        let _date;
+        function format(date, format) {
+            _date = date;
+            return format
+                .replace('Mm', Mm)
+                .replace('MMM', MMM)
+                .replace('MM', MM)
+                .replace('#M', $M)
+                .replace('yyyy', yyyy)
+                .replace('yy', yy)
+                .replace('dd', dd)
+                .replace('#d', $d)
+                .replace('Dd', Dd)
+                .replace('DDD', DDD)
+                .replace('HH', HH)
+                .replace('hh', hh)
+                .replace('#h', $h)
+                .replace('mm', mm)
+                .replace('#m', $m)
+                .replace('ss', ss)
+                .replace('#s', $s);
+        }
+        Formatter.format = format;
+        ;
+        const yyyy = function () {
+            return String(_date.getFullYear());
+        };
+        const yy = function () {
+            return String(_date.getFullYear() % 100);
+        };
+        const $M = function () {
+            return String(_date.getMonth() + 1);
+        };
+        const MM = function () {
+            return pad(_date.getMonth() + 1);
+        };
+        const Mm = function () {
+            return _cultureInfo.MONTH_SHORT[_date.getMonth()];
+        };
+        const MMM = function () {
+            return _cultureInfo.MONTH[_date.getMonth()];
+        };
+        const $d = function () {
+            return String(_date.getDate());
+        };
+        const dd = function () {
+            return pad(_date.getDate());
+        };
+        const Dd = function () {
+            return _cultureInfo.DAY_SHORT[_date.getMonth()];
+        };
+        const DDD = function () {
+            return _cultureInfo.DAY_SHORT[_date.getMonth()];
+        };
+        const $H = function () {
+            return String(_date.getHours());
+        };
+        const HH = function () {
+            return pad(_date.getHours());
+        };
+        const hh = HH;
+        const $h = $H;
+        const $m = function () {
+            return String(_date.getMinutes());
+        };
+        const mm = function () {
+            return pad(_date.getMinutes());
+        };
+        const $s = function () {
+            return String(_date.getSeconds());
+        };
+        const ss = function () {
+            return pad(_date.getSeconds());
+        };
+        function pad(value) {
+            return value > 9 ? value : '0' + value;
+        }
+    })(Formatter || (Formatter = {}));
 })($date = exports.$date || (exports.$date = {}));

package/dist/src/utils/$gas.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$gas = void 0;
+const _bigint_1 = require("@dequanto/utils/$bigint");
+var $gas;
+(function ($gas) {
+    function formatUsed(txData, receipt) {
+        let usage = receipt.gasUsed;
+        let price = BigInt(receipt.effectiveGasPrice ?? txData.gasPrice ?? 1);
+        let priceGwei = _bigint_1.$bigint.toGweiFromWei(price);
+        let totalEth = _bigint_1.$bigint.toEther(BigInt(usage) * price);
+        return `${totalEth}ETH(${usage}gas × ${priceGwei}gwei)`;
+    }
+    $gas.formatUsed = formatUsed;
+})($gas = exports.$gas || (exports.$gas = {}));

package/dist/src/utils/$hex.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$hex = void 0;
+const _buffer_1 = require("./$buffer");
+var $hex;
+(function ($hex) {
+    /**
+     * Adds '00' bytes to the hex string.
+     * @param hex
+     * @param byteSize Min bytes count in the hex string
+     */
+    function padBytes(hex, byteSize, opts) {
+        let length = byteSize * 2;
+        hex = ensure(hex);
+        if (hex.length === length + 2) {
+            return hex;
+        }
+        hex = hex.substring(2)[opts?.padEnd ? 'padEnd' : 'padStart'](length, '0');
+        return `0x${hex}`;
+    }
+    $hex.padBytes = padBytes;
+    /**
+     * Trims '00' bytes from start or end, e.g.  0x68656c6c6f000000 =>  0x68656c6c6f
+     */
+    function trimBytes(hex) {
+        return hex.replace(/^0x(0{2})+/, '').replace(/(0{2})+$/, '');
+    }
+    $hex.trimBytes = trimBytes;
+    function getNumber(hex, byteIndex, bytesCount = 1) {
+        let start = hex.startsWith('0x') ? 2 : 0;
+        let i = start + byteIndex * 2;
+        return parseInt(hex.substring(i, i + 2 * bytesCount), 16);
+    }
+    $hex.getNumber = getNumber;
+    function raw(hex) {
+        return hex.startsWith('0x')
+            ? hex.substring(2)
+            : hex;
+    }
+    $hex.raw = raw;
+    function toHex(value) {
+        switch (typeof value) {
+            case 'string': {
+                if (value.startsWith('0x')) {
+                    return value;
+                }
+                return _buffer_1.$buffer.toHex(_buffer_1.$buffer.fromString(value));
+            }
+            case 'number':
+            case 'bigint':
+                let hex = value.toString(16);
+                return '0x' + hex;
+            case 'boolean':
+                return value ? '0x1' : '0x0';
+        }
+        throw new Error(`Invalid value to convert to hex: ${value}`);
+    }
+    $hex.toHex = toHex;
+    function toHexBuffer(value) {
+        value = toHex(value);
+        if (value.length % 2 === 1) {
+            value = '0x0' + value.substring(2);
+        }
+        return value;
+    }
+    $hex.toHexBuffer = toHexBuffer;
+    /**
+     * Adds `0x` to the start if not present
+     */
+    function ensure(mix) {
+        if (mix.startsWith('0x')) {
+            return mix;
+        }
+        return `0x${mix}`;
+    }
+    $hex.ensure = ensure;
+})($hex = exports.$hex || (exports.$hex = {}));