@ultrade/shared 1.0.0

package/dist/common/utils/decode.js

@@ -0,0 +1,206 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("algosdk"));
+	else if(typeof define === 'function' && define.amd)
+		define(["algosdk"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("algosdk")) : factory(root["algosdk"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, (__WEBPACK_EXTERNAL_MODULE__9709__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 3450:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.printUnpackedLocalData = exports.getAccounInfoFormLocalStorage = void 0;
+exports.unpackData = unpackData;
+exports.decodeString = decodeString;
+const algosdk_1 = __importStar(__webpack_require__(9709));
+const orderByteSize = 28;
+const getAccounInfoFormLocalStorage = (localState) => {
+    const uintArray = Buffer.from(localState, 'base64');
+    const unpackedData = unpackData(uintArray, {
+        "priceCoin_locked": {
+            type: "uint",
+        },
+        "priceCoin_available": {
+            type: "uint",
+        },
+        "baseCoin_locked": {
+            type: "uint",
+        },
+        "baseCoin_available": {
+            type: "uint",
+        },
+        "companyId": {
+            type: "uint",
+        },
+        "WLFeeShare": {
+            type: "uint",
+        },
+        "WLCustomFee": {
+            type: "uint",
+        },
+        "slotMap": {
+            type: "uint",
+        },
+    });
+    return unpackedData;
+};
+exports.getAccounInfoFormLocalStorage = getAccounInfoFormLocalStorage;
+function unpackData(data, format) {
+    const result = new Map();
+    let index = 0;
+    for (const [name, type] of Object.entries(format)) {
+        if (index >= data.length) {
+            throw new Error('Array index out of bounds');
+        }
+        let value;
+        switch (type.type) {
+            case 'address':
+                value = (0, algosdk_1.encodeAddress)(data.slice(index, index + 32));
+                index += 32;
+                break;
+            case 'bytes':
+                value = data.slice(index, index + type.size);
+                value = algosdk_1.default.decodeUint64(value, "mixed");
+                index += type.size;
+                break;
+            case 'uint':
+                value = algosdk_1.default.decodeUint64(data.slice(index, index + 8), "mixed");
+                index += 8;
+                break;
+            case 'string':
+                value = decodeString(data.slice(index, index + type.size));
+                index += type.size;
+                break;
+        }
+        result.set(name, value);
+    }
+    return Object.fromEntries(result);
+}
+function decodeString(value) {
+    return Buffer.from(value).toString('utf-8');
+}
+const printUnpackedLocalData = (localState) => {
+    const uintArray = Buffer.from(localState, 'base64');
+    const unpackedData = [];
+    for (let i = 0; i < 4; i++) {
+        let data = unpackData(uintArray.subarray(orderByteSize * i, orderByteSize * (i + 1)), {
+            "orderID": {
+                type: "uint",
+            },
+            "side": {
+                type: "string",
+                size: 1
+            },
+            "price": {
+                type: "uint",
+            },
+            "amount": {
+                type: "uint",
+            },
+            "type": {
+                type: "string",
+                size: 1
+            },
+            "directSettle": {
+                type: "string",
+                size: 1
+            },
+            "storageSlot": {
+                type: "bytes",
+                size: 1
+            }
+        });
+        unpackedData.push(data);
+    }
+    return unpackedData;
+};
+exports.printUnpackedLocalData = printUnpackedLocalData;
+
+
+/***/ }),
+
+/***/ 9709:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__9709__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(3450);
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/common/utils/index.d.ts

@@ -0,0 +1,9 @@
+export declare const listDateFormat: (date: Date | number) => string;
+export declare const equalIgnoreCase: (value1: string | number, value2: string | number) => boolean;
+export declare function getRandomInt(min: number, max: number): number;
+export declare function getDomains(domain: string): string[];
+export declare function cutEvent(event: any): {
+    [k: string]: any;
+};
+export declare function maskingString(str: string): string;
+export declare function removeField(obj: any, fieldToRemove: string): any;

package/dist/common/utils/index.js

@@ -0,0 +1,122 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.equalIgnoreCase = exports.listDateFormat = void 0;
+exports.getRandomInt = getRandomInt;
+exports.getDomains = getDomains;
+exports.cutEvent = cutEvent;
+exports.maskingString = maskingString;
+exports.removeField = removeField;
+const listDateFormat = (date) => {
+    let newDAte = new Date(date);
+    let parsedDate = newDAte.toLocaleDateString('default', {
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+    });
+    let time = newDAte.toLocaleTimeString('en-US', {
+        hour12: true,
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+    return parsedDate + ' ' + time;
+};
+exports.listDateFormat = listDateFormat;
+const equalIgnoreCase = (value1, value2) => {
+    return String(value1).toLowerCase() === String(value2).toLowerCase();
+};
+exports.equalIgnoreCase = equalIgnoreCase;
+function getRandomInt(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function getDomains(domain) {
+    const domains = [];
+    const parts = domain.split('.');
+    for (let i = 0; i < parts.length - 1; i++) {
+        domains.push(parts.slice(i).join('.'));
+    }
+    return domains;
+}
+;
+function cutEvent(event) {
+    const headers = event.headers && removeUndefined({
+        'Authorization': event.headers['Authorization']?.substring(0, 200),
+        'CloudFront-Viewer-Country': event.headers['CloudFront-Viewer-Country'],
+        'Host': event.headers['Host'],
+        'origin': event.headers['origin'],
+        'Referer': event.headers['Referer'],
+        'User-Agent': event.headers['User-Agent'],
+        'wl-domain': event.headers['wl-domain'],
+        'X-API-Key': maskingString(event.headers['X-API-Key']),
+        'X-Forwarded-For': event.headers['X-Forwarded-For'],
+        'X-Forwarded-Port': event.headers['X-Forwarded-Port'],
+        'X-Forwarded-Proto': event.headers['X-Forwarded-Proto'],
+        'X-Trading-Key': event.headers['X-Trading-Key'],
+        'X-Wallet-Address': event.headers['X-Wallet-Address'],
+        'X-Wallet-Token': event.headers['X-Wallet-Token'],
+        'accessToken': maskingString(event.headers['accessToken']),
+        'companyId': event.headers['companyId'],
+        'seasonId': event.headers['seasonId'],
+    });
+    const requestContext = event.requestContext && removeUndefined({
+        identity: event.requestContext.identity && removeUndefined({
+            'userAgent': event.requestContext.identity['userAgent'],
+            'sourceIp': event.requestContext.identity['sourceIp'],
+        }),
+        domainName: event.requestContext.domainName,
+    });
+    return removeUndefined({
+        manage: event.manage,
+        path: event.path,
+        httpMethod: event.httpMethod,
+        headers,
+        requestContext,
+    });
+}
+function maskingString(str) {
+    if (!str?.length)
+        return str;
+    const maskLen = Math.round(str.length / 3);
+    const start = maskLen;
+    const end = str.length - maskLen;
+    const maskedStr = str.substring(0, start) + "*".repeat(maskLen) + str.substring(end);
+    return maskedStr;
+}
+function removeField(obj, fieldToRemove) {
+    if (Array.isArray(obj)) {
+        return obj.map(item => removeField(item, fieldToRemove));
+    }
+    else if (typeof obj === 'object' && obj !== null) {
+        return Object.fromEntries(Object.entries(obj)
+            .filter(([key]) => key !== fieldToRemove)
+            .map(([key, value]) => [key, removeField(value, fieldToRemove)]));
+    }
+    return obj; // Return primitives as-is
+}
+function removeUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/common/utils/social.d.ts

@@ -0,0 +1 @@
+export declare const getGlobalPointSystemId: () => number;

package/dist/common/utils/social.js

@@ -0,0 +1,30 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else {
+		var a = factory();
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.getGlobalPointSystemId = void 0;
+const getGlobalPointSystemId = () => {
+    return 1;
+};
+exports.getGlobalPointSystemId = getGlobalPointSystemId;
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/common/utils/stat.d.ts

@@ -0,0 +1 @@
+export declare const changes24H: (lastPrice: string | null, price24hAgo: string | null) => string;

package/dist/common/utils/stat.js

@@ -0,0 +1,274 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("bignumber.js"));
+	else if(typeof define === 'function' && define.amd)
+		define(["bignumber.js"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("bignumber.js")) : factory(root["bignumber.js"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(global, (__WEBPACK_EXTERNAL_MODULE__6168__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 1174:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Operations = void 0;
+exports.absolute = absolute;
+exports.ceil = ceil;
+exports.toFixed = toFixed;
+exports.floor = floor;
+exports.round = round;
+exports.plus = plus;
+exports.minus = minus;
+exports.multiply = multiply;
+exports.toUsd = toUsd;
+exports.divide = divide;
+exports.greaterThanOrEqual = greaterThanOrEqual;
+exports.greaterThan = greaterThan;
+exports.lessThanOrEqual = lessThanOrEqual;
+exports.lessThan = lessThan;
+exports.equal = equal;
+exports.mod = mod;
+exports.modZero = modZero;
+exports.bn_operation = bn_operation;
+exports.roundNumber = roundNumber;
+exports.convertFromBaseUnits = convertFromBaseUnits;
+exports.convertToBaseUnits = convertToBaseUnits;
+const bignumber_js_1 = __importDefault(__webpack_require__(6168));
+bignumber_js_1.default.config({ DECIMAL_PLACES: 40, EXPONENTIAL_AT: 45 });
+var Operations;
+(function (Operations) {
+    Operations["MINUS"] = "-";
+    Operations["PLUS"] = "+";
+    Operations["MULTIPLY"] = "*";
+    Operations["DIVIDE"] = "/";
+    Operations["GREATER_THAN_OR_EQUAL"] = ">=";
+    Operations["GREATER_THAN"] = ">";
+    Operations["LESS_THAN_OR_EQUAL"] = "<=";
+    Operations["LESS_THAN"] = "<";
+    Operations["EQUAL"] = "==";
+    Operations["MOD"] = "mod";
+})(Operations || (exports.Operations = Operations = {}));
+function absolute(value) {
+    let x = new bignumber_js_1.default(value);
+    const res = x.abs().toString();
+    // console.log('Absolute value', { value, res })
+    return res;
+}
+function ceil(value) {
+    let x = new bignumber_js_1.default(String(value));
+    const res = x.integerValue(bignumber_js_1.default.ROUND_CEIL).toString();
+    if (!equal(value, res)) {
+        console.log('Ceil value', { value, res });
+    }
+    return res;
+}
+function toFixed(value, decimalPlaces, roundUpToFirstSignificant = false) {
+    const x = new bignumber_js_1.default(String(value));
+    let res;
+    if (roundUpToFirstSignificant) {
+        const valueStr = x.toFixed();
+        const decimalIndex = valueStr.indexOf('.');
+        if (decimalIndex >= 0) {
+            const fractionalPart = valueStr.slice(decimalIndex + 1);
+            let leadingZeros = 0;
+            for (let char of fractionalPart) {
+                if (char === '0') {
+                    leadingZeros++;
+                }
+                else {
+                    break;
+                }
+            }
+            const totalDecimalPlaces = leadingZeros + 1;
+            res = x.toFixed(totalDecimalPlaces, bignumber_js_1.default.ROUND_UP);
+        }
+        else {
+            res = x.toFixed(0);
+        }
+    }
+    else {
+        res = x.toFixed(decimalPlaces);
+    }
+    console.log('Fixed value', { value, res });
+    return res;
+}
+function floor(value) {
+    let x = new bignumber_js_1.default(String(value));
+    const res = x.integerValue(bignumber_js_1.default.ROUND_FLOOR).toString();
+    console.log('Floor value', { value, res });
+    return res;
+}
+function round(value) {
+    let x = new bignumber_js_1.default(String(value));
+    const res = x.integerValue(bignumber_js_1.default.ROUND_HALF_UP).toString();
+    console.log('Round value', { value, res });
+    return res;
+}
+function plus(value1, value2) {
+    return bn_operation(value1, value2, Operations.PLUS);
+}
+function minus(value1, value2) {
+    return bn_operation(value1, value2, Operations.MINUS);
+}
+function multiply(value1, value2) {
+    return bn_operation(value1, value2, Operations.MULTIPLY);
+}
+function toUsd(amount, price) {
+    return multiply(amount, price || 0);
+}
+;
+function divide(value1, value2) {
+    return bn_operation(value1, value2, Operations.DIVIDE);
+}
+function greaterThanOrEqual(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.GREATER_THAN_OR_EQUAL));
+}
+function greaterThan(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.GREATER_THAN));
+}
+function lessThanOrEqual(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.LESS_THAN_OR_EQUAL));
+}
+function lessThan(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.LESS_THAN));
+}
+function equal(value1, value2) {
+    return Boolean(bn_operation(value1, value2, Operations.EQUAL));
+}
+function mod(value1, value2) {
+    return bn_operation(value1, value2, Operations.MOD);
+}
+function modZero(value1, value2) {
+    return equal(mod(value1, value2), 0);
+}
+function bn_operation(a, b, operation) {
+    a = new bignumber_js_1.default(String(a));
+    b = new bignumber_js_1.default(String(b));
+    switch (operation.toLowerCase()) {
+        case '-':
+            return a.minus(b).toString();
+        case '+':
+            return a.plus(b).toString();
+        case '*':
+        case 'x':
+            return a.multipliedBy(b).toString();
+        case '÷':
+        case '/':
+            return a.dividedBy(b).toString();
+        case '>=':
+            return a.isGreaterThanOrEqualTo(b);
+        case '>':
+            return a.isGreaterThan(b);
+        case '<=':
+            return a.isLessThanOrEqualTo(b);
+        case '<':
+            return a.isLessThan(b);
+        case '==':
+            return a.isEqualTo(b);
+        case 'mod':
+            return a.modulo(b);
+        default:
+            break;
+    }
+}
+function getExponentialNumberComponents(x) {
+    if (x.toString().includes('e')) {
+        const parts = x.toString().split('e');
+        return [parseFloat(parts[0]), parseFloat(parts[1])];
+    }
+    return [x, 0];
+}
+function generateExponentialNumberFromComponents(decimalPart, exponent) {
+    return decimalPart + (exponent < 0 ? `e${exponent}` : `e+${exponent}`);
+}
+function roundNumber({ decimalPlaces = 0 }, x) {
+    if (decimalPlaces > 0) {
+        const [decimal, decimalExponentialPart] = getExponentialNumberComponents(x);
+        const [rounded, roundedExponentialPart] = getExponentialNumberComponents(Math.round(Number(generateExponentialNumberFromComponents(decimal, decimalExponentialPart + decimalPlaces))));
+        return Number(generateExponentialNumberFromComponents(rounded, roundedExponentialPart - decimalPlaces));
+    }
+    return Math.round(x);
+}
+function convertFromBaseUnits(assetDecimals, quantity) {
+    const decimals = Number(assetDecimals);
+    return roundNumber({ decimalPlaces: decimals }, 
+    // eslint-disable-next-line no-magic-numbers
+    Math.pow(10, -decimals) * Number(quantity));
+}
+/**
+ * Computs quantity * 10^(assetDecimals) and rounds the result
+ */
+function convertToBaseUnits(assetDecimals, quantity) {
+    // eslint-disable-next-line no-magic-numbers
+    const baseAmount = Math.pow(10, Number(assetDecimals)) * Number(quantity);
+    // make sure the final value is an integer. This prevents this kind of computation errors: 0.0012 * 100000 = 119.99999999999999 and rounds this result into 120
+    return roundNumber({ decimalPlaces: 0 }, baseAmount);
+}
+
+
+/***/ }),
+
+/***/ 6168:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__6168__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.changes24H = void 0;
+const big_number_helper_1 = __webpack_require__(1174);
+const changes24H = (lastPrice, price24hAgo) => {
+    return (0, big_number_helper_1.greaterThan)(price24hAgo, 0) && (0, big_number_helper_1.greaterThan)(lastPrice, 0)
+        ? (0, big_number_helper_1.multiply)((0, big_number_helper_1.divide)((0, big_number_helper_1.minus)(lastPrice, price24hAgo), price24hAgo), 100)
+        : '0';
+};
+exports.changes24H = changes24H;
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/constants/allowedUrls.d.ts

@@ -0,0 +1 @@
+export declare const ALLOWED_URLS: string[];

package/dist/constants/auth.d.ts

@@ -0,0 +1,2 @@
+export declare const DAY_MILLISECONDS = 86400000;
+export declare const EXPIRE_DAYS = 30;

package/dist/constants/cctp.d.ts

@@ -0,0 +1,3 @@
+export declare const CCTP_UNIFIED_ASSETS: {
+    readonly "0x4343545055534443000000000000000000000000000000000000000000000000": 65537;
+};

package/dist/constants/codex.d.ts

@@ -0,0 +1,11 @@
+export declare const FACTOR_PRICE_DECIMAL = 18;
+export declare const FEE_SCALE = 100000;
+export declare const FRONTEND_FEE_SCALE: number;
+export declare const DEFAULT_FEE_SHARE = 90000;
+export declare const DEFAULT_ORDER_EXPIRATION_DAYS = 30;
+export declare const MIN_ORDER_EXPIRATION_MINS = 60;
+export declare const ORDER_DATA_BYTES_LENGTH = 328;
+export declare const ORDER_MSG_VERSION = 1;
+export declare const MAX_TOKEN_DECIMAL = 18;
+export declare const SHARE_DATA_LENGTH = 36;
+export declare const WITHDRAW_DATA_BYTES_LENGTH = 248;

package/dist/constants/env.d.ts

@@ -0,0 +1,6 @@
+export declare const ALGO_NETWORK: string;
+export declare const NETWORK: string;
+export declare const WH_CORE_ID: number;
+export declare const SUPER_APP_ID: number;
+export declare const CODEX_APP_ID: number;
+export declare const MSG_PROC_ID: number;

package/dist/constants/index.d.ts

@@ -0,0 +1,7 @@
+export * from './auth';
+export * from './codex';
+export * from './cctp';
+export * from './response';
+export * from './queue';
+export * from './settings';
+export * from './withdrawalWalletsMessage';