dequanto 0.0.1 → 0.0.7

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

@@ -5,8 +5,89 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$abiType = void 0;
 const alot_1 = __importDefault(require("alot"));
+const _require_1 = require("./$require");
 var $abiType;
 (function ($abiType_1) {
+    function getTsTypeFromDefinition(type) {
+        type = type.trim();
+        let rgxArray = /\[(?<size>\d+)?\]$/;
+        let isArray = rgxArray.test(type);
+        if (isArray) {
+            let baseType = array.getBaseType(type);
+            let baseTsType = getTsTypeFromDefinition(baseType);
+            let match = rgxArray.exec(type);
+            return `${baseTsType}${match[0]}`;
+        }
+        if (type.startsWith('(')) {
+            let entries = [];
+            for (let i = 1; i < type.length; i++) {
+                i = Parse.skipWhitespace(type, i);
+                let c = type[i];
+                let start = i;
+                let tsTypeEnd;
+                if (c === '(') {
+                    i = 1 + Parse.goToClosing(type, i + 1, c);
+                    tsTypeEnd = i;
+                }
+                else if (c === 'm' && type.substring(i, i + 'mapping'.length) === 'mapping') {
+                    i = i + 'mapping'.length;
+                    i = Parse.skipWhitespace(type, i);
+                    let c = type[i];
+                    if (c !== '(') {
+                        throw new Error(`Expect "(" after the mapping keyword. Got ${type.substring(i, i + 10)} ...`);
+                    }
+                    i = 1 + Parse.goToClosing(type, i + 1, c);
+                    tsTypeEnd = i;
+                }
+                else {
+                    i = Parse.goToTypeBoundary(type, i);
+                    tsTypeEnd = i;
+                }
+                i = Parse.skipWhitespace(type, i);
+                c = type[i];
+                if (c === '[') {
+                    i = 1 + Parse.goToClosing(type, i + 1, c);
+                    tsTypeEnd = i;
+                }
+                let solType = type.substring(start, i);
+                let tsType = getTsTypeFromDefinition(solType);
+                let name = null;
+                i = Parse.skipWhitespace(type, i);
+                c = type[i];
+                if (/[\w_$]/.test(c)) {
+                    start = i;
+                    i = Parse.goToTypeBoundary(type, i);
+                    name = type.substring(start, i);
+                }
+                entries.push({ ts: tsType, name: name });
+                i = Parse.skipWhitespace(type, i);
+                c = type[i];
+                if (c === ')') {
+                    break;
+                }
+                if (c === ',') {
+                    i++;
+                    continue;
+                }
+                console.log(`Invalid character starting at: ${type.substring(i)}`);
+            }
+            let isArray = entries.every(x => x.name == null);
+            if (isArray) {
+                return `[ ${entries.map(x => x.ts).join(', ')} ]`;
+            }
+            let keys = entries.map(x => `${x.name}: ${x.ts}`).join(', ');
+            return `{ ${keys} }`;
+        }
+        if (type.startsWith('mapping')) {
+            let valueType = $abiType.mapping.getValueType(type);
+            let keyType = $abiType.mapping.getKeyType(type);
+            let keyTsType = getTsTypeFromDefinition(keyType);
+            let valueTsType = getTsTypeFromDefinition(valueType);
+            return `Record<${keyTsType}, ${valueTsType}>`;
+        }
+        return getTsType(type);
+    }
+    $abiType_1.getTsTypeFromDefinition = getTsTypeFromDefinition;
     function getTsType($abiType, $abi) {
         let rgxArray = /\[(?<size>\d+)?\]$/;
         let isArray = rgxArray.test($abiType);
@@ -37,14 +118,62 @@ var $abiType;
             tsType = `{ ${fields} }`;
         }
         if (tsType == null) {
-            throw new Error(`Unknown abi type in return: ${abiType}`);
+            throw new Error(`Unknown abi type in return: "${abiType}"`);
         }
         return isArray
             ? `${tsType}[]`
             : `${tsType}`;
     }
     $abiType_1.getTsType = getTsType;
+    ;
+    let array;
+    (function (array) {
+        // uint256[2] bytes32[] ...
+        function getBaseType(arrayType) {
+            let baseType = arrayType.replace(/\[\d*\]\s*$/, '');
+            _require_1.$require.notEq(baseType, arrayType, `${arrayType} is not valid array declaration`);
+            return baseType;
+        }
+        array.getBaseType = getBaseType;
+        function getLength(arrayType) {
+            let match = /\[(?<len>\d+)?\]$/.exec(arrayType);
+            _require_1.$require.notNull(match, `${arrayType} is not valid array declaration`);
+            return Number(match.groups.len ?? Infinity);
+        }
+        array.getLength = getLength;
+    })(array = $abiType_1.array || ($abiType_1.array = {}));
+    let mapping;
+    (function (mapping) {
+        function getKeyType(mappingType) {
+            let mid = mappingType.indexOf('=>');
+            _require_1.$require.True(mid > -1, `Invalid mapping type: ${mappingType}`);
+            let str = mappingType.substring(0, mid);
+            return str.replace(/mapping\s*\(/, '').trim();
+        }
+        mapping.getKeyType = getKeyType;
+        function getValueType(mappingType) {
+            let mid = mappingType.indexOf('=>');
+            _require_1.$require.True(mid > -1, `Invalid mapping type: ${mappingType}`);
+            let closed = 0;
+            for (let i = mid + 2; i < mappingType.length; i++) {
+                let c = mappingType[i];
+                if (c === '(') {
+                    closed++;
+                    continue;
+                }
+                if (c === ')') {
+                    closed -= 1;
+                    if (closed === -1) {
+                        return mappingType.substring(mid + 2, i).trim();
+                    }
+                }
+            }
+            throw new Error(`Mapping value was not extracted from ${mappingType}`);
+        }
+        mapping.getValueType = getValueType;
+    })(mapping = $abiType_1.mapping || ($abiType_1.mapping = {}));
     const AbiTsTypes = {
+        'enum': 'number',
         'uint': 'number',
         'int': 'number',
         'bool': 'boolean',
@@ -59,9 +188,9 @@ var $abiType;
     };
     const AbiTsTypesRgx = [
         {
-            rgx: /u?int(?<bits>\d+)/,
+            rgx: /u?int(?<bits>\d+)?/,
             fromMatch(match) {
-                let bits = Number(match.groups.bits);
+                let bits = Number(match.groups.bits ?? 256);
                 if (bits > 64) {
                     return 'bigint';
                 }
@@ -69,9 +198,61 @@ var $abiType;
             },
             type: null,
         },
+        {
+            rgx: /bytes(?<bits>\d+)?/,
+            fromMatch(match) {
+                return 'TBufferLike';
+            },
+            type: null,
+        },
         // {
         //     rgx: /uint\d+/,
         //     type: 'bigint',
         // }
     ];
 })($abiType = exports.$abiType || (exports.$abiType = {}));
+var Parse;
+(function (Parse) {
+    function skipWhitespace(str, _i) {
+        let i = _i;
+        for (; i < str.length; i++) {
+            if (str.charCodeAt(i) > 32) {
+                return i;
+            }
+        }
+        return i;
+    }
+    Parse.skipWhitespace = skipWhitespace;
+    function goToClosing(str, startI, openChar, closeChar) {
+        closeChar = closeChar ?? CLOSE_CHARS[openChar];
+        let count = 1;
+        for (let i = startI; i < str.length; i++) {
+            if (str[i] === openChar) {
+                count++;
+            }
+            if (str[i] === closeChar) {
+                count--;
+            }
+            if (count === 0) {
+                return i;
+            }
+        }
+        throw new Error(`Unmatched closing chars ${openChar} ${closeChar} in ${str}`);
+    }
+    Parse.goToClosing = goToClosing;
+    const CLOSE_CHARS = {
+        '[': ']',
+        '(': ')'
+    };
+    function goToTypeBoundary(type, i) {
+        let rgx = /[\w_$]/;
+        for (; i < type.length; i++) {
+            if (rgx.test(type[i])) {
+                continue;
+            }
+            break;
+        }
+        return i;
+    }
+    Parse.goToTypeBoundary = goToTypeBoundary;
+})(Parse || (Parse = {}));

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

@@ -4,9 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (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"));
+const ethers_1 = require("ethers");
+const _contract_1 = require("./$contract");
+const _abiParser_1 = require("./$abiParser");
 var $abiUtils;
 (function ($abiUtils) {
     function encodePacked(...args) {
@@ -14,25 +15,73 @@ var $abiUtils;
     }
     $abiUtils.encodePacked = encodePacked;
     function encode(types, values) {
-        let coder = new abi_1.AbiCoder();
+        let coder = new ethers_1.utils.AbiCoder();
         return coder.encode(types, values);
     }
     $abiUtils.encode = encode;
     /** Returns complete method/event hash */
-    function getMethodHash(abi) {
+    function getMethodHash(mix) {
+        let abi = typeof mix === 'string'
+            ? _abiParser_1.$abiParser.parseMethod(mix)
+            : mix;
         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) {
+    function getMethodSignature(mix) {
+        let abi = typeof mix === 'string'
+            ? _abiParser_1.$abiParser.parseMethod(mix)
+            : mix;
         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 getTopicSignature(abi) {
+        let types = abi.inputs?.map(serializeMethodSignatureArgumentType) ?? [];
+        let signature = `${abi.name}(${types.join(',')})`;
+        let hash = _contract_1.$contract.keccak256(signature);
+        return hash;
+    }
+    $abiUtils.getTopicSignature = getTopicSignature;
+    function checkInterfaceOf(abi, iface) {
+        if (iface == null || iface.length === 0) {
+            return { ok: false };
+        }
+        for (let item of iface) {
+            if (item.type === 'constructor') {
+                continue;
+            }
+            let inAbi = abi.some(x => abiEquals(x, item));
+            if (inAbi === false) {
+                return { ok: false, missing: item.name };
+            }
+        }
+        return { ok: true };
+    }
+    $abiUtils.checkInterfaceOf = checkInterfaceOf;
+    function abiEquals(a, b) {
+        if (a.name !== b.name) {
+            return false;
+        }
+        let aInputs = a.inputs ?? [];
+        let bInputs = b.inputs ?? [];
+        if (aInputs.length !== bInputs.length) {
+            return false;
+        }
+        //@TODO: may be better AbiInput comparison?
+        for (let i = 0; i < aInputs.length; i++) {
+            let aInput = aInputs[i];
+            let bInput = bInputs[i];
+            if (aInput?.type !== bInput?.type) {
+                return false;
+            }
+        }
+        return true;
+    }
     function serializeMethodSignatureArgumentType(input) {
         if (input.type === 'tuple') {
             let types = input.components.map(x => serializeMethodSignatureArgumentType(x));

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$account = void 0;
+const _address_1 = require("./$address");
+var $account;
+(function ($account) {
+    function getSender(account) {
+        if (typeof account === 'string') {
+            if (_address_1.$address.isValid(account)) {
+                return { address: account };
+            }
+            return { name: account };
+        }
+        let acc = isSafe(account)
+            ? account.operator
+            : account;
+        return acc;
+    }
+    $account.getSender = getSender;
+    function isSafe(account) {
+        if (account == null) {
+            return false;
+        }
+        if (typeof account === 'string') {
+            return /^safe\//.test(account);
+        }
+        return 'operator' in account;
+    }
+    $account.isSafe = isSafe;
+})($account = exports.$account || (exports.$account = {}));

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

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$address = void 0;
+const web3_1 = __importDefault(require("web3"));
 var $address;
 (function ($address) {
     function eq(a1, a2) {
@@ -37,5 +41,9 @@ var $address;
         return address.toLowerCase().substring(2).padStart(32, '0');
     }
     $address.toBytes32 = toBytes32;
+    function toChecksum(address) {
+        return web3_1.default.utils.toChecksumAddress(address);
+    }
+    $address.toChecksum = toChecksum;
     $address.ZERO = '0x0000000000000000000000000000000000000000';
 })($address = exports.$address || (exports.$address = {}));

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$bigint = void 0;
-const _is_1 = require("./$is");
+const _require_1 = require("./$require");
 var $bigint;
 (function ($bigint_1) {
     $bigint_1.ETHER_DECIMALS = 18;
@@ -88,6 +88,21 @@ var $bigint;
     }
     $bigint_1.toEtherSafe = toEtherSafe;
     function toHex(num) {
+        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)}`;
     }
     $bigint_1.toHex = toHex;
@@ -112,8 +127,8 @@ var $bigint;
     }
     $bigint_1.multWithFloat = multWithFloat;
     function divToFloat(a, b, precision = 100000n) {
-        _is_1.$is.BigInt(a);
-        _is_1.$is.BigInt(b);
+        _require_1.$require.BigInt(a);
+        _require_1.$require.BigInt(b);
         let r = (a * precision) / b;
         if (r < Number.MAX_SAFE_INTEGER) {
             return Number(r) / Number(precision);
@@ -127,4 +142,38 @@ var $bigint;
         return $base ** $exp;
     }
     $bigint_1.pow = pow;
+    function sign(value) {
+        if (value > 0n) {
+            return 1n;
+        }
+        if (value < 0n) {
+            return -1n;
+        }
+        return 0n;
+    }
+    $bigint_1.sign = sign;
+    function abs(value) {
+        if (sign(value) === -1n) {
+            return -value;
+        }
+        return value;
+    }
+    $bigint_1.abs = abs;
+    function sqrt(value) {
+        return rootNth(value);
+    }
+    $bigint_1.sqrt = sqrt;
+    function rootNth(value, 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;
+    }
 })($bigint = exports.$bigint || (exports.$bigint = {}));

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

@@ -1,10 +1,26 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$block = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const BlockDateResolver_1 = require("@dequanto/blocks/BlockDateResolver");
 var $block;
 (function ($block) {
     function getDate(block) {
         return new Date(Number(block.timestamp) * 1000);
     }
     $block.getDate = getDate;
+    async function ensureNumber(mix, client) {
+        if (typeof mix === 'number') {
+            return mix;
+        }
+        if (mix instanceof Date) {
+            let dateResolver = a_di_1.default.resolve(BlockDateResolver_1.BlockDateResolver, client);
+            return await dateResolver.getBlockNumberFor(mix);
+        }
+        throw new Error(`Invalid getBlockNumber param: ${mix}`);
+    }
+    $block.ensureNumber = ensureNumber;
 })($block = exports.$block || (exports.$block = {}));

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$bloom = void 0;
+const _contract_1 = require("./$contract");
+const _hex_1 = require("./$hex");
+var $bloom;
+(function ($bloom) {
+    function check(bloomHex, hex) {
+        let masks = LogsBloom.getBits(hex);
+        let matched = masks.every((byte, i) => {
+            let b = _hex_1.$hex.getNumber(bloomHex, byte.index);
+            let has = (b | byte.mask) === b;
+            return has;
+        });
+        return matched;
+    }
+    $bloom.check = check;
+})($bloom = exports.$bloom || (exports.$bloom = {}));
+var LogsBloom;
+(function (LogsBloom) {
+    function getBits(topicHash) {
+        let hashBuf = getHashBuf(topicHash);
+        let byte1Mask = 1 << (_hex_1.$hex.getNumber(hashBuf, 1) & 0x7);
+        let byte2Mask = 1 << (_hex_1.$hex.getNumber(hashBuf, 3) & 0x7);
+        let byte3Mask = 1 << (_hex_1.$hex.getNumber(hashBuf, 5) & 0x7);
+        const bloomLength = 256;
+        let byte1Pos = bloomLength - ((_hex_1.$hex.getNumber(hashBuf, 0, 2) & 0x7FF) >> 3) - 1;
+        let byte2Pos = bloomLength - ((_hex_1.$hex.getNumber(hashBuf, 2, 2) & 0x7FF) >> 3) - 1;
+        let byte3Pos = bloomLength - ((_hex_1.$hex.getNumber(hashBuf, 4, 2) & 0x7FF) >> 3) - 1;
+        return [
+            { index: byte1Pos, mask: byte1Mask },
+            { index: byte2Pos, mask: byte2Mask },
+            { index: byte3Pos, mask: byte3Mask },
+        ];
+    }
+    LogsBloom.getBits = getBits;
+    function getHashBuf(topicHash) {
+        let hash = _contract_1.$contract.keccak256(_hex_1.$hex.ensure(topicHash));
+        return hash;
+    }
+    LogsBloom.getHashBuf = getHashBuf;
+})(LogsBloom || (LogsBloom = {}));

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$buffer = void 0;
+const atma_utils_1 = require("atma-utils");
+class NodeBufferUtils {
+    fromString(str, encoding) {
+        return Buffer.from(str, encoding ?? 'utf8');
+    }
+    toString(buffer, encoding) {
+        return buffer.toString(encoding);
+    }
+    fromHex(hex) {
+        return Buffer.from(utils.normalizeHex(hex), 'hex');
+    }
+    toHex(buffer) {
+        let hex = buffer.toString('hex');
+        return `0x${hex}`;
+    }
+    concat(buffers) {
+        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 {
+    fromString(string, encoding) {
+        if (encoding != null && /utf\-?8/.test(encoding) === false) {
+            throw new Error(`Only UTF8 Encoding supported`);
+        }
+        return new TextEncoder().encode(string);
+    }
+    toString(buffer, encoding) {
+        if (encoding != null && /utf\-?8/.test(encoding) === false) {
+            throw new Error(`Only UTF8 Encoding supported`);
+        }
+        return new TextDecoder().decode(buffer);
+    }
+    fromHex(hex) {
+        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) {
+        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) {
+        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;
+    }
+}
+var utils;
+(function (utils) {
+    function normalizeHex(hex) {
+        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;
+    }
+    utils.normalizeHex = normalizeHex;
+})(utils || (utils = {}));
+exports.$buffer = atma_utils_1.is_NODE
+    ? new NodeBufferUtils()
+    : new WebBufferUtils();

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$cli = void 0;
+var $cli;
+(function ($cli) {
+    function getParamValue(flag, parameters) {
+        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;
+    }
+    $cli.getParamValue = getParamValue;
+})($cli = exports.$cli || (exports.$cli = {}));