dequanto 0.0.1

package/src/utils/$number.ts

@@ -0,0 +1,89 @@
+import { $require } from './$require';
+
+export namespace $number {
+
+    export function div (a: number, b: number, digits: number = 5) {
+        let r = 10 ** digits;
+        return Math.round(a * r / b) / r;
+    }
+
+    /**
+     * [min, max)
+     * @param min: includes
+     * @param max: excludes
+     */
+     export function random(min: number, max: number) {
+        $require.True(min < max, `Random Int expects max to be greater then min: ${min}..${max}`);
+        return Math.random() * (max - min) + min;
+    }
+    /**
+     * [min, max)
+     * @param min: includes
+     * @param max: excludes
+     */
+    export function randomInt(min: number, max: number) {
+        $require.True(min < max, `Random Int expects max to be greater then min: ${min}..${max}`);
+        return Math.floor(Math.random() * (max - min)) + min;
+    }
+    /**
+     * [min, max)
+     * @param min: includes
+     * @param max: excludes
+     */
+    export function randomFloat(min: number, max: number, decimals: number = 0) {
+        let decimalsFromNumber = 0;
+        while (min * 10 ** decimalsFromNumber % 1 > 0 || max * 10 ** decimalsFromNumber % 1 > 0) {
+            decimalsFromNumber++;
+        }
+        let val = 10 ** Math.max(decimals, decimalsFromNumber);
+        return randomInt(min * val, max * val) / val;
+    }
+    export function parse (mix: string | number) {
+        if (!mix) return 0;
+        if (typeof mix === 'number') {
+            return mix;
+        }
+        return parseFloat(mix.replace(/,+/g, '.'));
+    }
+    export function round (mix: string | number, digits: number = 0, round: 'ceil' | 'round' | 'floor' = 'round') {
+        let number = typeof mix === 'string' ? Number(mix) : mix;
+        if (isNaN(number)) {
+            return number;
+        }
+        let factor = Math.pow(10, digits);
+        let val = number * factor;
+        let e = val - (val | 0);
+        if (e < 0) {
+            e *= -1;
+        }
+        if (e < .0001) {
+            val = val | 0;
+        }
+        return Math[round](val) / factor;
+    }
+    export function parseOptional (mix, default_ = null) {
+        if (mix == null) {
+            return default_;
+        }
+        if (typeof mix === 'number') {
+            return mix;
+        }
+        if (typeof mix === 'string') {
+
+            switch (mix.toLowerCase()) {
+                case 'einweg':
+                    return 0.25;
+                case 'mehrweg':
+                    return 0.15;
+            }
+
+            let num = parseFloat(mix.replace(/,+/g, '.'));
+            if (Number.isFinite(num) === false) {
+                return default_;
+            }
+            return num;
+        }
+        throw new Error('Unsupported type to convert to number ' + typeof mix);
+    }
+
+}

package/src/utils/$object.ts

@@ -0,0 +1,95 @@
+import { is_rawObject, is_ArrayLike, is_Object } from 'atma-utils';
+
+
+interface IObjectCleanOpts {
+    removePrivate?: boolean
+    skipProperties?: { [key: string]: any }
+    ignoreProperties?: { [key: string]: any }
+    strictProperties?: { [key: string]: any }
+    deep?: boolean
+    removeEmptyArrays?: boolean
+    removeFalsy?: boolean
+    shouldRemove?(key: string, val: any): boolean
+}
+
+export namespace $object {
+    export function clean<T extends any>(json: T, opts: IObjectCleanOpts = {
+        removePrivate: false,
+        skipProperties: null,
+        removeEmptyArrays: false,
+        removeFalsy: false
+    }): T {
+        if (json == null || typeof json !== 'object') {
+            return json;
+        }
+
+        if (is_ArrayLike(json)) {
+            let arr = json as any[];
+            let i = 0;
+            let notNullIndex = -1;
+            for (; i < arr.length; i++) {
+                let val = arr[i];
+                if (val != null) {
+                    notNullIndex = i;
+                }
+                $object.clean(val, opts);
+            }
+            // clean all last nullable values
+            if (notNullIndex + 1 < arr.length) {
+                arr.splice(notNullIndex + 1);
+            }
+            return json;
+        }
+
+        if (is_Object(json)) {
+            for (let key in json) {
+                if (opts.skipProperties != null && key in opts.skipProperties) {
+                    delete json[key];
+                    continue;
+                }
+                if (opts.ignoreProperties != null && key in opts.ignoreProperties) {
+                    continue;
+                }
+                if (opts.removePrivate === true && key[0] === '_') {
+                    delete json[key];
+                    continue;
+                }
+                let val = json[key];
+                if (opts.shouldRemove?.(key, val)) {
+                    delete json[key];
+                    continue;
+                }
+                if (isDefault(val, opts)) {
+                    if (opts.strictProperties != null && key in opts.strictProperties && val != null) {
+                        continue;
+                    }
+                    delete json[key];
+                    continue;
+                }
+                if (opts.deep !== false) {
+                    $object.clean(val, opts);
+                }
+                if (opts.removeEmptyArrays && is_ArrayLike(val) && val.length === 0) {
+                    delete json[key];
+                }
+            }
+            return json;
+        }
+
+        return json;
+    }
+
+
+    function isDefault(x, opts) {
+        if (x == null) {
+            return true;
+        }
+        if (opts.removeFalsy && (x === '' || x === false)) {
+            return true;
+        }
+        if (opts.removeEmptyArrays && is_ArrayLike(x) && x.length === 0) {
+            return true;
+        }
+        return false;
+    }
+}

package/src/utils/$path.ts

@@ -0,0 +1,32 @@
+import { class_Uri } from 'atma-utils';
+
+export namespace $path {
+    let root: string = null;
+
+    export function resolve (path: string) {
+
+        return class_Uri.combine(root ?? (root = getRoot()), path)
+    }
+
+    function getRoot () {
+        let uri = new class_Uri('file://' + __dirname + '/');
+        while (true) {
+            let dir = getDirName(uri.path);
+            if (!dir || dir === '/') {
+                throw new Error(`Root path not resolved: ${__dirname}`);
+            }
+            if (dir === 'lib' || dir === 'src') {
+                uri = uri.cdUp();
+                let path = uri.toString();
+                if (/dequanto/.test(path) === false) {
+                    path = uri.combine('dequanto').toString();
+                }
+                return path;
+            }
+            uri = uri.cdUp();
+        }
+    }
+    function getDirName (path: string) {
+        return /\/?([^\/]+)\/?$/.exec(path)?.[1];
+    }
+}

package/src/utils/$promise.ts

@@ -0,0 +1,7 @@
+export namespace $promise {
+    export function wait (ms) {
+        return new Promise(resolve => {
+            setTimeout(resolve, ms);
+        });
+    };
+}

package/src/utils/$require.ts

@@ -0,0 +1,118 @@
+import { IToken } from '@dequanto/models/IToken';
+import { TAddress } from '@dequanto/models/TAddress';
+import { $is } from './$is';
+
+export namespace $require {
+    export function Number <T> (val: T, message: string = '', opts?: { min?: T, max?: T}): T {
+        if (typeof val !== 'number') {
+            throw new Error(`Expects number type, got ${typeof val} ${val}. ${message}`);
+        }
+        if (isNaN(val)) {
+            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;
+    }
+    export function BigInt<T> (val: T, message: string = '', opts?: { min?: T, max?: T}): T {
+        if (typeof val !== 'bigint') {
+            throw new Error(`Expects bigint type, got ${typeof val} (${val}). ${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;
+    }
+    export function Numeric<T>(val: T, message: string = '', opts?: { min?: T, max?: T}): T {
+        if (typeof val === 'number') {
+            return Number(val, message, opts);
+        }
+        if (typeof val === 'bigint') {
+            return BigInt(val, message, opts);
+        }
+        throw new Error(`Expects numeric type, got ${typeof val}. ${message}`);
+    }
+
+    export function Function<T>(val: T, message: string): T {
+        if (typeof val !== 'function') {
+            throw new Error(`Value is not a function`);
+        }
+        return val;
+    }
+    export function notNull<T> (val: T, message: string): T {
+        if (val == null) {
+            throw new Error(`Value is undefined. ${message}`);
+        }
+        return val;
+    }
+
+    export function True(value: boolean, message: string) {
+        if (value !== true) {
+            throw new Error(`Got false expression ${message}`);
+        }
+    }
+    export function notEq<T = any>(a: T, b: T, message: string = '') {
+        // not strict equal
+        if (a == b) {
+            throw new Error(`${a} and ${b} shouldn't be equal. ${message}`)
+        }
+    }
+    export function eq<T = any>(a: T, b: T, message: string = '') {
+        // not strict equal
+        if (a != b) {
+            throw new Error(`${a} and ${b} should be equal. ${message}`)
+        }
+    }
+    export function match (rgx: RegExp, str: string, message = '') {
+        if (typeof str !== 'string') {
+            throw new Error(`Expected a string to find in. ${message}`);
+        }
+        if (rgx.test(str) === false) {
+            throw new Error(`Expected string "${str}" to match ${rgx.toString()}. ${message}`);
+        }
+    }
+    export function oneOf<T = any>(a: T, arr: T[], message: string = '') {
+        // not strict equal
+        if (arr.includes(a) === false) {
+            throw new Error(`${a} should be one of ${arr.join(', ')}. ${message}`)
+        }
+    }
+
+    export function Address (val: TAddress, message: string = ''): TAddress {
+        if ($is.Address(val) === false) {
+            throw new Error(`Value ${val} is not a valid address. ${message}`);
+        }
+        return val;
+    }
+    export function Token (token: IToken, message: string = ''): IToken {
+        if (token == null) {
+            throw new Error(`Token is undefined. ${message}`);
+        }
+        if (token.address == null) {
+            throw new Error(`Token address property is undefined. ${message}`);
+        }
+        if (token.decimals == null) {
+            throw new Error(`Token decimals property is undefined. ${message}`);
+        }
+        return token;
+    }
+
+    /**
+     * throws when a <= b
+     */
+    export function gt<T = number | bigint> (a: T, b: T, message: string = '') {
+        Numeric(a);
+        Numeric(b);
+
+        if (a <= b) {
+            throw new Error(`Expected a(${a}) > b(${b}). ${message}`);
+        }
+    }
+}

package/src/utils/$sign.ts

@@ -0,0 +1,36 @@
+import { hashPersonalMessage, ecsign } from 'ethereumjs-util';
+
+export namespace $sign {
+    export function signEC (message: string | Buffer, privateKey: string | Buffer) {
+        const sig = 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}`
+        }
+    }
+    export function signEIPHashed (message: string | Buffer, privateKey: string) {
+        const hash = hashPersonalMessage(toBuffer(message, { encoding: 'utf8' }));
+        return signEC(hash, privateKey);
+    }
+
+    function toBuffer (message: string | Buffer, opts?: { encoding?: 'utf8' | 'hex' }) {
+        if (typeof message === 'string') {
+            if (/^0x[\da-f]+$/i.test(message)) {
+                return Buffer.from(message.substring(2), 'hex');
+            }
+            return Buffer.from(message, opts?.encoding ?? 'utf8');
+        }
+        return message;
+    }
+}