@pioneer-platform/helpers 3.0.1 → 4.0.1

package/lib/modules/bigIntArithmetics.js

@@ -0,0 +1,344 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntArithmetics = exports.formatBigIntToSafeValue = void 0;
+var types_1 = require("@coinmasters/types");
+var DEFAULT_DECIMAL = 8;
+var bigintPow = function (base, exponent) {
+    var result = BigInt(1);
+    while (exponent > 0) {
+        if (exponent % 2 === 1) {
+            result *= base;
+        }
+        base *= base;
+        exponent = Math.floor(exponent / 2);
+    }
+    return result;
+};
+var toMultiplier = function (decimal) {
+    console.log('toMultiplier input decimal:', decimal);
+    try {
+        var result = bigintPow(BigInt(10), decimal);
+        console.log('toMultiplier result:', result);
+        return result;
+    }
+    catch (error) {
+        console.error('Error in toMultiplier:', error);
+        return BigInt(10);
+    }
+};
+var decimalFromMultiplier = function (multiplier) { return Math.log10(Number(multiplier)); };
+function formatBigIntToSafeValue(_a) {
+    var value = _a.value, _b = _a.bigIntDecimal, bigIntDecimal = _b === void 0 ? DEFAULT_DECIMAL : _b, _c = _a.decimal, decimal = _c === void 0 ? DEFAULT_DECIMAL : _c;
+    var isNegative = value < BigInt(0);
+    var valueString = value.toString().substring(isNegative ? 1 : 0);
+    var padLength = decimal - (valueString.length - 1);
+    if (padLength > 0) {
+        valueString = '0'.repeat(padLength) + valueString;
+    }
+    var decimalIndex = valueString.length - decimal;
+    var decimalString = valueString.slice(-decimal);
+    if (parseInt(decimalString[bigIntDecimal]) >= 5) {
+        decimalString = "".concat(decimalString.substring(0, bigIntDecimal - 1)).concat((parseInt(decimalString[bigIntDecimal - 1]) + 1).toString());
+    }
+    else {
+        decimalString = decimalString.substring(0, bigIntDecimal);
+    }
+    return "".concat(isNegative ? '-' : '').concat(valueString.slice(0, decimalIndex), ".").concat(decimalString).replace(/\.?0*$/, '');
+}
+exports.formatBigIntToSafeValue = formatBigIntToSafeValue;
+var BigIntArithmetics = /** @class */ (function () {
+    function BigIntArithmetics(params) {
+        this.decimalMultiplier = bigintPow(BigInt(10), 8);
+        this.bigIntValue = BigInt(0);
+        console.log('Constructor Params:', params);
+        var value = getStringValue(params);
+        console.log('String Value:', value);
+        var isComplex = typeof params === 'object' && params !== null;
+        this.decimal = isComplex ? params.decimal : undefined;
+        console.log('Decimal:', this.decimal);
+        if (isComplex && 'decimalMultiplier' in params) {
+            this.decimalMultiplier = params.decimalMultiplier;
+        }
+        else {
+            var maxDecimals = Math.max(getFloatDecimals(toSafeValue(value)), this.decimal || 0);
+            this.decimalMultiplier = toMultiplier(maxDecimals);
+        }
+        console.log('Decimal Multiplier:', this.decimalMultiplier);
+        this.setValue(value);
+        console.log('BigInt Value:', this.bigIntValue);
+    }
+    BigIntArithmetics.fromBigInt = function (value, decimal) {
+        return new BigIntArithmetics({
+            decimal: decimal,
+            value: formatBigIntToSafeValue({ value: value, bigIntDecimal: decimal, decimal: decimal }),
+        });
+    };
+    BigIntArithmetics.shiftDecimals = function (_a) {
+        var value = _a.value, from = _a.from, to = _a.to;
+        return this.fromBigInt((value.getBaseValue('bigint') * toMultiplier(to)) / toMultiplier(from), to);
+    };
+    BigIntArithmetics.prototype.set = function (value) {
+        // @ts-ignore
+        return new BigIntArithmetics({ decimal: this.decimal, value: value });
+    };
+    BigIntArithmetics.prototype.add = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.arithmetics.apply(this, __spreadArray(['add'], args, false));
+    };
+    BigIntArithmetics.prototype.sub = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.arithmetics.apply(this, __spreadArray(['sub'], args, false));
+    };
+    BigIntArithmetics.prototype.mul = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.arithmetics.apply(this, __spreadArray(['mul'], args, false));
+    };
+    BigIntArithmetics.prototype.div = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.arithmetics.apply(this, __spreadArray(['div'], args, false));
+    };
+    BigIntArithmetics.prototype.gt = function (value) {
+        return this.comparison('gt', value);
+    };
+    BigIntArithmetics.prototype.gte = function (value) {
+        return this.comparison('gte', value);
+    };
+    BigIntArithmetics.prototype.lt = function (value) {
+        return this.comparison('lt', value);
+    };
+    BigIntArithmetics.prototype.lte = function (value) {
+        return this.comparison('lte', value);
+    };
+    BigIntArithmetics.prototype.eqValue = function (value) {
+        return this.comparison('eqValue', value);
+    };
+    // @ts-ignore
+    BigIntArithmetics.prototype.getValue = function (type) {
+        var value = formatBigIntToSafeValue({
+            value: this.bigIntValue,
+            bigIntDecimal: this.decimal || decimalFromMultiplier(this.decimalMultiplier),
+        });
+        switch (type) {
+            case 'number':
+                return Number(value);
+            case 'string':
+                return value;
+            case 'bigint':
+                return ((this.bigIntValue * bigintPow(BigInt(10), this.decimal || 8)) /
+                    this.decimalMultiplier);
+        }
+    };
+    // @ts-ignore
+    BigIntArithmetics.prototype.getBaseValue = function (type) {
+        var divisor = this.decimalMultiplier / toMultiplier(this.decimal || types_1.BaseDecimal.THOR);
+        var baseValue = this.bigIntValue / divisor;
+        switch (type) {
+            case 'number':
+                return Number(baseValue);
+            case 'string':
+                return baseValue.toString();
+            case 'bigint':
+                return baseValue;
+        }
+    };
+    BigIntArithmetics.prototype.getBigIntValue = function (value, decimal) {
+        if (!decimal && typeof value === 'object' && value !== null) {
+            return value.bigIntValue;
+        }
+        var stringValue = getStringValue(value);
+        var safeValue = toSafeValue(stringValue);
+        if (safeValue === '0' || safeValue === 'undefined')
+            return BigInt(0);
+        return this.toBigInt(safeValue, decimal);
+    };
+    BigIntArithmetics.prototype.toSignificant = function (significantDigits) {
+        if (significantDigits === void 0) { significantDigits = 6; }
+        var _a = this.getValue('string').split('.'), int = _a[0], dec = _a[1];
+        var integer = int || '';
+        var decimal = dec || '';
+        var valueLength = parseInt(integer) ? integer.length + decimal.length : decimal.length;
+        if (valueLength <= significantDigits) {
+            return this.getValue('string');
+        }
+        if (integer.length >= significantDigits) {
+            return integer.slice(0, significantDigits).padEnd(integer.length, '0');
+        }
+        if (parseInt(integer)) {
+            return "".concat(integer, ".").concat(decimal.slice(0, significantDigits - integer.length)).padEnd(significantDigits - integer.length, '0');
+        }
+        var trimmedDecimal = parseInt(decimal);
+        var slicedDecimal = "".concat(trimmedDecimal).slice(0, significantDigits);
+        return "0.".concat(slicedDecimal.padStart(decimal.length - "".concat(trimmedDecimal).length + slicedDecimal.length, '0'));
+    };
+    BigIntArithmetics.prototype.toFixed = function (fixedDigits) {
+        if (fixedDigits === void 0) { fixedDigits = 6; }
+        var _a = this.getValue('string').split('.'), int = _a[0], dec = _a[1];
+        var integer = int || '';
+        var decimal = dec || '';
+        if (parseInt(integer)) {
+            return "".concat(integer, ".").concat(decimal.slice(0, fixedDigits)).padEnd(fixedDigits, '0');
+        }
+        var trimmedDecimal = parseInt(decimal);
+        var slicedDecimal = "".concat(trimmedDecimal).slice(0, fixedDigits);
+        return "0.".concat(slicedDecimal.padStart(decimal.length - "".concat(trimmedDecimal).length + slicedDecimal.length, '0'));
+    };
+    BigIntArithmetics.prototype.toAbbreviation = function (digits) {
+        if (digits === void 0) { digits = 2; }
+        var value = this.getValue('number');
+        var abbreviations = ['', 'K', 'M', 'B', 'T', 'Q', 'Qi', 'S'];
+        var tier = Math.floor(Math.log10(Math.abs(value)) / 3);
+        var suffix = abbreviations[tier];
+        if (!suffix)
+            return this.getValue('string');
+        var scale = Math.pow(10, (tier * 3));
+        var scaled = value / scale;
+        return "".concat(scaled.toFixed(digits)).concat(suffix);
+    };
+    BigIntArithmetics.prototype.toCurrency = function (currency, _a) {
+        if (currency === void 0) { currency = '$'; }
+        var _b = _a === void 0 ? {} : _a, _c = _b.currencyPosition, currencyPosition = _c === void 0 ? 'start' : _c, _d = _b.decimal, decimal = _d === void 0 ? 2 : _d, _e = _b.decimalSeparator, decimalSeparator = _e === void 0 ? '.' : _e, _f = _b.thousandSeparator, thousandSeparator = _f === void 0 ? ',' : _f;
+        var value = this.getValue('number');
+        var _g = value.toFixed(6).split('.'), int = _g[0], _h = _g[1], dec = _h === void 0 ? '' : _h;
+        var integer = int.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator);
+        var parsedValue = !int && !dec
+            ? '0.00'
+            : int === '0'
+                ? "".concat(parseFloat("0.".concat(dec))).replace('.', decimalSeparator)
+                : "".concat(integer).concat(parseInt(dec) ? "".concat(decimalSeparator).concat(dec.slice(0, decimal)) : '');
+        return "".concat(currencyPosition === 'start' ? currency : '').concat(parsedValue).concat(currencyPosition === 'end' ? currency : '');
+    };
+    BigIntArithmetics.prototype.arithmetics = function (method) {
+        var _this = this;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var precisionDecimal = this.retrievePrecisionDecimal.apply(this, __spreadArray([this], args, false));
+        var decimal = Math.max(precisionDecimal, decimalFromMultiplier(this.decimalMultiplier));
+        var precisionDecimalMultiplier = toMultiplier(decimal);
+        var result = args.reduce(function (acc, arg) {
+            var value = _this.getBigIntValue(arg, decimal);
+            switch (method) {
+                case 'add':
+                    return acc + value;
+                case 'sub':
+                    return acc - value;
+                case 'mul':
+                    return (acc * value) / precisionDecimalMultiplier;
+                case 'div': {
+                    if (value === BigInt(0))
+                        throw new RangeError('Division by zero');
+                    return (acc * precisionDecimalMultiplier) / value;
+                }
+                default:
+                    return acc;
+            }
+        }, (this.bigIntValue * precisionDecimalMultiplier) / this.decimalMultiplier);
+        var formattedValue = formatBigIntToSafeValue({
+            bigIntDecimal: decimal,
+            decimal: decimal,
+            value: result,
+        });
+        return new BigIntArithmetics({
+            decimalMultiplier: toMultiplier(decimal),
+            decimal: this.decimal,
+            value: formattedValue,
+        });
+    };
+    BigIntArithmetics.prototype.comparison = function (method) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var decimal = this.retrievePrecisionDecimal.apply(this, __spreadArray([this], args, false));
+        var value = this.getBigIntValue(args[0], decimal);
+        var compareToValue = this.getBigIntValue(this, decimal);
+        switch (method) {
+            case 'gt':
+                return compareToValue > value;
+            case 'gte':
+                return compareToValue >= value;
+            case 'lt':
+                return compareToValue < value;
+            case 'lte':
+                return compareToValue <= value;
+            case 'eqValue':
+                return compareToValue === value;
+        }
+    };
+    BigIntArithmetics.prototype.setValue = function (value) {
+        var safeValue = toSafeValue(value) || '0';
+        this.bigIntValue = this.toBigInt(safeValue);
+    };
+    BigIntArithmetics.prototype.retrievePrecisionDecimal = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var decimals = args
+            .map(function (arg) {
+            var isObject = typeof arg === 'object' && arg !== null;
+            var value = isObject
+                ? arg.decimal || decimalFromMultiplier(arg.decimalMultiplier)
+                : getFloatDecimals(toSafeValue(arg));
+            return value;
+        })
+            .filter(Boolean);
+        return Math.max.apply(Math, __spreadArray(__spreadArray([], decimals, false), [DEFAULT_DECIMAL], false));
+    };
+    BigIntArithmetics.prototype.toBigInt = function (value, decimal) {
+        var multiplier = decimal ? toMultiplier(decimal) : this.decimalMultiplier;
+        var padDecimal = decimalFromMultiplier(multiplier);
+        var _a = value.split('.'), _b = _a[0], integerPart = _b === void 0 ? '' : _b, _c = _a[1], decimalPart = _c === void 0 ? '' : _c;
+        return BigInt("".concat(integerPart).concat(decimalPart.padEnd(padDecimal, '0')));
+    };
+    return BigIntArithmetics;
+}());
+exports.BigIntArithmetics = BigIntArithmetics;
+var numberFormatter = Intl.NumberFormat('fullwide', {
+    useGrouping: false,
+    maximumFractionDigits: 20,
+});
+function toSafeValue(value) {
+    var parsedValue = typeof value === 'number' ? numberFormatter.format(value) : getStringValue(value);
+    var splitValue = "".concat(parsedValue).replace(/,/g, '.').split('.');
+    return splitValue.length > 1
+        ? "".concat(splitValue.slice(0, -1).join(''), ".").concat(splitValue.at(-1))
+        : splitValue[0];
+}
+function getFloatDecimals(value) {
+    var decimals = 0;
+    var parts = value.split('.');
+    if (parts.length > 1 && parts[1].length > 0) {
+        decimals = parts[1].length;
+    }
+    return Math.max(decimals, DEFAULT_DECIMAL);
+}
+function getStringValue(param) {
+    return typeof param === 'object' && param !== null
+        ? 'getValue' in param
+            ? param.getValue('string')
+            : param.value
+        : param;
+}

package/lib/modules/swapKitError.d.ts

@@ -0,0 +1,64 @@
+declare const errorMessages: {
+    /**
+     * Core
+     */
+    readonly core_wallet_connection_not_found: 10001;
+    readonly core_estimated_max_spendable_chain_not_supported: 10002;
+    readonly core_extend_error: 10003;
+    readonly core_inbound_data_not_found: 10004;
+    readonly core_approve_asset_address_or_from_not_found: 10005;
+    readonly core_chain_halted: 10099;
+    /**
+     * Core - Wallet Connection
+     */
+    readonly core_wallet_xdefi_not_installed: 10101;
+    readonly core_wallet_evmwallet_not_installed: 10102;
+    readonly core_wallet_walletconnect_not_installed: 10103;
+    readonly core_wallet_keystore_not_installed: 10104;
+    readonly core_wallet_ledger_not_installed: 10105;
+    readonly core_wallet_trezor_not_installed: 10106;
+    readonly core_wallet_keplr_not_installed: 10107;
+    readonly core_wallet_okx_not_installed: 10108;
+    readonly core_wallet_keepkey_not_installed: 10109;
+    /**
+     * Core - Swap
+     */
+    readonly core_swap_invalid_params: 10200;
+    readonly core_swap_route_not_complete: 10201;
+    readonly core_swap_asset_not_recognized: 10202;
+    readonly core_swap_contract_not_found: 10203;
+    readonly core_swap_route_transaction_not_found: 10204;
+    readonly core_swap_contract_not_supported: 10205;
+    readonly core_swap_quote_mode_not_supported: 10207;
+    /**
+     * Core - Transaction
+     */
+    readonly core_transaction_deposit_error: 10301;
+    readonly core_transaction_create_liquidity_rune_error: 10302;
+    readonly core_transaction_create_liquidity_asset_error: 10303;
+    readonly core_transaction_create_liquidity_invalid_params: 10304;
+    readonly core_transaction_add_liquidity_invalid_params: 10305;
+    readonly core_transaction_add_liquidity_no_rune_address: 10306;
+    readonly core_transaction_add_liquidity_rune_error: 10307;
+    readonly core_transaction_add_liquidity_asset_error: 10308;
+    readonly core_transaction_withdraw_error: 10309;
+    readonly core_transaction_deposit_to_pool_error: 10310;
+    readonly core_transaction_deposit_insufficient_funds_error: 10311;
+    readonly core_transaction_deposit_gas_error: 10312;
+    readonly core_transaction_invalid_sender_address: 10313;
+    readonly core_transaction_deposit_server_error: 10314;
+    readonly core_swap_transaction_error: 10400;
+    /**
+     * Wallets
+     */
+    readonly wallet_ledger_connection_error: 20001;
+    /**
+     * Helpers
+     */
+    readonly helpers_number_different_decimals: 99101;
+};
+export type Keys = keyof typeof errorMessages;
+export declare class SwapKitError extends Error {
+    constructor(errorKey: Keys, sourceError?: any);
+}
+export {};

package/lib/modules/swapKitError.js

@@ -0,0 +1,90 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapKitError = void 0;
+var errorMessages = {
+    /**
+     * Core
+     */
+    core_wallet_connection_not_found: 10001,
+    core_estimated_max_spendable_chain_not_supported: 10002,
+    core_extend_error: 10003,
+    core_inbound_data_not_found: 10004,
+    core_approve_asset_address_or_from_not_found: 10005,
+    core_chain_halted: 10099,
+    /**
+     * Core - Wallet Connection
+     */
+    core_wallet_xdefi_not_installed: 10101,
+    core_wallet_evmwallet_not_installed: 10102,
+    core_wallet_walletconnect_not_installed: 10103,
+    core_wallet_keystore_not_installed: 10104,
+    core_wallet_ledger_not_installed: 10105,
+    core_wallet_trezor_not_installed: 10106,
+    core_wallet_keplr_not_installed: 10107,
+    core_wallet_okx_not_installed: 10108,
+    core_wallet_keepkey_not_installed: 10109,
+    /**
+     * Core - Swap
+     */
+    core_swap_invalid_params: 10200,
+    core_swap_route_not_complete: 10201,
+    core_swap_asset_not_recognized: 10202,
+    core_swap_contract_not_found: 10203,
+    core_swap_route_transaction_not_found: 10204,
+    core_swap_contract_not_supported: 10205,
+    core_swap_quote_mode_not_supported: 10207,
+    /**
+     * Core - Transaction
+     */
+    core_transaction_deposit_error: 10301,
+    core_transaction_create_liquidity_rune_error: 10302,
+    core_transaction_create_liquidity_asset_error: 10303,
+    core_transaction_create_liquidity_invalid_params: 10304,
+    core_transaction_add_liquidity_invalid_params: 10305,
+    core_transaction_add_liquidity_no_rune_address: 10306,
+    core_transaction_add_liquidity_rune_error: 10307,
+    core_transaction_add_liquidity_asset_error: 10308,
+    core_transaction_withdraw_error: 10309,
+    core_transaction_deposit_to_pool_error: 10310,
+    core_transaction_deposit_insufficient_funds_error: 10311,
+    core_transaction_deposit_gas_error: 10312,
+    core_transaction_invalid_sender_address: 10313,
+    core_transaction_deposit_server_error: 10314,
+    core_swap_transaction_error: 10400,
+    /**
+     * Wallets
+     */
+    wallet_ledger_connection_error: 20001,
+    /**
+     * Helpers
+     */
+    helpers_number_different_decimals: 99101,
+};
+var SwapKitError = /** @class */ (function (_super) {
+    __extends(SwapKitError, _super);
+    function SwapKitError(errorKey, sourceError) {
+        var _this = this;
+        console.error(sourceError, { stack: sourceError === null || sourceError === void 0 ? void 0 : sourceError.stack, message: sourceError === null || sourceError === void 0 ? void 0 : sourceError.message });
+        // @ts-ignore
+        _this = _super.call(this, errorKey, { cause: { code: errorMessages[errorKey], message: errorKey } }) || this;
+        Object.setPrototypeOf(_this, SwapKitError.prototype);
+        return _this;
+    }
+    return SwapKitError;
+}(Error));
+exports.SwapKitError = SwapKitError;

package/lib/modules/swapKitNumber.d.ts

@@ -0,0 +1,6 @@
+import { BigIntArithmetics } from './bigIntArithmetics';
+export type SwapKitValueType = BigIntArithmetics | string | number;
+export declare class SwapKitNumber extends BigIntArithmetics {
+    eq(value: SwapKitValueType): boolean;
+    static fromBigInt(value: bigint, decimal?: number): SwapKitNumber;
+}

package/lib/modules/swapKitNumber.js

@@ -0,0 +1,36 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapKitNumber = void 0;
+var bigIntArithmetics_1 = require("./bigIntArithmetics");
+var SwapKitNumber = /** @class */ (function (_super) {
+    __extends(SwapKitNumber, _super);
+    function SwapKitNumber() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SwapKitNumber.prototype.eq = function (value) {
+        return this.eqValue(value);
+    };
+    SwapKitNumber.fromBigInt = function (value, decimal) {
+        return new SwapKitNumber({
+            decimal: decimal,
+            value: (0, bigIntArithmetics_1.formatBigIntToSafeValue)({ value: value, bigIntDecimal: decimal, decimal: decimal }),
+        });
+    };
+    return SwapKitNumber;
+}(bigIntArithmetics_1.BigIntArithmetics));
+exports.SwapKitNumber = SwapKitNumber;

package/package.json

@@ -1,41 +1,25 @@
 {
-  "dependencies": {
-    "@pioneer-platform/swapkit-entities": "3.0.1",
-    "@pioneer-platform/types": "3.0.1"
-  },
-  "description": "THORSwap Lib - Helper library for THORSwap",
-  "devDependencies": {
-    "@ethersproject/bignumber": "5.7.0",
-    "@vitest/coverage-istanbul": "0.34.3",
-    "bignumber.js": "9.1.2",
-    "vite": "4.4.9",
-    "vitest": "0.34.3",
-    "@internal/config": "3.0.1"
-  },
-  "eslintConfig": {
-    "extends": "../eslint-config-thorswap"
-  },
-  "files": [
-    "src/"
-  ],
-  "homepage": "https://github.com/thorswap/SwapKit",
-  "license": "MIT",
-  "main": "./src/index.ts",
   "name": "@pioneer-platform/helpers",
-  "peerDependencies": {
-    "@ethersproject/bignumber": "^5.7.0",
-    "bignumber.js": "^9.1.2"
+  "version": "4.0.1",
+  "main": "./lib/index.js",
+  "types": "./lib/main.d.ts",
+  "scripts": {
+    "npm": "npm i",
+    "test": "npm run build && node __tests__/test-module.js",
+    "lint": "prettier --write '**/**/*.ts'",
+    "start": "nodemon --watch 'src/**/*.ts' --exec ts-node __tests__node",
+    "build": "tsc -p .",
+    "prepublish": "npm run build",
+    "refresh": "rm -rf ./node_modules ./package-lock.json && npm install"
   },
-  "publishConfig": {
-    "access": "public"
+  "dependencies": {
+    "@coinmasters/tokens": "^3.7.28",
+    "@coinmasters/types": "^4.7.28",
+    "@noble/hashes": "^1.4.0",
+    "@pioneer-platform/loggerdog": "^8.3.1",
+    "@types/node": "^18.15.11",
+    "ts-node": "^8.10.2",
+    "typescript": "^5.0.2"
   },
-  "type": "module",
-  "version": "3.0.1",
-  "scripts": {
-    "build": "vite build",
-    "clean": "rm -rf dist .turbo node_modules",
-    "lint": "eslint --ext .ts,.tsx --fix; tsc --noEmit",
-    "test": "vitest --run",
-    "test:coverage": "vitest run --coverage"
-  }
-}
+  "gitHead": "aeae28273014ab69b42f22abec159c6693a56c40"
+}