dequanto 0.0.1 → 0.0.7

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

@@ -3,31 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.$is = void 0;
 var $is;
 (function ($is) {
-    function Number(val, message = 'Invalid.', opts) {
-        if (typeof val !== 'number') {
-            throw new Error(`Value is not a number. ${message}`);
-        }
-        if (opts?.min != null && val < opts.min) {
-            throw new Error(`Value ${val} is less than ${opts.min}. ${message}`);
-        }
-        if (opts?.max != null && val > opts.max) {
-            throw new Error(`Value ${val} is greater than ${opts.max}. ${message}`);
-        }
-        return val;
+    function Number(val) {
+        return typeof val === 'number' && isNaN(val) === false;
     }
     $is.Number = Number;
-    function notNull(val, message) {
-        if (val == null) {
-            throw new Error(`Value is undefined. ${message}`);
-        }
-        return val;
+    function notNull(val) {
+        return val != null;
     }
     $is.notNull = notNull;
-    function BigInt(val, message) {
-        if (typeof val !== 'bigint') {
-            throw new Error(`Value is undefined. ${message}`);
-        }
-        return val;
+    function BigInt(val) {
+        return typeof val === 'bigint';
     }
     $is.BigInt = BigInt;
     function Address(val, message) {
@@ -37,4 +22,22 @@ var $is;
         return /^0x[a-fA-F0-9]{40}$/g.test(val);
     }
     $is.Address = Address;
+    function TxHash(val) {
+        if (hexString(val) === false) {
+            return false;
+        }
+        // 0x115f9d0e3c5d7538eb27466cf42ac68527703a14e93c0d1243131164af2d1c6c
+        if (val.length !== 2 + 64) {
+            return false;
+        }
+        return true;
+    }
+    $is.TxHash = TxHash;
+    function hexString(str) {
+        if (typeof str !== 'string') {
+            return false;
+        }
+        return /^0x[\da-f]+$/i.test(str);
+    }
+    $is.hexString = hexString;
 })($is = exports.$is || (exports.$is = {}));

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

@@ -1,15 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.$logger = void 0;
+exports.l = exports.$logger = void 0;
+const _color_1 = require("./$color");
 const _date_1 = require("./$date");
 var $logger;
 (function ($logger) {
     function log(...args) {
-        console.log(_date_1.$date.format(new Date(), 'HH:mm:ss'), ...args);
+        if (args.length === 1 && typeof args[0] !== 'string') {
+            console.dir(args[0], { depth: null });
+            return;
+        }
+        console.log(_date_1.$date.format(new Date(), 'HH:mm:ss'), ...colored(args));
     }
     $logger.log = log;
     function warn(...args) {
-        console.warn(_date_1.$date.format(new Date(), 'HH:mm:ss'), ...args);
+        console.warn(_date_1.$date.format(new Date(), 'HH:mm:ss'), ...colored(args));
     }
     $logger.warn = warn;
+    function error(...args) {
+        console.error(_date_1.$date.format(new Date(), 'HH:mm:ss'), ...colored(args));
+    }
+    $logger.error = error;
+    function colored(args) {
+        for (let i = 0; i < args.length; i++) {
+            let x = args[i];
+            if (typeof x !== 'string') {
+                continue;
+            }
+            args[i] = (0, _color_1.$color)(args[i]);
+        }
+        return args;
+    }
 })($logger = exports.$logger || (exports.$logger = {}));
+function l(strings, ...values) {
+    let args = [];
+    for (let i = 0; i < strings.length; i++) {
+        args.push(strings[i]);
+        if (i < values.length) {
+            args.push(values[i]);
+        }
+    }
+    // join value types if should be colorized: l`Age: bold<${age}>`
+    for (let i = 1; i < args.length - 1; i++) {
+        let before = args[i - 1];
+        let value = args[i];
+        let after = args[i + 1];
+        if (typeof before !== 'string' || typeof after !== 'string') {
+            continue;
+        }
+        switch (typeof value) {
+            case 'number':
+            case 'string':
+            case 'boolean':
+            case 'undefined':
+            case 'bigint':
+                break;
+            default:
+                // skip all non-value types.
+                continue;
+        }
+        args[i - 1] = `${before}${value}${after}`;
+        args.splice(i, 2);
+        i--;
+    }
+    $logger.log(...args);
+}
+exports.l = l;

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$machine = void 0;
+var $machine;
+(function ($machine) {
+    function id(original = false) {
+        return new Promise((resolve, reject) => {
+            const { exec } = require('child_process');
+            return exec(getCommand(), {}, (err, stdout, stderr) => {
+                if (err) {
+                    return reject(new Error(`Error while obtaining machine id: ${err.stack}`));
+                }
+                let id = extractId(stdout.toString());
+                return resolve(original ? id : hash(id));
+            });
+        });
+    }
+    $machine.id = id;
+    function hash(guid) {
+        const { createHash } = require('crypto');
+        return createHash('sha256').update(guid).digest('hex');
+    }
+    function getCommand() {
+        let { platform } = process;
+        let win32RegBinPath = {
+            native: '%windir%\\System32',
+            mixed: '%windir%\\sysnative\\cmd.exe /c %windir%\\System32'
+        };
+        let guid = {
+            darwin: 'ioreg -rd1 -c IOPlatformExpertDevice',
+            win32: `${win32RegBinPath[isWindowsProcessMixedOrNativeArchitecture()]}\\REG.exe ` +
+                'QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography ' +
+                '/v MachineGuid',
+            linux: '( cat /var/lib/dbus/machine-id /etc/machine-id 2> /dev/null || hostname ) | head -n 1 || :',
+            freebsd: 'kenv -q smbios.system.uuid || sysctl -n kern.hostuuid'
+        };
+        function isWindowsProcessMixedOrNativeArchitecture() {
+            // detect if the node binary is the same arch as the Windows OS.
+            // or if this is 32 bit node on 64 bit windows.
+            if (process.platform !== 'win32') {
+                return '';
+            }
+            if (process.arch === 'ia32' && process.env.hasOwnProperty('PROCESSOR_ARCHITEW6432')) {
+                return 'mixed';
+            }
+            return 'native';
+        }
+        return guid[platform];
+    }
+    function extractId(result) {
+        switch (process.platform) {
+            case 'darwin':
+                return result
+                    .split('IOPlatformUUID')[1]
+                    .split('\n')[0].replace(/\=|\s+|\"/ig, '')
+                    .toLowerCase();
+            case 'win32':
+                return result
+                    .toString()
+                    .split('REG_SZ')[1]
+                    .replace(/\r+|\n+|\s+/ig, '')
+                    .toLowerCase();
+            case 'linux':
+                return result
+                    .toString()
+                    .replace(/\r+|\n+|\s+/ig, '')
+                    .toLowerCase();
+            case 'freebsd':
+                return result
+                    .toString()
+                    .replace(/\r+|\n+|\s+/ig, '')
+                    .toLowerCase();
+            default:
+                throw new Error(`Unsupported platform: ${process.platform}`);
+        }
+    }
+})($machine = exports.$machine || (exports.$machine = {}));

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

@@ -49,7 +49,26 @@ var $number;
         if (typeof mix === 'number') {
             return mix;
         }
-        return parseFloat(mix.replace(/,+/g, '.'));
+        let factor = null;
+        // string
+        let c = mix[mix.length - 1];
+        if (c === 'k' || c === 'K') {
+            factor = 1000;
+            mix = mix.substring(0, mix.length - 1);
+        }
+        if (c === 'm' || c === 'M') {
+            factor = 1000000;
+            mix = mix.substring(0, mix.length - 1);
+        }
+        if (c === 'b' || c === 'B') {
+            factor = 1000000000;
+            mix = mix.substring(0, mix.length - 1);
+        }
+        let value = parseFloat(mix.replace(/,+/g, '.'));
+        if (factor != null) {
+            value *= factor;
+        }
+        return value;
     }
     $number.parse = parse;
     function round(mix, digits = 0, round = 'round') {
@@ -92,4 +111,8 @@ var $number;
         throw new Error('Unsupported type to convert to number ' + typeof mix);
     }
     $number.parseOptional = parseOptional;
+    function toHex(num) {
+        return `0x` + Number(num).toString(16);
+    }
+    $number.toHex = toHex;
 })($number = exports.$number || (exports.$number = {}));

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$path = void 0;
 const atma_utils_1 = require("atma-utils");
+const _config_1 = require("./$config");
 var $path;
 (function ($path) {
     let root = null;
@@ -9,7 +10,23 @@ var $path;
         return atma_utils_1.class_Uri.combine(root ?? (root = getRoot()), path);
     }
     $path.resolve = resolve;
+    function isAbsolute(path) {
+        if (path[0] === '/') {
+            return true;
+        }
+        let hasProtocol = /^[\w]{2,5}:[\\\/]{2,}/.test(path);
+        if (hasProtocol) {
+            return true;
+        }
+        return false;
+    }
+    $path.isAbsolute = isAbsolute;
     function getRoot() {
+        let base = _config_1.$config.get('settings.base');
+        if (base != null) {
+            let cwd = process.cwd();
+            return atma_utils_1.class_Uri.combine('file://' + cwd, base);
+        }
         let uri = new atma_utils_1.class_Uri('file://' + __dirname + '/');
         while (true) {
             let dir = getDirName(uri.path);

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

@@ -10,4 +10,85 @@ var $promise;
     }
     $promise.wait = wait;
     ;
+    function fromEvent(eventEmitter, event) {
+        return new Promise((resolve, reject) => {
+            const cb = (value) => {
+                resolve(value);
+                eventEmitter.off(event, cb);
+            };
+            eventEmitter.on(event, cb);
+        });
+    }
+    $promise.fromEvent = fromEvent;
+    function timeout(promise, ms) {
+        let err = new Error(`Promise timeouted in ${ms}ms`);
+        return new Promise((resolve, reject) => {
+            let completed = false;
+            let timeout = setTimeout(() => {
+                if (completed) {
+                    return;
+                }
+                completed = true;
+                reject(err);
+            }, ms);
+            promise.then(result => {
+                completed = true;
+                clearTimeout(timeout);
+                resolve(result);
+            }, err => {
+                completed = true;
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    $promise.timeout = timeout;
+    function waitForTrue(check, opts) {
+        return waitForObject(async () => {
+            let result = await check();
+            return [null, result === true ? {} : null];
+        }, opts);
+    }
+    $promise.waitForTrue = waitForTrue;
+    function waitForObject(check, opts) {
+        let start = Date.now();
+        let completed = false;
+        let intervalMs = opts?.intervalMs ?? 500;
+        let timeoutMs = opts?.timeoutMs ?? null;
+        let timeoutMessage = opts?.timeoutMessage ?? `Waiting for object timeouted`;
+        return new Promise(async (resolve, reject) => {
+            async function tick() {
+                let [error, result] = (await check()) ?? [null, null];
+                if (result != null) {
+                    completed = true;
+                    resolve(result);
+                    return;
+                }
+                if (error != null) {
+                    completed = true;
+                    reject(error);
+                    return;
+                }
+                if (timeoutMs != null && (Date.now() - start) > timeoutMs) {
+                    completed = true;
+                    let message = typeof timeoutMessage === 'function'
+                        ? timeoutMessage()
+                        : timeoutMessage;
+                    reject(new Error(message));
+                    return;
+                }
+            }
+            while (true) {
+                try {
+                    await tick();
+                }
+                finally { }
+                if (completed === true) {
+                    break;
+                }
+                await $promise.wait(intervalMs);
+            }
+        });
+    }
+    $promise.waitForObject = waitForObject;
 })($promise = exports.$promise || (exports.$promise = {}));

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

@@ -45,11 +45,18 @@ var $require;
     $require.Numeric = Numeric;
     function Function(val, message) {
         if (typeof val !== 'function') {
-            throw new Error(`Value is not a function`);
+            throw new Error(`Value is not a function ${message}`);
         }
         return val;
     }
     $require.Function = Function;
+    function String(val, message) {
+        if (typeof val !== 'string') {
+            throw new Error(`Value ${val} is not a string ${message}`);
+        }
+        return val;
+    }
+    $require.String = String;
     function notNull(val, message) {
         if (val == null) {
             throw new Error(`Value is undefined. ${message}`);
@@ -100,6 +107,13 @@ var $require;
         return val;
     }
     $require.Address = Address;
+    function TxHash(val, message = '') {
+        if (_is_1.$is.TxHash(val) === false) {
+            throw new Error(`Value ${val} is not a valid tx hash. ${message}`);
+        }
+        return val;
+    }
+    $require.TxHash = TxHash;
     function Token(token, message = '') {
         if (token == null) {
             throw new Error(`Token is undefined. ${message}`);

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$secret = void 0;
+const _machine_1 = require("./$machine");
+var $secret;
+(function ($secret) {
+    async function getPin(parameters) {
+        let pin = parameters?.pin ?? getPinFromCli() ?? getPinFromEnv();
+        if (pin == null || pin.length === 0) {
+            return null;
+        }
+        let id = await _machine_1.$machine.id();
+        return `${id}:${pin}`;
+    }
+    $secret.getPin = getPin;
+    function getPinFromCli() {
+        let args = process.argv;
+        for (let i = 0; i < args.length - 1; i++) {
+            let key = args[i].replace(/^\-+/, '');
+            if (key === 'p' || key === 'pin') {
+                return args[i + 1];
+            }
+        }
+        return null;
+    }
+    function getPinFromEnv() {
+        return process.env.PIN;
+    }
+})($secret = exports.$secret || (exports.$secret = {}));

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

@@ -1,14 +1,85 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$sign = void 0;
-const ethereumjs_util_1 = require("ethereumjs-util");
+const _buffer_1 = require("./$buffer");
+const _is_1 = require("./$is");
+const ethers_1 = require("ethers");
 var $sign;
 (function ($sign) {
-    function signEC(message, privateKey) {
-        const sig = (0, ethereumjs_util_1.ecsign)(toBuffer(message), toBuffer(privateKey, { encoding: 'hex' }));
-        let r = sig.r.toString('hex').padStart(64, '0');
-        let s = sig.s.toString('hex').padStart(64, '0');
-        let v = sig.v.toString(16);
+    /** Adds  "Ethereum Signed Message" */
+    async function signEIPHashed(client, message, account, accountPss) {
+        const web3 = await client.getWeb3();
+        //const buffer = toBuffer(message);
+        //const hash = hashPersonalMessage(buffer as Buffer);
+        const str = message;
+        const key = account.key != null
+            ? account.key
+            : null;
+        if (key != null) {
+            let sig = web3.eth.accounts.sign(str, key);
+            let r = sig.r.substring(2);
+            let s = sig.s.substring(2);
+            let v = sig.v.substring(2);
+            return toSignature({ r, s, v });
+        }
+        let signature = accountPss == null
+            ? await web3.eth.sign(message.toString(), account.address)
+            : await web3.eth.personal.sign(message.toString(), account.address, accountPss);
+        return toSignature(splitSignature(signature));
+    }
+    $sign.signEIPHashed = signEIPHashed;
+    async function signTx(client, tx, account, accountPss) {
+        const web3 = await client.getWeb3();
+        const key = account.key != null
+            ? account.key
+            : null;
+        if (key != null) {
+            if (typeof tx.chainId === 'string') {
+                // chainIDBN in @ethereumjs supports HEX only if base is specified, otherwise 10 base is taken, and hex numbers are wrongly parsed to a number
+                tx.chainId = Number(tx.chainId);
+            }
+            let sig = await web3.eth.accounts.signTransaction(tx, key);
+            return toSignature(sig);
+        }
+        let signed = accountPss == null
+            ? await web3.eth.signTransaction(tx)
+            : await web3.eth.personal.signTransaction(tx, accountPss);
+        return toSignature(signed.tx);
+    }
+    $sign.signTx = signTx;
+    async function serializeTx(tx, signature) {
+        let sig = getSignature(signature);
+        if (Number(sig.v) === 0) {
+            // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-155.md
+            sig.v = '0x25';
+        }
+        return ethers_1.ethers.utils.serializeTransaction(tx, {
+            ...sig,
+            v: Number(sig.v)
+        });
+    }
+    $sign.serializeTx = serializeTx;
+    async function recoverTx(client, tx, signature) {
+        const web3 = await client.getWeb3();
+        const sig = getSignature(signature);
+        const rawTransaction = await serializeTx(tx, sig);
+        return web3.eth.accounts.recoverTransaction(rawTransaction);
+    }
+    $sign.recoverTx = recoverTx;
+    function splitSignature(signature) {
+        let r = signature.substring(2, 2 + 64);
+        let s = signature.substring(2 + 64, 2 + 64 + 64);
+        let v = signature.substring(2 + 64 + 64);
+        return { r, s, v };
+    }
+    function toSignature(sign) {
+        let { r, s, v } = sign;
+        r = remove0x(r);
+        s = remove0x(s);
+        if (typeof v === 'number') {
+            v = v.toString(16);
+        }
+        v = remove0x(v);
         return {
             v: `0x${v}`,
             r: `0x${r}`,
@@ -17,19 +88,30 @@ var $sign;
             signatureVRS: `0x${v}${r}${s}`
         };
     }
-    $sign.signEC = signEC;
-    function signEIPHashed(message, privateKey) {
-        const hash = (0, ethereumjs_util_1.hashPersonalMessage)(toBuffer(message, { encoding: 'utf8' }));
-        return signEC(hash, privateKey);
+    function remove0x(hex) {
+        return hex.startsWith('0x') ? hex.substring(2) : hex;
     }
-    $sign.signEIPHashed = signEIPHashed;
     function toBuffer(message, opts) {
         if (typeof message === 'string') {
-            if (/^0x[\da-f]+$/i.test(message)) {
-                return Buffer.from(message.substring(2), 'hex');
+            let encoding = opts?.encoding;
+            if (encoding == null && _is_1.$is.hexString(message)) {
+                encoding = 'hex';
+                message = message.substring(2);
             }
-            return Buffer.from(message, opts?.encoding ?? 'utf8');
+            if (encoding === 'hex') {
+                return _buffer_1.$buffer.fromHex(message);
+            }
+            return _buffer_1.$buffer.fromString(message, opts?.encoding ?? 'utf8');
         }
         return message;
     }
+    function getSignature(signature) {
+        let sig = typeof signature === 'string'
+            ? splitSignature(signature)
+            : signature;
+        if (sig?.r == null || sig?.v == null || sig?.s == null) {
+            throw new Error(`Invalid signature ${JSON.stringify(sig)}`);
+        }
+        return sig;
+    }
 })($sign = exports.$sign || (exports.$sign = {}));

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$signRaw = void 0;
+const ethereumjs_util_1 = require("ethereumjs-util");
+const _buffer_1 = require("./$buffer");
+const _is_1 = require("./$is");
+const ethers_1 = require("ethers");
+var $signRaw;
+(function ($signRaw) {
+    function signEC(message, privateKey) {
+        const sig = (0, ethereumjs_util_1.ecsign)(toBuffer(message), toBuffer(privateKey, { encoding: 'hex' }));
+        let r = sig.r.toString('hex').padStart(64, '0');
+        let s = sig.s.toString('hex').padStart(64, '0');
+        let v = sig.v.toString(16);
+        return {
+            v: `0x${v}`,
+            r: `0x${r}`,
+            s: `0x${s}`,
+            signature: `0x${r}${s}${v}`,
+            signatureVRS: `0x${v}${r}${s}`
+        };
+    }
+    $signRaw.signEC = signEC;
+    function signEIPHashed(message, privateKey) {
+        const buffer = toBuffer(message);
+        const hash = (0, ethereumjs_util_1.hashPersonalMessage)(buffer);
+        return signEC(hash, privateKey);
+    }
+    $signRaw.signEIPHashed = signEIPHashed;
+    function ecrecover(message, signature) {
+        return ethers_1.utils.recoverAddress(message, signature);
+    }
+    $signRaw.ecrecover = ecrecover;
+    function toBuffer(message, opts) {
+        if (typeof message === 'string') {
+            let encoding = opts?.encoding;
+            if (encoding == null && _is_1.$is.hexString(message)) {
+                encoding = 'hex';
+                message = message.substring(2);
+            }
+            if (encoding === 'hex') {
+                return _buffer_1.$buffer.fromHex(message);
+            }
+            return _buffer_1.$buffer.fromString(message, opts?.encoding ?? 'utf8');
+        }
+        return message;
+    }
+})($signRaw = exports.$signRaw || (exports.$signRaw = {}));

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

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.$signSerializer = void 0;
 const ethUtil = __importStar(require("ethereumjs-util"));
 const ethAbi = __importStar(require("ethereumjs-abi"));
+const _buffer_1 = require("./$buffer");
 var $signSerializer;
 (function ($signSerializer) {
     const TYPED_MESSAGE_SCHEMA = {
@@ -96,7 +97,7 @@ var $signSerializer;
                     if (type === 'string') {
                         // convert string to buffer - prevents ethUtil from interpreting strings like '0xabcd' as hex
                         if (typeof value === 'string') {
-                            value = Buffer.from(value, 'utf8');
+                            value = _buffer_1.$buffer.fromString(value);
                         }
                         return ['bytes32', ethUtil_keccak(value)];
                     }
@@ -129,7 +130,7 @@ var $signSerializer;
                             encodedTypes.push('bytes32');
                             // convert string to buffer - prevents ethUtil from interpreting strings like '0xabcd' as hex
                             if (typeof value === 'string') {
-                                value = Buffer.from(value, 'utf8');
+                                value = _buffer_1.$buffer.fromString(value, 'utf8');
                             }
                             value = ethUtil_keccak(value);
                             encodedValues.push(value);
@@ -241,12 +242,12 @@ var $signSerializer;
          */
         serialize(typedData, useV4 = true) {
             const sanitizedData = this.sanitizeData(typedData);
-            const parts = [Buffer.from('1901', 'hex')];
+            const parts = [_buffer_1.$buffer.fromHex('1901')];
             parts.push(this.hashStruct('EIP712Domain', sanitizedData.domain, sanitizedData.types, useV4));
             if (sanitizedData.primaryType !== 'EIP712Domain') {
                 parts.push(this.hashStruct(sanitizedData.primaryType, sanitizedData.message, sanitizedData.types, useV4));
             }
-            return ethUtil_keccak(Buffer.concat(parts));
+            return ethUtil_keccak(_buffer_1.$buffer.concat(parts));
         }
     }
     ;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$txData = void 0;
+var $txData;
+(function ($txData) {
+    function getJson(txData, defaults) {
+        let json = {
+            ...txData,
+            type: txData.type ?? defaults?.defaultTxType,
+            chainId: txData.chainId ?? defaults?.chainId
+        };
+        if (json.type === 1) {
+            // delete `type` field in case old tx type. Some old nodes may reject type field presence
+            delete json.type;
+        }
+        return json;
+    }
+    $txData.getJson = getJson;
+})($txData = exports.$txData || (exports.$txData = {}));