dequanto 0.0.1

package/src/utils/$array.ts

@@ -0,0 +1,57 @@
+export namespace $array {
+    export function upsert<T>(arr: T[], x:T, matcher: (x: T) => boolean, opts?: { patch: boolean }) {
+        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;
+    }
+
+    export function remove<T>(arr: T[], matcher: (x: T) => boolean): T[]
+    export function remove<T>(arr: T[], item: T): T[]
+    export function remove<T>(arr: T[], x: any): T[] {
+        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);
+        }
+    }
+
+    export function replace<T>(arr: T[], item:T, matcher: (x: T, item: T, i: number) => boolean) {
+        for (let i = 0; i < arr.length; i++) {
+            if (matcher(arr[i], item, i)) {
+                arr[i] = item;
+            }
+        }
+        arr.push(item);
+    }
+
+    export function shuffle <T> (arr: T[]): T[]  {
+        return arr.sort(() => Math.random() - 0.5);
+    }
+}

package/src/utils/$bigint.ts

@@ -0,0 +1,127 @@
+import { $is } from './$is';
+
+export namespace $bigint {
+
+    export const ETHER_DECIMALS = 18;
+    export const GWEI_DECIMALS = 9;
+
+    export function max(...args: bigint[]): bigint {
+        let max: bigint = null;
+        for (let i = 0; i < args.length; i++) {
+            let val = args[i];
+            if (max == null || max < val) {
+                max = val;
+            }
+        }
+        return max;
+    }
+    export function min(...args: bigint[]): bigint {
+        let min:bigint = null;
+        for (let i = 0; i < args.length; i++) {
+            let val = args[i];
+            if (min == null || min > val) {
+                min = val;
+            }
+        }
+        return min;
+    }
+
+    export function toBigInt (amount: string | number | bigint): bigint {
+        if (typeof amount === 'bigint') {
+            return amount;
+        }
+        if (typeof amount === 'string') {
+            amount = Number(amount);
+        }
+        return BigInt(Math.round(amount));
+    }
+
+    export function ensureWei (amount: number | bigint, decimals: number) {
+        if (typeof amount === 'number') {
+            return toWei(amount, decimals);
+        }
+        return amount;
+    }
+    export function toWei (amount: string | number | bigint, decimals: number | string = 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;
+    }
+    export function toWeiFromGwei(amount: string | number | bigint) {
+        return toWei(amount, GWEI_DECIMALS);
+    }
+
+    export function toEther (amount: string | number | bigint, decimals: number | string = ETHER_DECIMALS, round = 100000n): number {
+        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}`);
+    }
+
+    export function toEtherSafe (amount: string | number | bigint, decimals: number | string = ETHER_DECIMALS, round = 100000n): number | bigint {
+        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;
+    }
+
+    export function toHex (num: bigint) {
+        return `0x${num.toString(16)}`;
+    }
+
+    export function toGweiFromWei (val: bigint) {
+        return toEther(val, GWEI_DECIMALS);
+    }
+    export function toGweiFromEther (val: number) {
+        return toWei(val, GWEI_DECIMALS);
+    }
+
+    export function multWithFloat (bigInt: bigint, float: number) {
+        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;
+    }
+
+    export function divToFloat (a: bigint, b: bigint, precision = 100_000n): number {
+        $is.BigInt(a);
+        $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}`)
+    }
+
+    export function pow (basis: bigint | number, exponent: number | bigint): bigint {
+        let $base = typeof basis === 'number' ? BigInt(Math.round(basis)) : basis;
+        let $exp = typeof exponent === 'number' ? BigInt(exponent) : exponent;
+
+        return $base ** $exp;
+    }
+}

package/src/utils/$block.ts

@@ -0,0 +1,7 @@
+import { BlockTransactionBase } from 'web3-eth'
+
+export namespace $block {
+    export function getDate(block: { timestamp: string | number }) {
+        return new Date(Number(block.timestamp) * 1000);
+    }
+}

package/src/utils/$class.ts

@@ -0,0 +1,8 @@
+export namespace $class {
+    export function curry<T, TMix> (entity: T, extend: TMix): T & TMix {
+        let cloned = Object.assign({}, entity, extend);
+        let proto = Object.getPrototypeOf(entity);
+        Object.setPrototypeOf(cloned, proto);
+        return cloned;
+    }
+}

package/src/utils/$config.ts

@@ -0,0 +1,17 @@
+import { config } from '@dequanto/Config';
+import { obj_getProperty } from 'atma-utils';
+
+declare let global;
+
+export namespace $config {
+    export function get <T = any> (path: string, $default?: T): T {
+        let value = (typeof global.app !== 'undefined' ? global.app.config?.$get?.(path) : null)
+            ?? obj_getProperty(config, path)
+            ?? $default;
+
+        if (value == null) {
+            //-throw new Error(`Config data is undefined for ${path}`);
+        }
+        return value;
+    }
+}

package/src/utils/$contract.ts

@@ -0,0 +1,67 @@
+import Web3 from 'web3';
+import { AbiItem } from 'web3-utils';
+import { Log, TransactionReceipt } from 'web3-core';
+import { $abiUtils } from './$abiUtils';
+import { InputDataUtils } from '@dequanto/contracts/utils/InputDataUtils';
+import { ITxLogItem } from '@dequanto/txs/receipt/ITxLogItem';
+
+export namespace $contract {
+    export function keccak256 (str: string) {
+        return Web3.utils.keccak256(str);
+    }
+
+    export function normalizeArgs (args: any[]) {
+        return args.map(val => {
+            if (val?._isBigNumber) {
+                return BigInt(val.toString());
+            }
+            if (Array.isArray(val)) {
+                return normalizeArgs(val);
+            }
+            return val;
+        })
+    }
+
+    export function extractLogsForAbi (tx: TransactionReceipt, abiItem: AbiItem): ITxLogItem[] {
+        let topicHash = $abiUtils.getMethodHash(abiItem);
+        let logs = tx
+            .logs
+            .filter(log => {
+                return log.topics[0] === topicHash;
+            })
+            .map(log => {
+                return parseLogWithAbi(log, abiItem);
+            })
+        return logs;
+    }
+
+    export function parseLogWithAbi(log: Log, abiItem: AbiItem): ITxLogItem {
+        let inputs = abiItem.inputs.slice();
+        let args = log.topics.slice(1).map((bytes, i) => {
+            let type = inputs.shift();
+            let val = InputDataUtils.decode([ type ], bytes);
+
+            return {
+                name: type.name,
+                value: val[0]
+            }
+        });
+
+        if (inputs.length > 0) {
+            let values = 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,
+        };
+    }
+}

package/src/utils/$csv.ts

@@ -0,0 +1,54 @@
+import * as Papa from 'papaparse'
+
+export namespace $csv {
+    export function stringify(data: { header?: string[], rows: (any[])[]}) {
+        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;
+    }
+
+    export function parseToObjects <T = any> (csv, columns: string[], opts?: { hasHeader: boolean }): T[] {
+        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 = {} as T;
+            columns.map((key, i) => {
+                if (key) {
+                    obj[key] = row[i];
+                }
+            });
+            return obj;
+        }).filter(Boolean);
+    }
+
+    export function parseToRows (csv): string[][] {
+        let result = Papa.parse(csv);
+        let rows = result.data;
+        return rows;
+    }
+}