dequanto 0.0.1 → 0.0.7

package/src/utils/$machine.ts

@@ -0,0 +1,85 @@
+
+
+
+export namespace $machine {
+
+    export function id(original: boolean = false): Promise<string> {
+        return new Promise((resolve: Function, reject: Function): Object => {
+
+            const { exec } = require('child_process');
+            return exec(getCommand(), {}, (err: any, stdout: any, stderr: any) => {
+                if (err) {
+                    return reject(
+                        new Error(`Error while obtaining machine id: ${err.stack}`)
+                    );
+                }
+                let id: string = extractId(stdout.toString());
+                return resolve(original ? id : hash(id));
+            });
+        });
+    }
+
+    function hash(guid: string): string {
+        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(): string {
+            // 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: string): string {
+        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}`);
+        }
+    }
+
+}

package/src/utils/$number.ts

@@ -43,7 +43,27 @@ export namespace $number {
         if (typeof mix === 'number') {
             return mix;
         }
-        return parseFloat(mix.replace(/,+/g, '.'));
+        let factor: number = 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;
     }
     export function round (mix: string | number, digits: number = 0, round: 'ceil' | 'round' | 'floor' = 'round') {
         let number = typeof mix === 'string' ? Number(mix) : mix;
@@ -86,4 +106,7 @@ export namespace $number {
         throw new Error('Unsupported type to convert to number ' + typeof mix);
     }
 
+    export function toHex (num: string | number) {
+        return `0x` + Number(num).toString(16);
+    }
 }

package/src/utils/$path.ts

@@ -1,14 +1,30 @@
 import { class_Uri } from 'atma-utils';
+import { $config } from './$config';
 
 export namespace $path {
     let root: string = null;
 
     export function resolve (path: string) {
-
         return class_Uri.combine(root ?? (root = getRoot()), path)
     }
+    export function isAbsolute(path: string) {
+        if (path[0] === '/') {
+            return true;
+        }
+        let hasProtocol = /^[\w]{2,5}:[\\\/]{2,}/.test(path);
+        if (hasProtocol) {
+            return true;
+        }
+        return false;
+    }
 
     function getRoot () {
+        let base = $config.get('settings.base');
+        if (base != null) {
+            let cwd = process.cwd();
+            return class_Uri.combine('file://' + cwd, base);
+        }
+
         let uri = new class_Uri('file://' + __dirname + '/');
         while (true) {
             let dir = getDirName(uri.path);

package/src/utils/$promise.ts

@@ -1,7 +1,108 @@
+import { class_EventEmitter } from 'atma-utils';
+
 export namespace $promise {
     export function wait (ms) {
         return new Promise(resolve => {
             setTimeout(resolve, ms);
         });
     };
+
+    export function fromEvent<
+        T extends Pick<class_EventEmitter, 'on' | 'off'>,
+        TArgs extends Parameters<T['on']>,
+    > (
+        eventEmitter: T,
+        event: TArgs[0],
+    ): Promise<any> {
+        return new Promise((resolve, reject) => {
+            const cb = (value) => {
+                resolve(value);
+                eventEmitter.off(event, cb)
+            };
+            eventEmitter.on(event, cb);
+        });
+    }
+
+    export function timeout<T extends Promise<any>> (promise: T, ms: number): T {
+        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);
+                }
+            );
+        }) as T;
+    }
+
+    export function waitForTrue (check: () => boolean | Promise<boolean>, opts?: Parameters<typeof waitForObject>[1]): Promise<any> {
+        return waitForObject(async () => {
+            let result = await check();
+            return [ null, result === true ? {} : null ]
+        }, opts);
+    }
+
+    export function waitForObject<T>(check: () => Promise<[Error, T?]>, opts?: {
+        intervalMs?: number
+        timeoutMs?: number
+        timeoutMessage?: string | (() => string)
+    }): Promise<T>  {
+        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);
+            }
+        });
+    }
+
 }

package/src/utils/$require.ts

@@ -42,7 +42,13 @@ export namespace $require {
 
     export function Function<T>(val: T, message: string): T {
         if (typeof val !== 'function') {
-            throw new Error(`Value is not a function`);
+            throw new Error(`Value is not a function ${message}`);
+        }
+        return val;
+    }
+    export function String<T>(val: T, message): T {
+        if (typeof val !== 'string') {
+            throw new Error(`Value ${val} is not a string ${message}`);
         }
         return val;
     }
@@ -91,6 +97,14 @@ export namespace $require {
         }
         return val;
     }
+
+    export function TxHash (val: string, message: string = ''): string {
+        if ($is.TxHash(val) === false) {
+            throw new Error(`Value ${val} is not a valid tx hash. ${message}`);
+        }
+        return val;
+    }
+
     export function Token (token: IToken, message: string = ''): IToken {
         if (token == null) {
             throw new Error(`Token is undefined. ${message}`);

package/src/utils/$secret.ts

@@ -0,0 +1,27 @@
+import { $machine } from './$machine';
+
+export namespace $secret {
+    export async function getPin(parameters?: { pin?: string }) {
+
+        let pin = parameters?.pin ?? getPinFromCli() ?? getPinFromEnv();
+        if (pin == null || pin.length === 0) {
+            return null;
+        }
+        let id = await $machine.id();
+        return `${id}:${pin}`;
+    }
+
+    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;
+    }
+}

package/src/utils/$sign.ts

@@ -1,16 +1,99 @@
-import { hashPersonalMessage, ecsign } from 'ethereumjs-util';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { ChainAccount } from '@dequanto/models/TAccount';
+import { $buffer, TBytes } from './$buffer';
+import { $is } from './$is';
+import type { TransactionConfig } from 'web3-core';
+import { ethers } from 'ethers';
 
 export namespace $sign {
-    export function signEC (message: string | Buffer, privateKey: string | Buffer) {
-        const sig = ecsign(
-            toBuffer(message),
-            toBuffer(privateKey, { encoding: 'hex' })
-        );
+    export type TSignature = {
+        v: string
+        r: string
+        s: string
+        signature?: string
+        signatureVRS?: string
+    };
 
-        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" */
+    export async function signEIPHashed (client: Web3Client, message: string, account: ChainAccount, accountPss?: string): Promise<TSignature> {
+        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));
+
+    }
+
+    export async function signTx (client: Web3Client, tx: TransactionConfig, account: ChainAccount, accountPss?: string): Promise<ReturnType<typeof splitSignature>> {
+        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);
+    }
+
+    export async function serializeTx (tx, signature: string | TSignature): Promise<string> {
+        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.utils.serializeTransaction(tx, {
+            ...sig,
+            v: Number(sig.v)
+        });
+    }
+    export async function recoverTx(client: Web3Client, tx: TransactionConfig, signature: string | TSignature) {
+        const web3 = await client.getWeb3();
+        const sig = getSignature(signature);
+        const rawTransaction = await serializeTx(tx, sig);
+        return web3.eth.accounts.recoverTransaction(rawTransaction);
+    }
+
+    function splitSignature (signature: string): TSignature {
+        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: { r, s, v }) {
+        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}`,
@@ -19,18 +102,34 @@ export namespace $sign {
             signatureVRS: `0x${v}${r}${s}`
         }
     }
-    export function signEIPHashed (message: string | Buffer, privateKey: string) {
-        const hash = hashPersonalMessage(toBuffer(message, { encoding: 'utf8' }));
-        return signEC(hash, privateKey);
+    function remove0x(hex:string) {
+        return hex.startsWith('0x') ? hex.substring(2) : hex;
     }
 
-    function toBuffer (message: string | Buffer, opts?: { encoding?: 'utf8' | 'hex' }) {
+    function toBuffer (message: string | TBytes, opts?: { encoding?: 'utf8' | 'hex' }) {
         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.hexString(message)) {
+                encoding = 'hex';
+                message = message.substring(2);
             }
-            return Buffer.from(message, opts?.encoding ?? 'utf8');
+            if (encoding === 'hex') {
+                return $buffer.fromHex(message);
+            }
+            return $buffer.fromString(message, opts?.encoding ?? 'utf8');
         }
         return message;
     }
+
+
+    function getSignature(signature: string | TSignature): TSignature {
+        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;
+    }
 }

package/src/utils/$signRaw.ts

@@ -0,0 +1,50 @@
+import { hashPersonalMessage, ecsign } from 'ethereumjs-util';
+import { $buffer } from './$buffer';
+import { $is } from './$is';
+import { ethers, utils } from 'ethers'
+import { TAddress } from '@dequanto/models/TAddress';
+
+export namespace $signRaw {
+    export function signEC (message: string | Buffer, privateKey: string | Buffer) {
+        const sig = ecsign(
+            toBuffer(message) as Buffer,
+            toBuffer(privateKey, { encoding: 'hex' }) as Buffer
+        );
+
+        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}`
+        }
+    }
+    export function signEIPHashed (message: string | Buffer, privateKey: string) {
+        const buffer = toBuffer(message);
+        const hash = hashPersonalMessage(buffer as Buffer);
+        return signEC(hash, privateKey);
+    }
+
+    export function ecrecover (message: string, signature: string | { v, r, s}): TAddress {
+        return utils.recoverAddress(message, signature) as TAddress;
+    }
+
+    function toBuffer (message: string | Buffer, opts?: { encoding?: 'utf8' | 'hex' }) {
+        if (typeof message === 'string') {
+            let encoding = opts?.encoding;
+            if (encoding == null && $is.hexString(message)) {
+                encoding = 'hex';
+                message = message.substring(2);
+            }
+            if (encoding === 'hex') {
+                return $buffer.fromHex(message);
+            }
+            return $buffer.fromString(message, opts?.encoding ?? 'utf8');
+        }
+        return message;
+    }
+}

package/src/utils/$signSerializer.ts

@@ -1,5 +1,7 @@
 import * as ethUtil from 'ethereumjs-util';
 import * as ethAbi from 'ethereumjs-abi';
+import { $buffer } from './$buffer';
+import { type BytesLike } from 'ethers';
 
 export namespace $signSerializer {
 
@@ -116,7 +118,7 @@ export namespace $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.fromString(value);
                         }
                         return ['bytes32', ethUtil_keccak(value)];
                     }
@@ -159,7 +161,7 @@ export namespace $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.fromString(value, 'utf8');
                             }
                             value = ethUtil_keccak(value);
                             encodedValues.push(value);
@@ -298,7 +300,7 @@ export namespace $signSerializer {
             useV4 = true
         ): Buffer {
             const sanitizedData = this.sanitizeData(typedData);
-            const parts = [Buffer.from('1901', 'hex')];
+            const parts = [$buffer.fromHex('1901')];
 
             parts.push(
                 this.hashStruct(
@@ -319,13 +321,13 @@ export namespace $signSerializer {
                 );
             }
 
-            return ethUtil_keccak(Buffer.concat(parts));
+            return ethUtil_keccak($buffer.concat(parts));
         }
     };
 
 
 
-    function ethUtil_keccak (value: string | Buffer) {
+    function ethUtil_keccak(value: BytesLike) {
         if (typeof value === 'string') {
             if (value.startsWith('0x')) {
                 value = Buffer.from(value.substring(2), 'hex');
@@ -333,7 +335,7 @@ export namespace $signSerializer {
                 value = Buffer.from(value);
             }
         }
-        return ethUtil.keccak(value);
+        return ethUtil.keccak(value as Buffer);
     }
 
 }

package/src/utils/$txData.ts

@@ -0,0 +1,16 @@
+import type { TransactionRequest } from '@ethersproject/abstract-provider';
+
+export namespace $txData {
+    export function getJson(txData: TransactionRequest, defaults?: { defaultTxType?: number, chainId?: number}): TransactionRequest {
+        let json = <TransactionRequest> {
+            ...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;
+    }
+}

package/src/utils/$wallet.ts

@@ -1,4 +1,4 @@
-import { ChainAccount } from '@dequanto/ChainAccounts';
+import { ChainAccount } from "@dequanto/models/TAccount";
 import { Wallet, utils } from 'ethers';
 
 export namespace $wallet {