dequanto 0.0.1

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$number = void 0;
+const _require_1 = require("./$require");
+var $number;
+(function ($number) {
+    function div(a, b, digits = 5) {
+        let r = 10 ** digits;
+        return Math.round(a * r / b) / r;
+    }
+    $number.div = div;
+    /**
+     * [min, max)
+     * @param min: includes
+     * @param max: excludes
+     */
+    function random(min, max) {
+        _require_1.$require.True(min < max, `Random Int expects max to be greater then min: ${min}..${max}`);
+        return Math.random() * (max - min) + min;
+    }
+    $number.random = random;
+    /**
+     * [min, max)
+     * @param min: includes
+     * @param max: excludes
+     */
+    function randomInt(min, max) {
+        _require_1.$require.True(min < max, `Random Int expects max to be greater then min: ${min}..${max}`);
+        return Math.floor(Math.random() * (max - min)) + min;
+    }
+    $number.randomInt = randomInt;
+    /**
+     * [min, max)
+     * @param min: includes
+     * @param max: excludes
+     */
+    function randomFloat(min, max, decimals = 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;
+    }
+    $number.randomFloat = randomFloat;
+    function parse(mix) {
+        if (!mix)
+            return 0;
+        if (typeof mix === 'number') {
+            return mix;
+        }
+        return parseFloat(mix.replace(/,+/g, '.'));
+    }
+    $number.parse = parse;
+    function round(mix, digits = 0, round = '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;
+    }
+    $number.round = round;
+    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);
+    }
+    $number.parseOptional = parseOptional;
+})($number = exports.$number || (exports.$number = {}));

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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$object = void 0;
+const atma_utils_1 = require("atma-utils");
+var $object;
+(function ($object) {
+    function clean(json, opts = {
+        removePrivate: false,
+        skipProperties: null,
+        removeEmptyArrays: false,
+        removeFalsy: false
+    }) {
+        if (json == null || typeof json !== 'object') {
+            return json;
+        }
+        if ((0, atma_utils_1.is_ArrayLike)(json)) {
+            let arr = json;
+            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 ((0, atma_utils_1.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 && (0, atma_utils_1.is_ArrayLike)(val) && val.length === 0) {
+                    delete json[key];
+                }
+            }
+            return json;
+        }
+        return json;
+    }
+    $object.clean = clean;
+    function isDefault(x, opts) {
+        if (x == null) {
+            return true;
+        }
+        if (opts.removeFalsy && (x === '' || x === false)) {
+            return true;
+        }
+        if (opts.removeEmptyArrays && (0, atma_utils_1.is_ArrayLike)(x) && x.length === 0) {
+            return true;
+        }
+        return false;
+    }
+})($object = exports.$object || (exports.$object = {}));

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$path = void 0;
+const atma_utils_1 = require("atma-utils");
+var $path;
+(function ($path) {
+    let root = null;
+    function resolve(path) {
+        return atma_utils_1.class_Uri.combine(root ?? (root = getRoot()), path);
+    }
+    $path.resolve = resolve;
+    function getRoot() {
+        let uri = new atma_utils_1.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) {
+        return /\/?([^\/]+)\/?$/.exec(path)?.[1];
+    }
+})($path = exports.$path || (exports.$path = {}));

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$promise = void 0;
+var $promise;
+(function ($promise) {
+    function wait(ms) {
+        return new Promise(resolve => {
+            setTimeout(resolve, ms);
+        });
+    }
+    $promise.wait = wait;
+    ;
+})($promise = exports.$promise || (exports.$promise = {}));

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$require = void 0;
+const _is_1 = require("./$is");
+var $require;
+(function ($require) {
+    function Number(val, message = '', opts) {
+        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;
+    }
+    $require.Number = Number;
+    function BigInt(val, message = '', opts) {
+        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;
+    }
+    $require.BigInt = BigInt;
+    function Numeric(val, message = '', opts) {
+        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}`);
+    }
+    $require.Numeric = Numeric;
+    function Function(val, message) {
+        if (typeof val !== 'function') {
+            throw new Error(`Value is not a function`);
+        }
+        return val;
+    }
+    $require.Function = Function;
+    function notNull(val, message) {
+        if (val == null) {
+            throw new Error(`Value is undefined. ${message}`);
+        }
+        return val;
+    }
+    $require.notNull = notNull;
+    function True(value, message) {
+        if (value !== true) {
+            throw new Error(`Got false expression ${message}`);
+        }
+    }
+    $require.True = True;
+    function notEq(a, b, message = '') {
+        // not strict equal
+        if (a == b) {
+            throw new Error(`${a} and ${b} shouldn't be equal. ${message}`);
+        }
+    }
+    $require.notEq = notEq;
+    function eq(a, b, message = '') {
+        // not strict equal
+        if (a != b) {
+            throw new Error(`${a} and ${b} should be equal. ${message}`);
+        }
+    }
+    $require.eq = eq;
+    function match(rgx, str, 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}`);
+        }
+    }
+    $require.match = match;
+    function oneOf(a, arr, message = '') {
+        // not strict equal
+        if (arr.includes(a) === false) {
+            throw new Error(`${a} should be one of ${arr.join(', ')}. ${message}`);
+        }
+    }
+    $require.oneOf = oneOf;
+    function Address(val, message = '') {
+        if (_is_1.$is.Address(val) === false) {
+            throw new Error(`Value ${val} is not a valid address. ${message}`);
+        }
+        return val;
+    }
+    $require.Address = Address;
+    function Token(token, message = '') {
+        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;
+    }
+    $require.Token = Token;
+    /**
+     * throws when a <= b
+     */
+    function gt(a, b, message = '') {
+        Numeric(a);
+        Numeric(b);
+        if (a <= b) {
+            throw new Error(`Expected a(${a}) > b(${b}). ${message}`);
+        }
+    }
+    $require.gt = gt;
+})($require = exports.$require || (exports.$require = {}));

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$sign = void 0;
+const ethereumjs_util_1 = require("ethereumjs-util");
+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);
+        return {
+            v: `0x${v}`,
+            r: `0x${r}`,
+            s: `0x${s}`,
+            signature: `0x${r}${s}${v}`,
+            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);
+    }
+    $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');
+            }
+            return Buffer.from(message, opts?.encoding ?? 'utf8');
+        }
+        return message;
+    }
+})($sign = exports.$sign || (exports.$sign = {}));

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

@@ -0,0 +1,264 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$signSerializer = void 0;
+const ethUtil = __importStar(require("ethereumjs-util"));
+const ethAbi = __importStar(require("ethereumjs-abi"));
+var $signSerializer;
+(function ($signSerializer) {
+    const TYPED_MESSAGE_SCHEMA = {
+        type: 'object',
+        properties: {
+            types: {
+                type: 'object',
+                additionalProperties: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            type: { type: 'string' },
+                        },
+                        required: ['name', 'type'],
+                    },
+                },
+            },
+            primaryType: { type: 'string' },
+            domain: { type: 'object' },
+            message: { type: 'object' },
+        },
+        required: ['types', 'primaryType', 'domain', 'message'],
+    };
+    function serializeTypedData(data, version = 'V4') {
+        let serializer = new TypedDataSerializer();
+        switch (version) {
+            case 'V3':
+                return serializer.serialize(data, false);
+            case 'V4':
+            default:
+                return serializer.serialize(data, true);
+        }
+    }
+    $signSerializer.serializeTypedData = serializeTypedData;
+    /**
+     * A collection of utility functions used for signing typed data
+     */
+    class TypedDataSerializer {
+        /**
+         * Encodes an object by encoding and concatenating each of its members
+         *
+         * @param {string} primaryType - Root type
+         * @param {Object} data - Object to encode
+         * @param {Object} types - Type definitions
+         * @returns {Buffer} - Encoded representation of an object
+         */
+        encodeData(primaryType, data, types, useV4 = true) {
+            const encodedTypes = ['bytes32'];
+            const encodedValues = [this.hashType(primaryType, types)];
+            if (useV4) {
+                const encodeField = (name, type, value) => {
+                    if (types[type] !== undefined) {
+                        return [
+                            'bytes32',
+                            value == null // eslint-disable-line no-eq-null
+                                ? '0x0000000000000000000000000000000000000000000000000000000000000000'
+                                : ethUtil_keccak(this.encodeData(type, value, types, useV4)),
+                        ];
+                    }
+                    if (value === undefined) {
+                        throw new Error(`missing value for field ${name} of type ${type}`);
+                    }
+                    if (type === 'bytes') {
+                        return ['bytes32', ethUtil_keccak(value)];
+                    }
+                    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');
+                        }
+                        return ['bytes32', ethUtil_keccak(value)];
+                    }
+                    if (type.lastIndexOf(']') === type.length - 1) {
+                        const parsedType = type.slice(0, type.lastIndexOf('['));
+                        const typeValuePairs = value.map((item) => encodeField(name, parsedType, item));
+                        return [
+                            'bytes32',
+                            ethUtil_keccak(ethAbi.rawEncode(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v))),
+                        ];
+                    }
+                    return [type, value];
+                };
+                for (const field of types[primaryType]) {
+                    const [type, value] = encodeField(field.name, field.type, data[field.name]);
+                    encodedTypes.push(type);
+                    encodedValues.push(value);
+                }
+            }
+            else {
+                for (const field of types[primaryType]) {
+                    let value = data[field.name];
+                    if (value !== undefined) {
+                        if (field.type === 'bytes') {
+                            encodedTypes.push('bytes32');
+                            value = ethUtil_keccak(value);
+                            encodedValues.push(value);
+                        }
+                        else if (field.type === 'string') {
+                            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 = ethUtil_keccak(value);
+                            encodedValues.push(value);
+                        }
+                        else if (types[field.type] !== undefined) {
+                            encodedTypes.push('bytes32');
+                            value = ethUtil_keccak(this.encodeData(field.type, value, types, useV4));
+                            encodedValues.push(value);
+                        }
+                        else if (field.type.lastIndexOf(']') === field.type.length - 1) {
+                            throw new Error('Arrays are unimplemented in encodeData; use V4 extension');
+                        }
+                        else {
+                            encodedTypes.push(field.type);
+                            encodedValues.push(value);
+                        }
+                    }
+                }
+            }
+            return ethAbi.rawEncode(encodedTypes, encodedValues);
+        }
+        /**
+         * Encodes the type of an object by encoding a comma delimited list of its members
+         *
+         * @param {string} primaryType - Root type to encode
+         * @param {Object} types - Type definitions
+         * @returns {string} - Encoded representation of the type of an object
+         */
+        encodeType(primaryType, types) {
+            let result = '';
+            let deps = this.findTypeDependencies(primaryType, types).filter((dep) => dep !== primaryType);
+            deps = [primaryType].concat(deps.sort());
+            for (const type of deps) {
+                const children = types[type];
+                if (!children) {
+                    throw new Error(`No type definition specified: ${type}`);
+                }
+                result += `${type}(${types[type]
+                    .map(({ name, type: t }) => `${t} ${name}`)
+                    .join(',')})`;
+            }
+            return result;
+        }
+        /**
+         * Finds all types within a type definition object
+         *
+         * @param {string} primaryType - Root type
+         * @param {Object} types - Type definitions
+         * @param {Array} results - current set of accumulated types
+         * @returns {Array} - Set of all types found in the type definition
+         */
+        findTypeDependencies(primaryType, types, results = []) {
+            [primaryType] = primaryType.match(/^\w*/u);
+            if (results.includes(primaryType) || types[primaryType] === undefined) {
+                return results;
+            }
+            results.push(primaryType);
+            for (const field of types[primaryType]) {
+                for (const dep of this.findTypeDependencies(field.type, types, results)) {
+                    !results.includes(dep) && results.push(dep);
+                }
+            }
+            return results;
+        }
+        /**
+         * Hashes an object
+         *
+         * @param {string} primaryType - Root type
+         * @param {Object} data - Object to hash
+         * @param {Object} types - Type definitions
+         * @returns {Buffer} - Hash of an object
+         */
+        hashStruct(primaryType, data, types, useV4 = true) {
+            return ethUtil_keccak(this.encodeData(primaryType, data, types, useV4));
+        }
+        /**
+         * Hashes the type of an object
+         *
+         * @param {string} primaryType - Root type to hash
+         * @param {Object} types - Type definitions
+         * @returns {Buffer} - Hash of an object
+         */
+        hashType(primaryType, types) {
+            return ethUtil_keccak(this.encodeType(primaryType, types));
+        }
+        /**
+         * Removes properties from a message object that are not defined per EIP-712
+         *
+         * @param {Object} data - typed message object
+         * @returns {Object} - typed message object with only allowed fields
+         */
+        sanitizeData(data) {
+            const sanitizedData = {};
+            for (const key in TYPED_MESSAGE_SCHEMA.properties) {
+                if (data[key]) {
+                    sanitizedData[key] = data[key];
+                }
+            }
+            if ('types' in sanitizedData) {
+                sanitizedData.types = { EIP712Domain: [], ...sanitizedData.types };
+            }
+            return sanitizedData;
+        }
+        /**
+         * Signs a typed message as per EIP-712 and returns its keccak hash
+         *
+         * @param {Object} typedData - Types message data to sign
+         * @returns {Buffer} - keccak hash of the resulting signed message
+         */
+        serialize(typedData, useV4 = true) {
+            const sanitizedData = this.sanitizeData(typedData);
+            const parts = [Buffer.from('1901', 'hex')];
+            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));
+        }
+    }
+    ;
+    function ethUtil_keccak(value) {
+        if (typeof value === 'string') {
+            if (value.startsWith('0x')) {
+                value = Buffer.from(value.substring(2), 'hex');
+            }
+            else {
+                value = Buffer.from(value);
+            }
+        }
+        return ethUtil.keccak(value);
+    }
+})($signSerializer = exports.$signSerializer || (exports.$signSerializer = {}));

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$wallet = void 0;
+const ethers_1 = require("ethers");
+var $wallet;
+(function ($wallet) {
+    async function ecdsaSign(account, message) {
+        let wallet = new ethers_1.Wallet(account.key);
+        let signature = await wallet.signMessage(message);
+        return signature;
+    }
+    $wallet.ecdsaSign = ecdsaSign;
+})($wallet = exports.$wallet || (exports.$wallet = {}));

package/dist/src/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });