@swapkit/helpers 1.0.0-rc.5 → 1.0.0-rc.50

package/src/modules/assetValue.ts

@@ -17,10 +17,18 @@ import type { CommonAssetString } from '../helpers/asset.ts';
 import { getAssetType, getCommonAssetInfo, getDecimal, isGasAsset } from '../helpers/asset.ts';
 import { validateIdentifier } from '../helpers/validators.ts';
 
-import { BigIntArithmetics } from './bigIntArithmetics.ts';
+import type { NumberPrimitives } from './bigIntArithmetics.ts';
+import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
 import type { SwapKitValueType } from './swapKitNumber.ts';
 
-type AssetValueParams = { decimal: number; value: SwapKitValueType } & (
+type TokenTax = { buy: number; sell: number };
+
+const safeValue = (value: NumberPrimitives, decimal: number) =>
+  typeof value === 'bigint'
+    ? formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
+    : value;
+
+type AssetValueParams = { decimal: number; value: SwapKitValueType; tax?: TokenTax } & (
   | { chain: Chain; symbol: string }
   | { identifier: string }
 );
@@ -40,7 +48,9 @@ type TokenNames =
   | (typeof WoofiList)['tokens'][number]['identifier']
   | (typeof UniswapList)['tokens'][number]['identifier'];
 
-let staticTokensMap: Map<TokenNames, { decimal: number; identifier: string }> | undefined;
+let staticTokensMap:
+  | Map<TokenNames, { tax?: TokenTax; decimal: number; identifier: string }>
+  | undefined;
 
 const getStaticToken = (identifier: TokenNames) => {
   if (!staticTokensMap) {
@@ -51,31 +61,35 @@ const getStaticToken = (identifier: TokenNames) => {
   return tokenInfo || { decimal: BaseDecimal.THOR, identifier: '' };
 };
 
-const createAssetValue = async (assetString: string, value: number | string = 0) => {
+const createAssetValue = async (assetString: string, value: NumberPrimitives = 0) => {
   validateIdentifier(assetString);
 
   const decimal = await getDecimal(getAssetInfo(assetString));
-  return new AssetValue({ decimal, value, identifier: assetString });
+  const parsedValue = safeValue(value, decimal);
+
+  return new AssetValue({ decimal, value: parsedValue, identifier: assetString });
 };
 
 export class AssetValue extends BigIntArithmetics {
   address?: string;
   chain: Chain;
-  isSynthetic = false;
   isGasAsset = false;
+  isSynthetic = false;
   symbol: string;
+  tax?: TokenTax;
   ticker: string;
   type: ReturnType<typeof getAssetType>;
 
   constructor(params: AssetValueParams) {
+    const identifier =
+      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
+
     super(
       params.value instanceof BigIntArithmetics
         ? params.value
         : { decimal: params.decimal, value: params.value },
     );
 
-    const identifier =
-      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
     const assetInfo = getAssetInfo(identifier);
 
     this.type = getAssetType(assetInfo);
@@ -85,94 +99,94 @@ export class AssetValue extends BigIntArithmetics {
     this.address = assetInfo.address;
     this.isSynthetic = assetInfo.isSynthetic;
     this.isGasAsset = assetInfo.isGasAsset;
-  }
 
-  get assetValue() {
-    return `${this.getValue('string')} ${this.ticker}`;
+    this.tax = params.tax;
   }
 
   toString() {
-    return `${this.chain}.${this.symbol}`;
+    return this.isSynthetic ? this.symbol : `${this.chain}.${this.symbol}`;
+  }
+
+  toUrl() {
+    return this.isSynthetic ? `${this.chain}.${this.symbol.replace('/', '.')}` : this.toString();
   }
 
   eq({ chain, symbol }: { chain: Chain; symbol: string }) {
     return this.chain === chain && this.symbol === symbol;
   }
 
-  static async fromString(assetString: string, value: number | string = 0) {
+  // THOR.RUNE
+  // THOR.ETH.ETH
+  // ETH.THOR-0x1234567890
+  static fromUrl(urlAsset: string, value: NumberPrimitives = 0) {
+    const [chain, ticker, symbol] = urlAsset.split('.');
+    if (!chain || !ticker) throw new Error('Invalid asset url');
+
+    const assetString =
+      chain === Chain.THORChain && symbol ? `${chain}.${ticker}/${symbol}` : urlAsset;
+
     return createAssetValue(assetString, value);
   }
 
-  static fromStringSync(assetString: string, value: number | string = 0) {
-    const { decimal, identifier: tokenIdentifier } = getStaticToken(
-      assetString as unknown as TokenNames,
-    );
+  static fromString(assetString: string, value: NumberPrimitives = 0) {
+    return createAssetValue(assetString, value);
+  }
+
+  static fromStringSync(assetString: string, value: NumberPrimitives = 0) {
+    const { isSynthetic } = getAssetInfo(assetString);
+    const {
+      tax,
+      decimal,
+      identifier: tokenIdentifier,
+    } = getStaticToken(assetString as unknown as TokenNames);
+
+    const parsedValue = safeValue(value, decimal);
+
+    const asset = tokenIdentifier
+      ? new AssetValue({ tax, decimal, identifier: tokenIdentifier, value: parsedValue })
+      : isSynthetic
+        ? new AssetValue({ tax, decimal: 8, identifier: assetString, value: parsedValue })
+        : undefined;
 
-    return tokenIdentifier
-      ? new AssetValue({ decimal, identifier: tokenIdentifier, value })
-      : undefined;
+    return asset;
   }
 
-  static async fromIdentifier(
+  static fromIdentifier(
     assetString: `${Chain}.${string}` | `${Chain}/${string}` | `${Chain}.${string}-${string}`,
-    value: number | string = 0,
+    value: NumberPrimitives = 0,
   ) {
     return createAssetValue(assetString, value);
   }
 
-  static fromIdentifierSync(identifier: TokenNames, value: number | string = 0) {
+  static fromIdentifierSync(identifier: TokenNames, value: NumberPrimitives = 0) {
     const { decimal, identifier: tokenIdentifier } = getStaticToken(identifier);
+    const parsedValue = safeValue(value, decimal);
 
-    return new AssetValue({ decimal, identifier: tokenIdentifier, value });
+    return new AssetValue({ decimal, identifier: tokenIdentifier, value: parsedValue });
   }
 
-  static fromChainOrSignature(assetString: CommonAssetString, value: number | string = 0) {
+  static fromChainOrSignature(assetString: CommonAssetString, value: NumberPrimitives = 0) {
     const { decimal, identifier } = getCommonAssetInfo(assetString);
+    const parsedValue = safeValue(value, decimal);
 
-    return new AssetValue({ value, decimal, identifier });
-  }
-
-  static async fromTCQuote(identifier: TCTokenNames, value: number | string = 0) {
-    const decimal = await getDecimal(getAssetInfo(identifier));
-    const shiftedValue = this.shiftDecimals({ value, from: BaseDecimal.THOR, to: decimal });
-
-    return new AssetValue({ value: shiftedValue, identifier, decimal });
-  }
-
-  static fromTCQuoteStatic(identifier: TCTokenNames, value: number | string = 0) {
-    const tokenInfo = getStaticToken(identifier);
-    const shiftedValue = this.shiftDecimals({
-      value,
-      from: BaseDecimal.THOR,
-      to: tokenInfo.decimal,
-    });
-
-    return new AssetValue({ ...tokenInfo, value: shiftedValue });
+    return new AssetValue({ value: parsedValue, decimal, identifier });
   }
 
-  static async loadStaticAssets() {
+  static loadStaticAssets() {
     return new Promise<{ ok: true } | { ok: false; message: string; error: any }>(
       async (resolve, reject) => {
         try {
-          const {
-            // Omit ThorchainList from import to avoid decimals conflict (TC uses 8 for all)
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            ThorchainList: _ThorchainList,
-            NativeList,
-            ...tokensPackage
-          } = await import('@swapkit/tokens');
-          const tokensMap = [NativeList, ...Object.values(tokensPackage)].reduce(
-            (acc, { tokens }) => {
-              tokens.forEach(({ identifier, chain, ...rest }) => {
-                const decimal = 'decimals' in rest ? rest.decimals : BaseDecimal[chain as Chain];
-
-                acc.set(identifier as TokenNames, { identifier, decimal });
+          const tokenPackages = await import('@swapkit/tokens');
+          const tokensMap = Object.values(tokenPackages).reduce((acc, tokenList) => {
+            tokenList?.tokens?.forEach(({ identifier, chain, ...rest }) => {
+              acc.set(identifier as TokenNames, {
+                identifier,
+                decimal: 'decimals' in rest ? rest.decimals : BaseDecimal[chain as Chain],
               });
+            });
 
-              return acc;
-            },
-            new Map<TokenNames, { decimal: number; identifier: string }>(),
-          );
+            return acc;
+          }, new Map<TokenNames, { decimal: number; identifier: string }>());
 
           staticTokensMap = tokensMap;
 
@@ -198,39 +212,41 @@ export const getMinAmountByChain = (chain: Chain) => {
     case Chain.Bitcoin:
     case Chain.Litecoin:
     case Chain.BitcoinCash:
-      return asset.add(10001);
+      return asset.set(0.00010001);
 
     case Chain.Dogecoin:
-      return asset.add(100000001);
+      return asset.set(1.00000001);
 
     case Chain.Avalanche:
     case Chain.Ethereum:
-      return asset.add(10 * 10 ** 9);
+      return asset.set(0.00000001);
 
     case Chain.THORChain:
     case Chain.Maya:
-      return asset.add(0);
+      return asset.set(0);
 
     default:
-      return asset.add(1);
+      return asset.set(0.00000001);
   }
 };
 
 const getAssetInfo = (identifier: string) => {
   const isSynthetic = identifier.slice(0, 14).includes('/');
-  const adjustedIdentifier = identifier.includes('.')
-    ? identifier
-    : `${Chain.THORChain}.${identifier}`;
+  const [synthChain, synthSymbol] = identifier.split('.').pop()!.split('/');
+  const adjustedIdentifier =
+    identifier.includes('.') && !isSynthetic ? identifier : `${Chain.THORChain}.${synthSymbol}`;
 
   const [chain, symbol] = adjustedIdentifier.split('.') as [Chain, string];
-  const [ticker, address] = symbol.split('-') as [string, string?];
+  const [ticker, address] = (isSynthetic ? synthSymbol : symbol).split('-') as [string, string?];
 
   return {
     address: address?.toLowerCase(),
     chain,
     isGasAsset: isGasAsset({ chain, symbol }),
     isSynthetic,
-    symbol: address ? `${ticker}-${address?.toLowerCase() ?? ''}` : symbol,
-    ticker: isSynthetic ? symbol : ticker,
+    symbol:
+      (isSynthetic ? `${synthChain}/` : '') +
+      (address ? `${ticker}-${address?.toLowerCase() ?? ''}` : symbol),
+    ticker,
   };
 };

package/src/modules/bigIntArithmetics.ts

@@ -1,3 +1,5 @@
+import { BaseDecimal } from '@swapkit/types';
+
 import type { SwapKitNumber } from './swapKitNumber.ts';
 
 type NumberPrimitivesType = {
@@ -5,10 +7,11 @@ type NumberPrimitivesType = {
   number: number;
   string: string;
 };
-type NumberPrimitives = bigint | number | string;
+export type NumberPrimitives = bigint | number | string;
 type InitialisationValueType = NumberPrimitives | BigIntArithmetics | SwapKitNumber;
 
 type SKBigIntParams = InitialisationValueType | { decimal?: number; value: number | string };
+type AllowedNumberTypes = 'bigint' | 'number' | 'string';
 
 const DEFAULT_DECIMAL = 8;
 const toMultiplier = (decimal: number) => 10n ** BigInt(decimal);
@@ -69,38 +72,30 @@ export class BigIntArithmetics {
     from,
     to,
   }: {
-    value: InitialisationValueType;
+    value: InstanceType<typeof SwapKitNumber>;
     from: number;
     to: number;
   }) {
-    return BigIntArithmetics.fromBigInt(
-      (new BigIntArithmetics(value).bigIntValue * toMultiplier(to)) / toMultiplier(from),
+    return this.fromBigInt(
+      (value.getBaseValue('bigint') * toMultiplier(to)) / toMultiplier(from),
       to,
     );
   }
 
   constructor(params: SKBigIntParams) {
     const value = getStringValue(params);
-    this.decimal = typeof params === 'object' ? params.decimal : undefined;
+    const isComplex = typeof params === 'object';
+    this.decimal = isComplex ? params.decimal : undefined;
 
     // use the multiplier to keep track of decimal point - defaults to 8 if lower than 8
-    this.decimalMultiplier = toMultiplier(
-      Math.max(this.#getFloatDecimals(this.#toSafeValue(value)), this.decimal || 0),
-    );
+    this.decimalMultiplier =
+      isComplex && 'decimalMultiplier' in params
+        ? params.decimalMultiplier
+        : toMultiplier(Math.max(getFloatDecimals(toSafeValue(value)), this.decimal || 0));
     this.#setValue(value);
   }
 
-  get baseValue() {
-    return this.getBaseValue('string') as string;
-  }
-  get baseValueNumber() {
-    return this.getBaseValue('number') as number;
-  }
-  get baseValueBigInt() {
-    return this.getBaseValue('bigint') as bigint;
-  }
-
-  set(value: SKBigIntParams) {
+  set(value: SKBigIntParams): this {
     // @ts-expect-error False positive
     return new this.constructor({ decimal: this.decimal, value, identifier: this.toString() });
   }
@@ -117,22 +112,23 @@ export class BigIntArithmetics {
     return this.#arithmetics('div', ...args);
   }
   gt(value: InitialisationValueType) {
-    return this.bigIntValue > this.getBigIntValue(value);
+    return this.#comparison('gt', value);
   }
   gte(value: InitialisationValueType) {
-    return this.bigIntValue >= this.getBigIntValue(value);
+    return this.#comparison('gte', value);
   }
   lt(value: InitialisationValueType) {
-    return this.bigIntValue < this.getBigIntValue(value);
+    return this.#comparison('lt', value);
   }
   lte(value: InitialisationValueType) {
-    return this.bigIntValue <= this.getBigIntValue(value);
+    return this.#comparison('lte', value);
   }
   eqValue(value: InitialisationValueType) {
-    return this.bigIntValue === this.getBigIntValue(value);
+    return this.#comparison('eqValue', value);
   }
 
-  getValue<T extends 'number' | 'string' | 'bigint'>(type: T): NumberPrimitivesType[T] {
+  // @ts-expect-error False positive
+  getValue<T extends AllowedNumberTypes>(type: T): NumberPrimitivesType[T] {
     const value = this.formatBigIntToSafeValue(
       this.bigIntValue,
       this.decimal || decimalFromMultiplier(this.decimalMultiplier),
@@ -140,38 +136,125 @@ export class BigIntArithmetics {
 
     switch (type) {
       case 'number':
-        // @ts-expect-error False positive
-        return Number(value);
+        return Number(value) as NumberPrimitivesType[T];
       case 'string':
-        // @ts-expect-error False positive
-        return value;
-      default:
-        // @ts-expect-error False positive
-        return this.bigIntValue;
+        return value as NumberPrimitivesType[T];
+      case 'bigint':
+        return ((this.bigIntValue * 10n ** BigInt(this.decimal || 8n)) /
+          this.decimalMultiplier) as NumberPrimitivesType[T];
     }
   }
 
-  getBaseValue<T extends 'number' | 'string' | 'bigint'>(type: T): NumberPrimitivesType[T] {
-    const divisor = this.decimalMultiplier / toMultiplier(this.decimal || 0);
+  // @ts-expect-error
+  getBaseValue<T extends AllowedNumberTypes>(type: T): NumberPrimitivesType[T] {
+    const divisor = this.decimalMultiplier / toMultiplier(this.decimal || BaseDecimal.THOR);
     const baseValue = this.bigIntValue / divisor;
 
     switch (type) {
       case 'number':
-        // @ts-expect-error False positive
-        return Number(baseValue);
+        return Number(baseValue) as NumberPrimitivesType[T];
       case 'string':
-        // @ts-expect-error False positive
-        return baseValue.toString();
-      default:
-        // @ts-expect-error False positive
-        return this.bigIntValue;
+        return baseValue.toString() as NumberPrimitivesType[T];
+      case 'bigint':
+        return baseValue as NumberPrimitivesType[T];
     }
   }
 
   getBigIntValue(value: InitialisationValueType, decimal?: number) {
     if (!decimal && typeof value === 'object') return value.bigIntValue;
 
-    return this.#toBigInt(this.#toSafeValue(getStringValue(value)), decimal);
+    const stringValue = getStringValue(value);
+    const safeValue = toSafeValue(stringValue);
+
+    if (safeValue === '0' || safeValue === 'undefined') return 0n;
+    return this.#toBigInt(safeValue, decimal);
+  }
+
+  toSignificant(significantDigits: number = 6) {
+    const [int, dec] = this.getValue('string').split('.');
+    const integer = int || '';
+    const decimal = dec || '';
+    const 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 `${integer}.${decimal.slice(0, significantDigits - integer.length)}`.padEnd(
+        significantDigits - integer.length,
+        '0',
+      );
+    }
+
+    const trimmedDecimal = parseInt(decimal);
+    const slicedDecimal = `${trimmedDecimal}`.slice(0, significantDigits);
+
+    return `0.${slicedDecimal.padStart(
+      decimal.length - `${trimmedDecimal}`.length + slicedDecimal.length,
+      '0',
+    )}`;
+  }
+
+  toFixed(fixedDigits: number = 6) {
+    const [int, dec] = this.getValue('string').split('.');
+    const integer = int || '';
+    const decimal = dec || '';
+
+    if (parseInt(integer)) {
+      return `${integer}.${decimal.slice(0, fixedDigits)}`.padEnd(fixedDigits, '0');
+    }
+
+    const trimmedDecimal = parseInt(decimal);
+    const slicedDecimal = `${trimmedDecimal}`.slice(0, fixedDigits);
+
+    return `0.${slicedDecimal.padStart(
+      decimal.length - `${trimmedDecimal}`.length + slicedDecimal.length,
+      '0',
+    )}`;
+  }
+
+  toAbbreviation(digits = 2) {
+    const value = this.getValue('number');
+    const abbreviations = ['', 'K', 'M', 'B', 'T', 'Q', 'Qi', 'S'];
+    const tier = Math.floor(Math.log10(Math.abs(value)) / 3);
+    const suffix = abbreviations[tier];
+
+    if (!suffix) return this.getValue('string');
+
+    const scale = 10 ** (tier * 3);
+    const scaled = value / scale;
+
+    return `${scaled.toFixed(digits)}${suffix}`;
+  }
+
+  toCurrency(
+    currency = '$',
+    {
+      currencyPosition = 'start',
+      decimal = 2,
+      decimalSeparator = '.',
+      thousandSeparator = ',',
+    } = {},
+  ) {
+    const value = this.getValue('number');
+    const [int, dec = ''] = value.toFixed(6).split('.');
+    const integer = int.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator);
+
+    const parsedValue =
+      !int && !dec
+        ? '0.00'
+        : int === '0'
+          ? `${parseFloat(`0.${dec}`)}`.replace('.', decimalSeparator)
+          : `${integer}${parseInt(dec) ? `${decimalSeparator}${dec.slice(0, decimal)}` : ''}`;
+
+    return `${currencyPosition === 'start' ? currency : ''}${parsedValue}${
+      currencyPosition === 'end' ? currency : ''
+    }`;
   }
 
   formatBigIntToSafeValue(value: bigint, decimal?: number) {
@@ -207,43 +290,14 @@ export class BigIntArithmetics {
     )}.${decimalString}`.replace(/\.?0*$/, '');
   }
 
-  toSignificant(significantDigits: number = 6) {
-    const [int, dec] = this.getValue('string').split('.');
-    const integer = int || '';
-    const decimal = dec || '';
-    const 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 `${integer}.${decimal.slice(0, significantDigits - integer.length)}`.padEnd(
-        valueLength - significantDigits,
-        '0',
-      );
-    }
-
-    const trimmedDecimal = parseInt(decimal);
-    const slicedDecimal = `${trimmedDecimal}`.slice(0, significantDigits);
-
-    return `0.${slicedDecimal.padStart(
-      decimal.length - `${trimmedDecimal}`.length + slicedDecimal.length,
-      '0',
-    )}`;
-  }
-
   #arithmetics(method: 'add' | 'sub' | 'mul' | 'div', ...args: InitialisationValueType[]): this {
     const precisionDecimal = this.#retrievePrecisionDecimal(this, ...args);
-    const precisionDecimalMultiplier = toMultiplier(precisionDecimal);
+    const decimal = Math.max(precisionDecimal, decimalFromMultiplier(this.decimalMultiplier));
+    const precisionDecimalMultiplier = toMultiplier(decimal);
 
     const result = args.reduce(
       (acc: bigint, arg) => {
-        const value = this.getBigIntValue(arg, precisionDecimal);
+        const value = this.getBigIntValue(arg, decimal);
 
         switch (method) {
           case 'add':
@@ -273,65 +327,92 @@ export class BigIntArithmetics {
     );
 
     const value = formatBigIntToSafeValue({
-      bigIntDecimal: precisionDecimal,
-      decimal: Math.max(precisionDecimal, decimalFromMultiplier(this.decimalMultiplier)),
+      bigIntDecimal: decimal,
+      decimal,
       value: result,
     });
 
     // @ts-expect-error False positive
-    return new this.constructor({ decimal: this.decimal, value, identifier: this.toString() });
+    return new this.constructor({
+      decimalMultiplier: toMultiplier(decimal),
+      decimal: this.decimal,
+      value,
+      identifier: this.toString(),
+    });
+  }
+
+  #comparison(method: 'gt' | 'gte' | 'lt' | 'lte' | 'eqValue', ...args: InitialisationValueType[]) {
+    const decimal = this.#retrievePrecisionDecimal(this, ...args);
+    const value = this.getBigIntValue(args[0], decimal);
+    const 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;
+    }
   }
 
   #setValue(value: InitialisationValueType) {
-    const safeValue = this.#toSafeValue(value) || '0';
+    const safeValue = toSafeValue(value) || '0';
     this.bigIntValue = this.#toBigInt(safeValue);
   }
 
   #retrievePrecisionDecimal(...args: InitialisationValueType[]) {
     const decimals = args
-      .map((arg) =>
-        typeof arg === 'object'
+      .map((arg) => {
+        const isObject = typeof arg === 'object';
+        const value = isObject
           ? arg.decimal || decimalFromMultiplier(arg.decimalMultiplier)
-          : this.#getFloatDecimals(this.#toSafeValue(arg)),
-      )
+          : getFloatDecimals(toSafeValue(arg));
+
+        return value;
+      })
       .filter(Boolean) as number[];
+
     return Math.max(...decimals, DEFAULT_DECIMAL);
   }
 
   #toBigInt(value: string, decimal?: number) {
     const multiplier = decimal ? toMultiplier(decimal) : this.decimalMultiplier;
     const padDecimal = decimalFromMultiplier(multiplier);
-    const [integerPart, decimalPart = ''] = value.split('.');
+    const [integerPart = '', decimalPart = ''] = value.split('.');
 
     return BigInt(`${integerPart}${decimalPart.padEnd(padDecimal, '0')}`);
   }
+}
 
-  #toSafeValue(value: InitialisationValueType) {
-    const parsedValue =
-      typeof value === 'number'
-        ? Number(value).toLocaleString('fullwide', {
-            useGrouping: false,
-            maximumFractionDigits: 20,
-          })
-        : getStringValue(value);
-
-    const splitValue = `${parsedValue}`.replaceAll(',', '.').split('.');
-
-    return splitValue.length > 1
-      ? `${splitValue.slice(0, -1).join('')}.${splitValue.at(-1)}`
-      : splitValue[0];
-  }
+const numberFormatter = Intl.NumberFormat('fullwide', {
+  useGrouping: false,
+  maximumFractionDigits: 20,
+});
 
-  #getFloatDecimals(value: string) {
-    const decimals = value.split('.')[1]?.length || 0;
-    return Math.max(decimals, DEFAULT_DECIMAL);
-  }
+function toSafeValue(value: InitialisationValueType) {
+  const parsedValue =
+    typeof value === 'number' ? numberFormatter.format(value) : getStringValue(value);
+  const splitValue = `${parsedValue}`.replaceAll(',', '.').split('.');
+
+  return splitValue.length > 1
+    ? `${splitValue.slice(0, -1).join('')}.${splitValue.at(-1)}`
+    : splitValue[0];
+}
+
+function getFloatDecimals(value: string) {
+  const decimals = value.split('.')[1]?.length || 0;
+  return Math.max(decimals, DEFAULT_DECIMAL);
 }
 
-function getStringValue(value: SKBigIntParams) {
-  return typeof value === 'object'
-    ? 'getValue' in value
-      ? value.getValue('string')
-      : value.value
-    : value;
+function getStringValue(param: SKBigIntParams) {
+  return typeof param === 'object'
+    ? 'getValue' in param
+      ? param.getValue('string')
+      : param.value
+    : param;
 }