@ultrade/shared 1.0.0

package/dist/helpers/ticker.helpers.js

@@ -0,0 +1,358 @@
+(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.groupTickersByInterval = groupTickersByInterval;
+exports.groupTickersByMonthInterval = groupTickersByMonthInterval;
+exports.groupTickersByYearInterval = groupTickersByYearInterval;
+exports.mapCandleToTicker = mapCandleToTicker;
+exports.roundUpSecondsInTimestamp = roundUpSecondsInTimestamp;
+exports.roundUpMinutesInTimestamp = roundUpMinutesInTimestamp;
+exports.roundUpHoursInTimestamp = roundUpHoursInTimestamp;
+const big_number_helper_1 = __webpack_require__(1174);
+function groupTickersByInterval(tickers, newIntervalInSec, endTimeInSec) {
+    const newGroupedTickers = [];
+    let timestamp = endTimeInSec - newIntervalInSec;
+    let slot = null;
+    // desc direction by timestamp
+    const sortedTickers = tickers.sort((a, b) => b.t - a.t);
+    for (let i = 0; i < sortedTickers.length; i++) {
+        const element = sortedTickers[i];
+        if (element.t < timestamp) {
+            if (slot) {
+                newGroupedTickers.push({ ...slot });
+                slot = null;
+            }
+            timestamp = timestamp - newIntervalInSec * Math.ceil((timestamp - element.t) / newIntervalInSec);
+        }
+        if (!slot) {
+            slot = { ...element, t: timestamp };
+        }
+        else {
+            if ((0, big_number_helper_1.lessThan)(slot.h, element.h))
+                slot.h = element.h;
+            if ((0, big_number_helper_1.greaterThan)(slot.l, element.l))
+                slot.l = element.l;
+            slot.o = element.o;
+            slot.v = Number((0, big_number_helper_1.plus)(slot.v, element.v));
+        }
+        if (i + 1 === sortedTickers.length) {
+            newGroupedTickers.push({ ...slot });
+        }
+    }
+    return newGroupedTickers;
+}
+function groupTickersByMonthInterval(tickers, months, endTimeInSec) {
+    const sortedTickers = tickers.sort((a, b) => b.t - a.t);
+    const yearlyTickers = [];
+    const tickersByYear = new Map();
+    for (const ticker of sortedTickers) {
+        const date = new Date(ticker.t * 1000);
+        const year = date.getFullYear();
+        if (!tickersByYear.has(year)) {
+            tickersByYear.set(year, []);
+        }
+        tickersByYear.get(year).push(ticker);
+    }
+    for (const [year, yearTickers] of tickersByYear) {
+        if (yearTickers.length === 0)
+            continue;
+        const sortedYearTickers = yearTickers.sort((a, b) => a.t - b.t);
+        const yearlyTicker = {
+            t: new Date(year, 0, 1).getTime() / 1000,
+            o: sortedYearTickers[0].o,
+            h: Math.max(...sortedYearTickers.map(t => t.h)),
+            l: Math.min(...sortedYearTickers.map(t => t.l)),
+            c: sortedYearTickers[sortedYearTickers.length - 1].c,
+            v: sortedYearTickers.reduce((sum, t) => sum + t.v, 0),
+            q: sortedYearTickers.reduce((sum, t) => sum + t.q, 0),
+        };
+        yearlyTickers.push(yearlyTicker);
+    }
+    return yearlyTickers.sort((a, b) => b.t - a.t);
+}
+function groupTickersByYearInterval(tickers, years, endTimeInSec) {
+    throw new Error("groupTickersByYearInterval has not implemented yet");
+}
+function mapCandleToTicker(candle) {
+    return {
+        t: +(0, big_number_helper_1.divide)(candle.timestamp, 1000),
+        o: candle.open,
+        h: candle.high,
+        l: candle.low,
+        c: candle.close,
+        v: candle.volume,
+        q: candle.quote
+    };
+}
+function roundUpSecondsInTimestamp(timeInSec) {
+    return (new Date(timeInSec * 1000).setSeconds(60, 0)) / 1000;
+}
+function roundUpMinutesInTimestamp(timeInSec) {
+    return (new Date(timeInSec * 1000).setMinutes(60, 0, 0)) / 1000;
+}
+function roundUpHoursInTimestamp(timeInSec) {
+    return (new Date(timeInSec * 1000).setHours(24, 0, 0, 0)) / 1000;
+}
+
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/dist/helpers/vaa.helper.d.ts

@@ -0,0 +1,2 @@
+export declare const wormholeEmitterFormat: (address: string, chainId: number) => string;
+export declare const getVaaId: (emitterAddress: string, emitterChainId: number, sequence: string) => string;