dequanto 0.0.1

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

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$abiType = void 0;
+const alot_1 = __importDefault(require("alot"));
+var $abiType;
+(function ($abiType_1) {
+    function getTsType($abiType, $abi) {
+        let rgxArray = /\[(?<size>\d+)?\]$/;
+        let isArray = rgxArray.test($abiType);
+        // fix subarrays
+        let rgxSubType = /\[\]\[\d+\]$/;
+        if (rgxSubType.test($abiType)) {
+            $abiType = $abiType.replace(rgxSubType, '');
+        }
+        let abiType = isArray
+            ? $abiType.replace(rgxArray, '')
+            : $abiType;
+        let tsType = AbiTsTypes[abiType];
+        if (tsType == null) {
+            let byRgx = (0, alot_1.default)(AbiTsTypesRgx).map(definition => ({ match: definition.rgx.exec(abiType), definition })).first(x => x.match != null);
+            if (byRgx) {
+                let { match, definition } = byRgx;
+                tsType = definition.fromMatch?.(match) ?? definition.type;
+            }
+        }
+        if (tsType == null && abiType === 'tuple') {
+            let components = $abi?.components;
+            if (components == null) {
+                throw new Error(`Components undefined for tuple ${$abi?.name ?? ''}`);
+            }
+            let fields = components.map(x => {
+                return `${x.name}: ${getTsType(x.type, x)}`;
+            }).join(', ');
+            tsType = `{ ${fields} }`;
+        }
+        if (tsType == null) {
+            throw new Error(`Unknown abi type in return: ${abiType}`);
+        }
+        return isArray
+            ? `${tsType}[]`
+            : `${tsType}`;
+    }
+    $abiType_1.getTsType = getTsType;
+    const AbiTsTypes = {
+        'uint': 'number',
+        'int': 'number',
+        'bool': 'boolean',
+        'bytes': 'TBufferLike',
+        'bytes4': 'TBufferLike',
+        'bytes32': 'TBufferLike',
+        'bytes64': 'TBufferLike',
+        'bytes128': 'TBufferLike',
+        'bytes256': 'TBufferLike',
+        'address': 'TAddress',
+        'string': 'string',
+    };
+    const AbiTsTypesRgx = [
+        {
+            rgx: /u?int(?<bits>\d+)/,
+            fromMatch(match) {
+                let bits = Number(match.groups.bits);
+                if (bits > 64) {
+                    return 'bigint';
+                }
+                return 'number';
+            },
+            type: null,
+        },
+        // {
+        //     rgx: /uint\d+/,
+        //     type: 'bigint',
+        // }
+    ];
+})($abiType = exports.$abiType || (exports.$abiType = {}));

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

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$abiUtils = void 0;
+const abi_1 = require("@ethersproject/abi");
+const _contract_1 = require("./$contract");
+const web3_1 = __importDefault(require("web3"));
+var $abiUtils;
+(function ($abiUtils) {
+    function encodePacked(...args) {
+        return web3_1.default.utils.encodePacked(...args);
+    }
+    $abiUtils.encodePacked = encodePacked;
+    function encode(types, values) {
+        let coder = new abi_1.AbiCoder();
+        return coder.encode(types, values);
+    }
+    $abiUtils.encode = encode;
+    /** Returns complete method/event hash */
+    function getMethodHash(abi) {
+        let types = abi.inputs?.map(serializeMethodSignatureArgumentType) ?? [];
+        let signature = `${abi.name}(${types.join(',')})`;
+        let hash = _contract_1.$contract.keccak256(signature);
+        return hash;
+    }
+    $abiUtils.getMethodHash = getMethodHash;
+    function getMethodSignature(abi) {
+        let types = abi.inputs?.map(serializeMethodSignatureArgumentType) ?? [];
+        let signature = `${abi.name}(${types.join(',')})`;
+        let hash = _contract_1.$contract.keccak256(signature);
+        return hash.substring(0, 10);
+    }
+    $abiUtils.getMethodSignature = getMethodSignature;
+    function serializeMethodSignatureArgumentType(input) {
+        if (input.type === 'tuple') {
+            let types = input.components.map(x => serializeMethodSignatureArgumentType(x));
+            return `(${types.join(',')})`;
+        }
+        return input.type;
+    }
+})($abiUtils = exports.$abiUtils || (exports.$abiUtils = {}));

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$address = void 0;
+var $address;
+(function ($address) {
+    function eq(a1, a2) {
+        return a1?.toUpperCase() === a2?.toUpperCase();
+    }
+    $address.eq = eq;
+    function find(arr, getter, address) {
+        return arr.find(x => eq(getter(x), address));
+    }
+    $address.find = find;
+    function isValid(address) {
+        let rgx = /0x[\dA-F]{40,}/i;
+        return rgx.test(address);
+    }
+    $address.isValid = isValid;
+    function isEmpty(address) {
+        if (address == null || address === '') {
+            return true;
+        }
+        if (/^0x0+$/.test(address)) {
+            return true;
+        }
+        return false;
+    }
+    $address.isEmpty = isEmpty;
+    function expectValid(address, message) {
+        if (isValid(address) === false) {
+            throw new Error(`${address} is invalid: ${message}`);
+        }
+        return address;
+    }
+    $address.expectValid = expectValid;
+    function toBytes32(address) {
+        return address.toLowerCase().substring(2).padStart(32, '0');
+    }
+    $address.toBytes32 = toBytes32;
+    $address.ZERO = '0x0000000000000000000000000000000000000000';
+})($address = exports.$address || (exports.$address = {}));

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$array = void 0;
+var $array;
+(function ($array) {
+    function upsert(arr, x, matcher, opts) {
+        if (arr == null) {
+            return [x];
+        }
+        for (let i = 0; i < arr.length; i++) {
+            if (matcher(arr[i])) {
+                let current = arr[i];
+                if (opts?.patch === true) {
+                    for (let key in x) {
+                        if (x[key] != null) {
+                            current[key] = x[key];
+                        }
+                    }
+                    return arr;
+                }
+                arr.splice(i, 1, x);
+                return arr;
+            }
+        }
+        arr.push(x);
+        return arr;
+    }
+    $array.upsert = upsert;
+    function remove(arr, x) {
+        if (typeof x === 'function') {
+            let removed = [];
+            for (let i = 0; i < arr.length; i++) {
+                if (x(arr[i], i)) {
+                    removed.push(arr[i]);
+                    arr.splice(i, 1);
+                    i--;
+                }
+            }
+            return removed;
+        }
+        let i = arr.indexOf(x);
+        if (i > -1) {
+            return arr.splice(i, 1);
+        }
+    }
+    $array.remove = remove;
+    function replace(arr, item, matcher) {
+        for (let i = 0; i < arr.length; i++) {
+            if (matcher(arr[i], item, i)) {
+                arr[i] = item;
+            }
+        }
+        arr.push(item);
+    }
+    $array.replace = replace;
+    function shuffle(arr) {
+        return arr.sort(() => Math.random() - 0.5);
+    }
+    $array.shuffle = shuffle;
+})($array = exports.$array || (exports.$array = {}));

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

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$bigint = void 0;
+const _is_1 = require("./$is");
+var $bigint;
+(function ($bigint_1) {
+    $bigint_1.ETHER_DECIMALS = 18;
+    $bigint_1.GWEI_DECIMALS = 9;
+    function max(...args) {
+        let max = null;
+        for (let i = 0; i < args.length; i++) {
+            let val = args[i];
+            if (max == null || max < val) {
+                max = val;
+            }
+        }
+        return max;
+    }
+    $bigint_1.max = max;
+    function min(...args) {
+        let min = null;
+        for (let i = 0; i < args.length; i++) {
+            let val = args[i];
+            if (min == null || min > val) {
+                min = val;
+            }
+        }
+        return min;
+    }
+    $bigint_1.min = min;
+    function toBigInt(amount) {
+        if (typeof amount === 'bigint') {
+            return amount;
+        }
+        if (typeof amount === 'string') {
+            amount = Number(amount);
+        }
+        return BigInt(Math.round(amount));
+    }
+    $bigint_1.toBigInt = toBigInt;
+    function ensureWei(amount, decimals) {
+        if (typeof amount === 'number') {
+            return toWei(amount, decimals);
+        }
+        return amount;
+    }
+    $bigint_1.ensureWei = ensureWei;
+    function toWei(amount, decimals = $bigint_1.ETHER_DECIMALS) {
+        let decimalsCount = Number(decimals);
+        if (typeof amount === 'number') {
+            let $exp = 0;
+            while ((amount * 10 ** $exp) % 1 !== 0 && $exp < decimalsCount) {
+                $exp++;
+            }
+            decimalsCount -= $exp;
+            amount *= 10 ** $exp;
+            if (amount % 1 !== 0) {
+                amount = Math.round(amount);
+            }
+        }
+        let $amount = BigInt(amount);
+        let $decimals = BigInt(decimalsCount);
+        return $amount * 10n ** $decimals;
+    }
+    $bigint_1.toWei = toWei;
+    function toWeiFromGwei(amount) {
+        return toWei(amount, $bigint_1.GWEI_DECIMALS);
+    }
+    $bigint_1.toWeiFromGwei = toWeiFromGwei;
+    function toEther(amount, decimals = $bigint_1.ETHER_DECIMALS, round = 100000n) {
+        let $decimals = BigInt(decimals);
+        let $amount = BigInt(amount);
+        let val = $amount * round / 10n ** $decimals;
+        if (val < Number.MAX_SAFE_INTEGER) {
+            return Number(val) / Number(round);
+        }
+        throw new Error(`Ether overflow: ${val}. Decimals: ${decimals}`);
+    }
+    $bigint_1.toEther = toEther;
+    function toEtherSafe(amount, decimals = $bigint_1.ETHER_DECIMALS, round = 100000n) {
+        let $decimals = BigInt(decimals);
+        let $amount = BigInt(amount);
+        let val = $amount * round / 10n ** $decimals;
+        if (val < Number.MAX_SAFE_INTEGER) {
+            return Number(val) / Number(round);
+        }
+        return val / round;
+    }
+    $bigint_1.toEtherSafe = toEtherSafe;
+    function toHex(num) {
+        return `0x${num.toString(16)}`;
+    }
+    $bigint_1.toHex = toHex;
+    function toGweiFromWei(val) {
+        return toEther(val, $bigint_1.GWEI_DECIMALS);
+    }
+    $bigint_1.toGweiFromWei = toGweiFromWei;
+    function toGweiFromEther(val) {
+        return toWei(val, $bigint_1.GWEI_DECIMALS);
+    }
+    $bigint_1.toGweiFromEther = toGweiFromEther;
+    function multWithFloat(bigInt, float) {
+        let $bigint = bigInt;
+        let $number = float;
+        let value = 1n;
+        while (Math.floor($number) !== $number) {
+            $number *= 10;
+            $bigint *= 10n;
+            value *= 100n;
+        }
+        return $bigint * BigInt(Math.floor($number)) / value;
+    }
+    $bigint_1.multWithFloat = multWithFloat;
+    function divToFloat(a, b, precision = 100000n) {
+        _is_1.$is.BigInt(a);
+        _is_1.$is.BigInt(b);
+        let r = (a * precision) / b;
+        if (r < Number.MAX_SAFE_INTEGER) {
+            return Number(r) / Number(precision);
+        }
+        throw new Error(`divToFloat failed by MAX_SAFE_INTEGER result ${r}. ${a}/${b}`);
+    }
+    $bigint_1.divToFloat = divToFloat;
+    function pow(basis, exponent) {
+        let $base = typeof basis === 'number' ? BigInt(Math.round(basis)) : basis;
+        let $exp = typeof exponent === 'number' ? BigInt(exponent) : exponent;
+        return $base ** $exp;
+    }
+    $bigint_1.pow = pow;
+})($bigint = exports.$bigint || (exports.$bigint = {}));

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$block = void 0;
+var $block;
+(function ($block) {
+    function getDate(block) {
+        return new Date(Number(block.timestamp) * 1000);
+    }
+    $block.getDate = getDate;
+})($block = exports.$block || (exports.$block = {}));

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$class = void 0;
+var $class;
+(function ($class) {
+    function curry(entity, extend) {
+        let cloned = Object.assign({}, entity, extend);
+        let proto = Object.getPrototypeOf(entity);
+        Object.setPrototypeOf(cloned, proto);
+        return cloned;
+    }
+    $class.curry = curry;
+})($class = exports.$class || (exports.$class = {}));

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$config = void 0;
+const Config_1 = require("@dequanto/Config");
+const atma_utils_1 = require("atma-utils");
+var $config;
+(function ($config) {
+    function get(path, $default) {
+        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}`);
+        }
+        return value;
+    }
+    $config.get = get;
+})($config = exports.$config || (exports.$config = {}));

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

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$contract = void 0;
+const web3_1 = __importDefault(require("web3"));
+const _abiUtils_1 = require("./$abiUtils");
+const InputDataUtils_1 = require("@dequanto/contracts/utils/InputDataUtils");
+var $contract;
+(function ($contract) {
+    function keccak256(str) {
+        return web3_1.default.utils.keccak256(str);
+    }
+    $contract.keccak256 = keccak256;
+    function normalizeArgs(args) {
+        return args.map(val => {
+            if (val?._isBigNumber) {
+                return BigInt(val.toString());
+            }
+            if (Array.isArray(val)) {
+                return normalizeArgs(val);
+            }
+            return val;
+        });
+    }
+    $contract.normalizeArgs = normalizeArgs;
+    function extractLogsForAbi(tx, abiItem) {
+        let topicHash = _abiUtils_1.$abiUtils.getMethodHash(abiItem);
+        let logs = tx
+            .logs
+            .filter(log => {
+            return log.topics[0] === topicHash;
+        })
+            .map(log => {
+            return parseLogWithAbi(log, abiItem);
+        });
+        return logs;
+    }
+    $contract.extractLogsForAbi = extractLogsForAbi;
+    function parseLogWithAbi(log, abiItem) {
+        let inputs = abiItem.inputs.slice();
+        let args = log.topics.slice(1).map((bytes, i) => {
+            let type = inputs.shift();
+            let val = InputDataUtils_1.InputDataUtils.decode([type], bytes);
+            return {
+                name: type.name,
+                value: val[0]
+            };
+        });
+        if (inputs.length > 0) {
+            let values = InputDataUtils_1.InputDataUtils.decode(inputs, log.data);
+            args.push(...values.map((val, i) => {
+                return {
+                    name: inputs[i].name,
+                    value: val
+                };
+            }));
+        }
+        return {
+            contract: log.address,
+            name: abiItem.name,
+            arguments: args,
+        };
+    }
+    $contract.parseLogWithAbi = parseLogWithAbi;
+})($contract = exports.$contract || (exports.$contract = {}));

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

@@ -0,0 +1,79 @@
+"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) {
+    function stringify(data) {
+        if (Array.isArray(data.rows) === false) {
+            console.error('Rows', data.rows);
+            throw new Error(`To serialize data to csv, it should be an array of rows`);
+        }
+        if (data.rows.length > 0) {
+            data.rows.forEach((row, i) => {
+                if (row != null && Array.isArray(row) === false) {
+                    console.error(`Columns at row ${i} must be an array, got`, row);
+                    throw new Error(`To serialize data to csv, each row must be an array`);
+                }
+            });
+        }
+        let str = Papa.unparse({
+            fields: data.header,
+            data: data.rows
+        });
+        return str;
+    }
+    $csv.stringify = stringify;
+    function parseToObjects(csv, columns, opts) {
+        let result = Papa.parse(csv);
+        let rows = result.data;
+        if (opts?.hasHeader === true) {
+            rows = rows.slice(1);
+        }
+        return rows.map(row => {
+            if (row.length === 0) {
+                return null;
+            }
+            if (row.length === 1 && row[0] === '') {
+                return null;
+            }
+            let obj = {};
+            columns.map((key, i) => {
+                if (key) {
+                    obj[key] = row[i];
+                }
+            });
+            return obj;
+        }).filter(Boolean);
+    }
+    $csv.parseToObjects = parseToObjects;
+    function parseToRows(csv) {
+        let result = Papa.parse(csv);
+        let rows = result.data;
+        return rows;
+    }
+    $csv.parseToRows = parseToRows;
+})($csv = exports.$csv || (exports.$csv = {}));