@cityofzion/blockchain-service 1.18.2 → 1.19.0

package/dist/error.d.ts

@@ -0,0 +1,4 @@
+export declare class BSError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}

package/dist/error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSError = void 0;
+class BSError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'BSError';
+    }
+}
+exports.BSError = BSError;

package/dist/functions.d.ts

@@ -1,11 +1,11 @@
-import { Account, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, UntilIndexRecord } from './interfaces';
+import { Account, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, IBSWithNeo3NeoXBridge, UntilIndexRecord } from './interfaces';
 export declare function hasNameService<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithNameService;
 export declare function isClaimable<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSClaimable<BSName>;
 export declare function isCalculableFee<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSCalculableFee<BSName>;
 export declare function hasNft<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithNft;
 export declare function hasExplorerService<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithExplorerService;
 export declare function hasLedger<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithLedger<BSName>;
-export declare function wait(ms: number): Promise<unknown>;
+export declare function hasNeo3NeoXBridge<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & IBSWithNeo3NeoXBridge<BSName>;
 /**
  * @deprecated use `waitForAccountTransaction` instead
  */
@@ -19,9 +19,3 @@ export declare function waitForAccountTransaction<BSName extends string = string
 export declare function fetchAccounts<BSName extends string = string>(blockchainServices: BlockchainService<BSName>, initialIndex: number, getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>): Promise<Account<BSName>[]>;
 export declare function generateAccount<BSName extends string = string>(blockchainServices: BlockchainService<BSName>, initialIndex: number, untilIndex: number, getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>): Promise<Account<BSName>[]>;
 export declare function generateAccountForBlockchainService<BSName extends string = string>(blockchainServices: BlockchainService<BSName>[], getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>, untilIndexByBlockchainService?: UntilIndexRecord<BSName>): Promise<Map<BSName, Account<BSName>[]>>;
-type NormalizedHashOptions = {
-    lowercase?: boolean;
-};
-export declare function normalizeHash(hash: string, options?: NormalizedHashOptions): string;
-export declare function denormalizeHash(hash: string): string;
-export {};

package/dist/functions.js

@@ -9,7 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.denormalizeHash = exports.normalizeHash = exports.generateAccountForBlockchainService = exports.generateAccount = exports.fetchAccounts = exports.waitForAccountTransaction = exports.waitForTransaction = exports.wait = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+exports.generateAccountForBlockchainService = exports.generateAccount = exports.fetchAccounts = exports.waitForAccountTransaction = exports.waitForTransaction = exports.hasNeo3NeoXBridge = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+const BSUtilsHelper_1 = require("./helpers/BSUtilsHelper");
 function hasNameService(service) {
     return 'resolveNameServiceDomain' in service && 'validateNameServiceDomainFormat' in service;
 }
@@ -34,10 +35,10 @@ function hasLedger(service) {
     return 'ledgerService' in service;
 }
 exports.hasLedger = hasLedger;
-function wait(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+function hasNeo3NeoXBridge(service) {
+    return 'neo3NeoXBridgeService' in service;
 }
-exports.wait = wait;
+exports.hasNeo3NeoXBridge = hasNeo3NeoXBridge;
 /**
  * @deprecated use `waitForAccountTransaction` instead
  */
@@ -55,7 +56,7 @@ function waitForTransaction(service, txId) {
                 // Empty block
             }
             attempts++;
-            yield wait(waitMs);
+            yield BSUtilsHelper_1.BSUtilsHelper.wait(waitMs);
         } while (attempts < maxAttempts);
         return false;
     });
@@ -66,7 +67,7 @@ function waitForAccountTransaction(params) {
         const { address, maxAttempts = 10, service, txId } = params;
         let attempts = 1;
         do {
-            yield wait(60000);
+            yield BSUtilsHelper_1.BSUtilsHelper.wait(60000);
             try {
                 const response = yield service.blockchainDataService.getTransactionsByAddress({ address });
                 const isTransactionConfirmed = response.transactions.some(transaction => transaction.hash === txId);
@@ -140,15 +141,3 @@ function generateAccountForBlockchainService(blockchainServices, getAccountCallb
     });
 }
 exports.generateAccountForBlockchainService = generateAccountForBlockchainService;
-function normalizeHash(hash, options) {
-    const { lowercase = true } = options !== null && options !== void 0 ? options : {};
-    hash = hash.replace('0x', '');
-    if (lowercase)
-        hash = hash.toLowerCase();
-    return hash;
-}
-exports.normalizeHash = normalizeHash;
-function denormalizeHash(hash) {
-    return hash.startsWith('0x') ? hash : `0x${hash}`;
-}
-exports.denormalizeHash = denormalizeHash;

package/dist/helpers/BSBigNumberHelper.d.ts

@@ -0,0 +1,11 @@
+import BigNumber from 'bignumber.js';
+type FormatNumberOptions = {
+    decimals?: number;
+};
+export declare class BSBigNumberHelper {
+    static toDecimals(value: BigNumber, decimals?: number): string;
+    static fromNumber(value: string | number): BigNumber;
+    static fromDecimals(value: string | number, decimals?: number): BigNumber;
+    static format(value?: string | number | BigNumber, options?: FormatNumberOptions): string;
+}
+export {};

package/dist/helpers/BSBigNumberHelper.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSBigNumberHelper = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+class BSBigNumberHelper {
+    static toDecimals(value, decimals = 0) {
+        return new bignumber_js_1.default(value).shiftedBy(decimals).toString();
+    }
+    static fromNumber(value) {
+        return new bignumber_js_1.default(value);
+    }
+    static fromDecimals(value, decimals = 0) {
+        return new bignumber_js_1.default(value).shiftedBy(-decimals);
+    }
+    static format(value, options) {
+        const { decimals = 0 } = options || {};
+        if (!value)
+            return '0';
+        if (typeof value === 'string') {
+            value = value.replace(/,|\.\.|\.,/g, '.').replace(/^([^.]*\.)(.*)$/, function (_a, b, c) {
+                return b + c.replace(/\./g, '');
+            });
+        }
+        try {
+            const bigValue = new bignumber_js_1.default(value);
+            if (bigValue.isNaN()) {
+                return '0';
+            }
+            const formattedValue = bigValue.decimalPlaces(decimals, bignumber_js_1.default.ROUND_DOWN);
+            return formattedValue.toFixed();
+        }
+        catch (error) {
+            console.error('Invalid value provided to format:', value);
+            return '0';
+        }
+    }
+}
+exports.BSBigNumberHelper = BSBigNumberHelper;

package/dist/helpers/BSTokenHelper.d.ts

@@ -0,0 +1,21 @@
+import { Token } from '../interfaces';
+type TPredicateToken = {
+    hash: string;
+    symbol?: string;
+};
+export declare class BSTokenHelper {
+    static predicate({ hash, symbol }: TPredicateToken): (params: TPredicateToken) => boolean;
+    static predicateByHash(tokenOrHash: string | {
+        hash: string;
+    }): (params: string | {
+        hash: string;
+    }) => boolean;
+    static predicateBySymbol(tokenOrSymbol: string | {
+        symbol: string;
+    }): (params: string | {
+        symbol: string;
+    }) => boolean;
+    static normalizeToken<T extends Token | Token[]>(token: T): T;
+    static normalizeHash(hash: string): string;
+}
+export {};

package/dist/helpers/BSTokenHelper.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSTokenHelper = void 0;
+class BSTokenHelper {
+    static predicate({ hash, symbol }) {
+        const normalizedHash = this.normalizeHash(hash);
+        return (params) => {
+            if (normalizedHash === this.normalizeHash(params.hash))
+                return true;
+            if (symbol && params.symbol && symbol.toLowerCase() === params.symbol.toLowerCase())
+                return true;
+            return false;
+        };
+    }
+    static predicateByHash(tokenOrHash) {
+        const hash = typeof tokenOrHash === 'string' ? tokenOrHash : tokenOrHash.hash;
+        const normalizedHash = this.normalizeHash(hash);
+        return (params) => normalizedHash === this.normalizeHash(typeof params === 'string' ? params : params.hash);
+    }
+    static predicateBySymbol(tokenOrSymbol) {
+        const symbol = typeof tokenOrSymbol === 'string' ? tokenOrSymbol : tokenOrSymbol.symbol;
+        const lowercaseSymbol = symbol.toLowerCase();
+        return (params) => {
+            const tokenSymbol = typeof params === 'string' ? params : params.symbol;
+            const lowercaseTokenSymbol = tokenSymbol.toLowerCase();
+            return lowercaseSymbol === lowercaseTokenSymbol;
+        };
+    }
+    static normalizeToken(token) {
+        if (Array.isArray(token)) {
+            return token.map(item => (Object.assign(Object.assign({}, item), { hash: this.normalizeHash(item.hash) })));
+        }
+        return Object.assign(Object.assign({}, token), { hash: this.normalizeHash(token.hash) });
+    }
+    static normalizeHash(hash) {
+        return hash.startsWith('0x') ? hash : `0x${hash}`;
+    }
+}
+exports.BSTokenHelper = BSTokenHelper;

package/dist/helpers/BSUtilsHelper.d.ts

@@ -0,0 +1,10 @@
+type RetryOptions = {
+    retries?: number;
+    delay?: number;
+    shouldRetry?: (error: any) => boolean;
+};
+export declare class BSUtilsHelper {
+    static wait(ms: number): Promise<unknown>;
+    static retry<T = any>(callback: () => Promise<T>, options?: RetryOptions): Promise<T>;
+}
+export {};

package/dist/helpers/BSUtilsHelper.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSUtilsHelper = void 0;
+class BSUtilsHelper {
+    static wait(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    static retry(callback, options) {
+        const { retries = 50, delay = 100, shouldRetry } = options || {};
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < retries; i++) {
+                try {
+                    const result = yield callback();
+                    return resolve(result);
+                }
+                catch (error) {
+                    if (shouldRetry && !shouldRetry(error)) {
+                        return reject(error);
+                    }
+                }
+                yield this.wait(delay);
+            }
+            return reject(new Error('timeout'));
+        }));
+    }
+}
+exports.BSUtilsHelper = BSUtilsHelper;

package/dist/index.d.ts

@@ -1,9 +1,12 @@
 export * from './constants/BSCommonConstants';
 export * from './helpers/BSFullTransactionsByAddressHelper';
 export * from './helpers/BSPromisesHelper';
-export * from './helpers/BSNumberHelper';
+export * from './helpers/BSBigNumberHelper';
+export * from './helpers/BSTokenHelper';
+export * from './helpers/BSUtilsHelper';
 export * from './services/exchange-data/CryptoCompareEDS';
 export * from './services/exchange-data/FlamingoForthewinEDS';
 export * from './BSAggregator';
 export * from './functions';
 export * from './interfaces';
+export * from './error';

package/dist/index.js

@@ -17,9 +17,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./constants/BSCommonConstants"), exports);
 __exportStar(require("./helpers/BSFullTransactionsByAddressHelper"), exports);
 __exportStar(require("./helpers/BSPromisesHelper"), exports);
-__exportStar(require("./helpers/BSNumberHelper"), exports);
+__exportStar(require("./helpers/BSBigNumberHelper"), exports);
+__exportStar(require("./helpers/BSTokenHelper"), exports);
+__exportStar(require("./helpers/BSUtilsHelper"), exports);
 __exportStar(require("./services/exchange-data/CryptoCompareEDS"), exports);
 __exportStar(require("./services/exchange-data/FlamingoForthewinEDS"), exports);
 __exportStar(require("./BSAggregator"), exports);
 __exportStar(require("./functions"), exports);
 __exportStar(require("./interfaces"), exports);
+__exportStar(require("./error"), exports);

package/dist/interfaces.d.ts

@@ -76,6 +76,9 @@ export interface BSWithLedger<BSName extends string = string> {
     ledgerService: LedgerService<BSName>;
     generateAccountFromPublicKey(publicKey: string): Account<BSName>;
 }
+export interface IBSWithNeo3NeoXBridge<BSName extends string = string> {
+    neo3NeoXBridgeService: INeo3NeoXBridgeService<BSName>;
+}
 export type TransactionNotificationTypedResponse = {
     type: string;
     value?: string;
@@ -359,3 +362,37 @@ export interface SwapService<BSName extends string = string> {
     swap(): Promise<SwapServiceSwapResult>;
     calculateFee(): Promise<string>;
 }
+export type TNeo3NeoXBridgeServiceCalculateMaxAmountParams<BSName extends string> = {
+    account: Account<BSName>;
+    receiverAddress: string;
+    token: Token;
+    balances: BalanceResponse[];
+};
+export type TNeo3NeoXBridgeServiceValidatedInputs = {
+    amount: string;
+    receiveAmount: string;
+    token: Token;
+};
+export type TNeo3NeoXBridgeServiceBridgeParam<BSName extends string> = {
+    account: Account<BSName>;
+    receiverAddress: string;
+    validatedInputs: TNeo3NeoXBridgeServiceValidatedInputs;
+};
+export type TNeo3NeoXBridgeServiceValidateInputParams<BSName extends string> = {
+    account: Account<BSName>;
+    receiverAddress: string;
+    amount: string;
+    token: Token;
+    balances: BalanceResponse[];
+};
+export type TNeo3NeoXBridgeServiceWaitParams = {
+    transactionHash: string;
+    validatedInputs: TNeo3NeoXBridgeServiceValidatedInputs;
+};
+export interface INeo3NeoXBridgeService<BSName extends string = string> {
+    calculateMaxAmount(params: TNeo3NeoXBridgeServiceCalculateMaxAmountParams<BSName>): Promise<string>;
+    calculateFee(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
+    bridge(params: TNeo3NeoXBridgeServiceBridgeParam<BSName>): Promise<string>;
+    validateInputs(params: TNeo3NeoXBridgeServiceValidateInputParams<BSName>): Promise<TNeo3NeoXBridgeServiceValidatedInputs>;
+    wait(params: TNeo3NeoXBridgeServiceWaitParams): Promise<boolean>;
+}

package/dist/services/exchange-data/FlamingoForthewinEDS.d.ts

@@ -4,5 +4,4 @@ export declare class FlamingoForthewinEDS extends CryptoCompareEDS implements Ex
     #private;
     constructor();
     getTokenPrices({ tokens }: GetTokenPricesParams): Promise<TokenPricesResponse[]>;
-    private predicateToken;
 }

package/dist/services/exchange-data/FlamingoForthewinEDS.js

@@ -21,7 +21,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlamingoForthewinEDS = void 0;
 const axios_1 = __importDefault(require("axios"));
 const CryptoCompareEDS_1 = require("./CryptoCompareEDS");
-const functions_1 = require("../../functions");
+const BSTokenHelper_1 = require("../../helpers/BSTokenHelper");
 class FlamingoForthewinEDS extends CryptoCompareEDS_1.CryptoCompareEDS {
     constructor() {
         super();
@@ -33,13 +33,13 @@ class FlamingoForthewinEDS extends CryptoCompareEDS_1.CryptoCompareEDS {
             const { data: flamingoData } = yield __classPrivateFieldGet(this, _FlamingoForthewinEDS_flamingoAxiosInstance, "f").get('/live-data/prices/latest');
             const prices = [];
             const neoToken = tokens.find(({ symbol }) => symbol === 'NEO');
-            if (neoToken && !flamingoData.find(this.predicateToken(neoToken)))
+            if (neoToken && !flamingoData.find(BSTokenHelper_1.BSTokenHelper.predicate(neoToken)))
                 flamingoData.forEach(item => {
                     if (item.symbol === 'bNEO')
                         flamingoData.push(Object.assign(Object.assign({}, item), { symbol: neoToken.symbol, hash: neoToken.hash }));
                 });
             flamingoData.forEach(item => {
-                const token = tokens.find(this.predicateToken(item));
+                const token = tokens.find(BSTokenHelper_1.BSTokenHelper.predicate(item));
                 if (!token)
                     return;
                 prices.push({ usdPrice: item.usd_price, token });
@@ -47,10 +47,10 @@ class FlamingoForthewinEDS extends CryptoCompareEDS_1.CryptoCompareEDS {
             if (tokens.length > prices.length) {
                 const { data: forthewinData } = yield __classPrivateFieldGet(this, _FlamingoForthewinEDS_forthewinAxiosInstance, "f").get('/mainnet/prices');
                 Object.entries(forthewinData).forEach(([hash, usdPrice]) => {
-                    const hasPrice = !!prices.find(({ token }) => this.predicateToken({ hash })(token));
+                    const hasPrice = !!prices.find(({ token }) => BSTokenHelper_1.BSTokenHelper.predicate({ hash })(token));
                     if (hasPrice)
                         return;
-                    const foundToken = tokens.find(this.predicateToken({ hash }));
+                    const foundToken = tokens.find(BSTokenHelper_1.BSTokenHelper.predicate({ hash }));
                     if (!foundToken)
                         return;
                     prices.push({ usdPrice, token: foundToken });
@@ -59,10 +59,6 @@ class FlamingoForthewinEDS extends CryptoCompareEDS_1.CryptoCompareEDS {
             return prices;
         });
     }
-    predicateToken({ hash, symbol }) {
-        const normalizedHash = (0, functions_1.normalizeHash)(hash);
-        return (params) => normalizedHash === (0, functions_1.normalizeHash)(params.hash) || (!!symbol && !!params.symbol && symbol === params.symbol);
-    }
 }
 exports.FlamingoForthewinEDS = FlamingoForthewinEDS;
 _FlamingoForthewinEDS_flamingoAxiosInstance = new WeakMap(), _FlamingoForthewinEDS_forthewinAxiosInstance = new WeakMap();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/blockchain-service",
-  "version": "1.18.2",
+  "version": "1.19.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -25,7 +25,8 @@
   "dependencies": {
     "@ledgerhq/hw-transport": "~6.30.5",
     "axios": "1.8.2",
-    "date-fns": "~4.1.0"
+    "date-fns": "~4.1.0",
+    "bignumber.js": "~9.3.0"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",

package/dist/helpers/BSNumberHelper.d.ts

@@ -1,16 +0,0 @@
-type FormatNumberOptions = {
-    decimals?: number;
-    shouldRemoveLeadingZero?: boolean;
-    shouldRemoveTrailingZero?: boolean;
-};
-export declare class BSNumberHelper {
-    static readonly sciNotationRegex: RegExp;
-    static countDecimals(value: string | number): number;
-    static sanitizeCommasAndDotsInNumber(value: string): string;
-    static isSciNotationValue(value: string): boolean;
-    static convertSciNotationValueToString(value: number): string;
-    static removeLeadingZero(value: string): string;
-    static removeTrailingZero(value: string): string;
-    static formatNumber(value?: string | number, options?: FormatNumberOptions): string;
-}
-export {};

package/dist/helpers/BSNumberHelper.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BSNumberHelper = void 0;
-class BSNumberHelper {
-    static countDecimals(value) {
-        var _b;
-        const [, decimals] = value.toString().split('.');
-        return (_b = decimals === null || decimals === void 0 ? void 0 : decimals.length) !== null && _b !== void 0 ? _b : 0;
-    }
-    static sanitizeCommasAndDotsInNumber(value) {
-        let newValue = value.replace(/,|\.\.|\.,|,,/g, '.');
-        const parts = newValue.split('.');
-        if (parts.length > 2)
-            newValue = `${parts[0]}.${parts.slice(1).join('')}`;
-        return newValue;
-    }
-    static isSciNotationValue(value) {
-        return BSNumberHelper.sciNotationRegex.test(value);
-    }
-    static convertSciNotationValueToString(value) {
-        if (Math.abs(value) < 1.0) {
-            const parts = value.toString().split('e-');
-            const hasNegativeExponent = parts.length === 2;
-            if (hasNegativeExponent) {
-                const negativeExponent = parseInt(parts[1], 10);
-                value *= Math.pow(10, negativeExponent - 1);
-                return `0.${'0'.repeat(negativeExponent - 1)}${value.toString().substring(2)}`;
-            }
-        }
-        return value.toString();
-    }
-    static removeLeadingZero(value) {
-        return value.replace(/^0+(?!\.)/, '') || '0';
-    }
-    static removeTrailingZero(value) {
-        return value.replace(/(\.\d*?[1-9])0+$/g, '$1').replace(/\.0+$/, '');
-    }
-    static formatNumber(value, options) {
-        if (!value)
-            return '0';
-        const { decimals = 0, shouldRemoveLeadingZero = true, shouldRemoveTrailingZero = true } = options !== null && options !== void 0 ? options : {};
-        let newValue = typeof value === 'number' ? value.toString() : value.trim();
-        newValue = BSNumberHelper.sanitizeCommasAndDotsInNumber(newValue);
-        const newValueAsNumber = Number(newValue);
-        if (isNaN(newValueAsNumber))
-            return '0';
-        const isNegativeValue = newValue.startsWith('-');
-        if (BSNumberHelper.isSciNotationValue(newValue))
-            newValue = BSNumberHelper.convertSciNotationValueToString(newValueAsNumber);
-        if (decimals === 0)
-            newValue = newValue.split('.')[0];
-        else {
-            newValue = newValue.replace(/[^\d.]/g, '');
-            const countedDecimals = BSNumberHelper.countDecimals(newValue);
-            if (countedDecimals > decimals)
-                newValue = newValue.slice(0, newValue.length - countedDecimals + decimals);
-        }
-        newValue = newValue.replace(/\s|-/g, '').replace(/^([^.]*\.)(.*)$/, (_a, b, c) => b + c.replace(/\./g, ''));
-        if (shouldRemoveLeadingZero)
-            newValue = BSNumberHelper.removeLeadingZero(newValue);
-        if (shouldRemoveTrailingZero)
-            newValue = BSNumberHelper.removeTrailingZero(newValue);
-        if (newValue.startsWith('.'))
-            newValue = `0${newValue}`;
-        if (newValue.endsWith('.'))
-            newValue = newValue.slice(0, newValue.length - 1);
-        if (!newValue)
-            newValue = '0';
-        if (newValue !== '0' && isNegativeValue)
-            newValue = `-${newValue}`;
-        return newValue;
-    }
-}
-exports.BSNumberHelper = BSNumberHelper;
-BSNumberHelper.sciNotationRegex = /^[+-]?\d+(\.\d+)?e[+-]?\d+$/i;