@swapkit/helpers 1.0.0-rc.70 → 1.0.0-rc.72

package/src/modules/assetValue.ts

@@ -1,13 +1,13 @@
-import { BaseDecimal, Chain, ChainToChainId } from '@swapkit/types';
+import { BaseDecimal, Chain, ChainToChainId } from "@swapkit/types";
 
-import type { CommonAssetString } from '../helpers/asset.ts';
-import { getAssetType, getCommonAssetInfo, getDecimal, isGasAsset } from '../helpers/asset.ts';
-import { validateIdentifier } from '../helpers/validators.ts';
-import type { TokenNames, TokenTax } from '../types.ts';
+import type { CommonAssetString } from "../helpers/asset.ts";
+import { getAssetType, getCommonAssetInfo, getDecimal, isGasAsset } from "../helpers/asset.ts";
+import { validateIdentifier } from "../helpers/validators.ts";
+import type { TokenNames, TokenTax } from "../types.ts";
 
-import type { NumberPrimitives } from './bigIntArithmetics.ts';
-import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
-import type { SwapKitValueType } from './swapKitNumber.ts';
+import type { NumberPrimitives } from "./bigIntArithmetics.ts";
+import { BigIntArithmetics, formatBigIntToSafeValue } from "./bigIntArithmetics.ts";
+import { SwapKitNumber, type SwapKitValueType } from "./swapKitNumber.ts";
 
 const staticTokensMap = new Map<
   TokenNames,
@@ -35,7 +35,7 @@ export class AssetValue extends BigIntArithmetics {
     | { chain: Chain; symbol: string; identifier?: never }
     | { identifier: string; chain?: never; symbol?: never }
   )) {
-    super(typeof value === 'object' ? value : { decimal, value });
+    super(typeof value === "object" ? value : { decimal, value });
 
     const assetInfo = getAssetInfo(identifier || `${chain}.${symbol}`);
 
@@ -54,7 +54,7 @@ export class AssetValue extends BigIntArithmetics {
   }
 
   toUrl() {
-    return this.isSynthetic ? `${this.chain}.${this.symbol.replace('/', '.')}` : this.toString();
+    return this.isSynthetic ? `${this.chain}.${this.symbol.replace("/", ".")}` : this.toString();
   }
 
   eq({ chain, symbol }: { chain: Chain; symbol: string }) {
@@ -69,8 +69,8 @@ export class AssetValue extends BigIntArithmetics {
   // 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 [chain, ticker, symbol] = urlAsset.split(".");
+    if (!(chain && ticker)) throw new Error("Invalid asset url");
 
     const assetString =
       chain === Chain.THORChain && symbol ? `${chain}.${ticker}/${symbol}` : urlAsset;
@@ -117,6 +117,44 @@ export class AssetValue extends BigIntArithmetics {
     });
   }
 
+  static async fromStringWithBase(
+    assetString: string,
+    value: NumberPrimitives = 0,
+    baseDecimal: number = BaseDecimal.THOR,
+  ) {
+    const shiftedAmount = BigIntArithmetics.shiftDecimals({
+      value: SwapKitNumber.fromBigInt(BigInt(value)),
+      from: 0,
+      to: baseDecimal,
+    }).getBaseValue("string");
+    const assetValue = await AssetValue.fromString(assetString, value);
+
+    return assetValue.set(shiftedAmount);
+  }
+
+  static fromStringWithBaseSync(
+    assetString: string,
+    value: NumberPrimitives = 0,
+    baseDecimal: number = BaseDecimal.THOR,
+  ) {
+    const { chain, isSynthetic } = getAssetInfo(assetString);
+    const tokenInfo = staticTokensMap.get(assetString.toUpperCase() as TokenNames);
+
+    if (isSynthetic) return createSyntheticAssetValue(assetString, value);
+
+    const { tax, decimal, identifier } = tokenInfo || {
+      decimal: BaseDecimal[chain],
+      identifier: assetString,
+    };
+
+    return new AssetValue({
+      tax,
+      value: safeValue(BigInt(value), baseDecimal),
+      identifier,
+      decimal,
+    });
+  }
+
   static fromIdentifierSync(assetString: TokenNames, value: NumberPrimitives = 0) {
     const { chain, isSynthetic } = getAssetInfo(assetString);
     const tokenInfo = staticTokensMap.get(assetString);
@@ -143,20 +181,20 @@ export class AssetValue extends BigIntArithmetics {
 
   static loadStaticAssets() {
     return new Promise<{ ok: true } | { ok: false; message: string; error: any }>(
-      async (resolve, reject) => {
+      (resolve, reject) => {
         try {
-          const tokenPackages = await import('@swapkit/tokens');
-
-          Object.values(tokenPackages).forEach((tokenList) => {
-            tokenList?.tokens?.forEach(({ identifier, chain, ...rest }) => {
-              staticTokensMap.set(identifier.toUpperCase() as TokenNames, {
-                identifier,
-                decimal: 'decimals' in rest ? rest.decimals : BaseDecimal[chain as Chain],
-              });
-            });
+          import("@swapkit/tokens").then((tokenPackages) => {
+            for (const tokenList of Object.values(tokenPackages)) {
+              for (const { identifier, chain, ...rest } of tokenList.tokens) {
+                staticTokensMap.set(identifier.toUpperCase() as TokenNames, {
+                  identifier,
+                  decimal: "decimals" in rest ? rest.decimals : BaseDecimal[chain as Chain],
+                });
+              }
+            }
+
+            resolve({ ok: true });
           });
-
-          resolve({ ok: true });
         } catch (error) {
           console.error(error);
           reject({
@@ -213,11 +251,11 @@ async function createAssetValue(identifier: string, value: NumberPrimitives = 0)
 
 function createSyntheticAssetValue(identifier: string, value: NumberPrimitives = 0) {
   const [synthChain, symbol] =
-    identifier.split('.')[0].toUpperCase() === Chain.THORChain
-      ? identifier.split('.').slice(1)!.join().split('/')
-      : identifier.split('/');
+    identifier.split(".")[0].toUpperCase() === Chain.THORChain
+      ? identifier.split(".").slice(1).join().split("/")
+      : identifier.split("/");
 
-  if (!synthChain || !symbol) throw new Error('Invalid asset identifier');
+  if (!(synthChain && symbol)) throw new Error("Invalid asset identifier");
 
   return new AssetValue({
     decimal: 8,
@@ -227,31 +265,31 @@ function createSyntheticAssetValue(identifier: string, value: NumberPrimitives =
 }
 
 function safeValue(value: NumberPrimitives, decimal: number) {
-  return typeof value === 'bigint'
+  return typeof value === "bigint"
     ? formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
     : value;
 }
 
 // TODO refactor & split into smaller functions
 function getAssetInfo(identifier: string) {
-  const isSynthetic = identifier.slice(0, 14).includes('/');
+  const isSynthetic = identifier.slice(0, 14).includes("/");
 
   const [synthChain, synthSymbol] =
-    identifier.split('.')[0].toUpperCase() === Chain.THORChain
-      ? identifier.split('.').slice(1)!.join().split('/')
-      : identifier.split('/');
+    identifier.split(".")[0].toUpperCase() === Chain.THORChain
+      ? identifier.split(".").slice(1).join().split("/")
+      : identifier.split("/");
 
-  if (isSynthetic && (!synthChain || !synthSymbol)) throw new Error('Invalid asset identifier');
+  if (isSynthetic && !(synthChain && synthSymbol)) throw new Error("Invalid asset identifier");
 
   const adjustedIdentifier =
-    identifier.includes('.') && !isSynthetic ? identifier : `${Chain.THORChain}.${synthSymbol}`;
+    identifier.includes(".") && !isSynthetic ? identifier : `${Chain.THORChain}.${synthSymbol}`;
 
-  const [chain, ...rest] = adjustedIdentifier.split('.') as [Chain, string];
-  const [ticker, address] = (isSynthetic ? synthSymbol : rest.join('.')).split('-') as [
+  const [chain, ...rest] = adjustedIdentifier.split(".") as [Chain, string];
+  const [ticker, address] = (isSynthetic ? synthSymbol : rest.join(".")).split("-") as [
     string,
     string?,
   ];
-  const symbol = isSynthetic ? synthSymbol : rest.join('.');
+  const symbol = isSynthetic ? synthSymbol : rest.join(".");
 
   return {
     address: address?.toLowerCase(),
@@ -259,8 +297,8 @@ function getAssetInfo(identifier: string) {
     isGasAsset: isGasAsset({ chain, symbol }),
     isSynthetic,
     symbol:
-      (isSynthetic ? `${synthChain}/` : '') +
-      (address ? `${ticker}-${address?.toLowerCase() ?? ''}` : symbol),
+      (isSynthetic ? `${synthChain}/` : "") +
+      (address ? `${ticker}-${address?.toLowerCase() ?? ""}` : symbol),
     ticker,
   };
 }

package/src/modules/bigIntArithmetics.ts

@@ -1,6 +1,6 @@
-import { BaseDecimal } from '@swapkit/types';
+import { BaseDecimal } from "@swapkit/types";
 
-import type { SwapKitNumber } from './swapKitNumber.ts';
+import type { SwapKitNumber } from "./swapKitNumber.ts";
 
 type NumberPrimitivesType = {
   bigint: bigint;
@@ -11,7 +11,7 @@ export type NumberPrimitives = bigint | number | string;
 type InitialisationValueType = NumberPrimitives | BigIntArithmetics | SwapKitNumber;
 
 type SKBigIntParams = InitialisationValueType | { decimal?: number; value: number | string };
-type AllowedNumberTypes = 'bigint' | 'number' | 'string';
+type AllowedNumberTypes = "bigint" | "number" | "string";
 
 const DEFAULT_DECIMAL = 8;
 const toMultiplier = (decimal: number) => 10n ** BigInt(decimal);
@@ -33,7 +33,7 @@ export function formatBigIntToSafeValue({
   const padLength = decimal - (valueString.length - 1);
 
   if (padLength > 0) {
-    valueString = '0'.repeat(padLength) + valueString;
+    valueString = "0".repeat(padLength) + valueString;
   }
 
   const decimalIndex = valueString.length - decimal;
@@ -50,15 +50,15 @@ export function formatBigIntToSafeValue({
     decimalString = decimalString.substring(0, bigIntDecimal);
   }
 
-  return `${isNegative ? '-' : ''}${valueString.slice(0, decimalIndex)}.${decimalString}`.replace(
+  return `${isNegative ? "-" : ""}${valueString.slice(0, decimalIndex)}.${decimalString}`.replace(
     /\.?0*$/,
-    '',
+    "",
   );
 }
 
 export class BigIntArithmetics {
   decimalMultiplier: bigint = 10n ** 8n;
-  bigIntValue: bigint = 0n;
+  bigIntValue = 0n;
   decimal?: number;
 
   static fromBigInt(value: bigint, decimal?: number) {
@@ -77,20 +77,20 @@ export class BigIntArithmetics {
     from: number;
     to: number;
   }) {
-    return this.fromBigInt(
-      (value.getBaseValue('bigint') * toMultiplier(to)) / toMultiplier(from),
+    return BigIntArithmetics.fromBigInt(
+      (value.getBaseValue("bigint") * toMultiplier(to)) / toMultiplier(from),
       to,
     );
   }
 
   constructor(params: SKBigIntParams) {
     const value = getStringValue(params);
-    const isComplex = typeof params === 'object';
+    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 =
-      isComplex && 'decimalMultiplier' in params
+      isComplex && "decimalMultiplier" in params
         ? params.decimalMultiplier
         : toMultiplier(Math.max(getFloatDecimals(toSafeValue(value)), this.decimal || 0));
     this.#setValue(value);
@@ -101,31 +101,31 @@ export class BigIntArithmetics {
     return new this.constructor({ decimal: this.decimal, value, identifier: this.toString() });
   }
   add(...args: InitialisationValueType[]) {
-    return this.#arithmetics('add', ...args);
+    return this.#arithmetics("add", ...args);
   }
   sub(...args: InitialisationValueType[]) {
-    return this.#arithmetics('sub', ...args);
+    return this.#arithmetics("sub", ...args);
   }
   mul(...args: InitialisationValueType[]) {
-    return this.#arithmetics('mul', ...args);
+    return this.#arithmetics("mul", ...args);
   }
   div(...args: InitialisationValueType[]) {
-    return this.#arithmetics('div', ...args);
+    return this.#arithmetics("div", ...args);
   }
   gt(value: InitialisationValueType) {
-    return this.#comparison('gt', value);
+    return this.#comparison("gt", value);
   }
   gte(value: InitialisationValueType) {
-    return this.#comparison('gte', value);
+    return this.#comparison("gte", value);
   }
   lt(value: InitialisationValueType) {
-    return this.#comparison('lt', value);
+    return this.#comparison("lt", value);
   }
   lte(value: InitialisationValueType) {
-    return this.#comparison('lte', value);
+    return this.#comparison("lte", value);
   }
   eqValue(value: InitialisationValueType) {
-    return this.#comparison('eqValue', value);
+    return this.#comparison("eqValue", value);
   }
 
   // @ts-expect-error False positive
@@ -136,11 +136,11 @@ export class BigIntArithmetics {
     );
 
     switch (type) {
-      case 'number':
+      case "number":
         return Number(value) as NumberPrimitivesType[T];
-      case 'string':
+      case "string":
         return value as NumberPrimitivesType[T];
-      case 'bigint':
+      case "bigint":
         return ((this.bigIntValue * 10n ** BigInt(this.decimal || 8n)) /
           this.decimalMultiplier) as NumberPrimitivesType[T];
     }
@@ -152,43 +152,43 @@ export class BigIntArithmetics {
     const baseValue = this.bigIntValue / divisor;
 
     switch (type) {
-      case 'number':
+      case "number":
         return Number(baseValue) as NumberPrimitivesType[T];
-      case 'string':
+      case "string":
         return baseValue.toString() as NumberPrimitivesType[T];
-      case 'bigint':
+      case "bigint":
         return baseValue as NumberPrimitivesType[T];
     }
   }
 
   getBigIntValue(value: InitialisationValueType, decimal?: number) {
-    if (!decimal && typeof value === 'object') return value.bigIntValue;
+    if (!decimal && typeof value === "object") return value.bigIntValue;
 
     const stringValue = getStringValue(value);
     const safeValue = toSafeValue(stringValue);
 
-    if (safeValue === '0' || safeValue === 'undefined') return 0n;
+    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 || '';
+  toSignificant(significantDigits = 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');
+      return this.getValue("string");
     }
 
     if (integer.length >= significantDigits) {
-      return integer.slice(0, significantDigits).padEnd(integer.length, '0');
+      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',
+        "0",
       );
     }
 
@@ -197,17 +197,17 @@ export class BigIntArithmetics {
 
     return `0.${slicedDecimal.padStart(
       decimal.length - `${trimmedDecimal}`.length + slicedDecimal.length,
-      '0',
+      "0",
     )}`;
   }
 
-  toFixed(fixedDigits: number = 6) {
-    const [int, dec] = this.getValue('string').split('.');
-    const integer = int || '';
-    const decimal = dec || '';
+  toFixed(fixedDigits = 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');
+      return `${integer}.${decimal.slice(0, fixedDigits)}`.padEnd(fixedDigits, "0");
     }
 
     const trimmedDecimal = parseInt(decimal);
@@ -215,17 +215,17 @@ export class BigIntArithmetics {
 
     return `0.${slicedDecimal.padStart(
       decimal.length - `${trimmedDecimal}`.length + slicedDecimal.length,
-      '0',
+      "0",
     )}`;
   }
 
   toAbbreviation(digits = 2) {
-    const value = this.getValue('number');
-    const abbreviations = ['', 'K', 'M', 'B', 'T', 'Q', 'Qi', 'S'];
+    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');
+    if (!suffix) return this.getValue("string");
 
     const scale = 10 ** (tier * 3);
     const scaled = value / scale;
@@ -234,27 +234,27 @@ export class BigIntArithmetics {
   }
 
   toCurrency(
-    currency = '$',
+    currency = "$",
     {
-      currencyPosition = 'start',
+      currencyPosition = "start",
       decimal = 2,
-      decimalSeparator = '.',
-      thousandSeparator = ',',
+      decimalSeparator = ".",
+      thousandSeparator = ",",
     } = {},
   ) {
-    const value = this.getValue('number');
-    const [int, dec = ''] = value.toFixed(6).split('.');
+    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 : ''
+      int || dec
+        ? int === "0"
+          ? `${parseFloat(`0.${dec}`)}`.replace(".", decimalSeparator)
+          : `${integer}${parseInt(dec) ? `${decimalSeparator}${dec.slice(0, decimal)}` : ""}`
+        : "0.00";
+
+    return `${currencyPosition === "start" ? currency : ""}${parsedValue}${
+      currencyPosition === "end" ? currency : ""
     }`;
   }
 
@@ -269,7 +269,7 @@ export class BigIntArithmetics {
     const valueString = value.toString().substring(isNegative ? 1 : 0);
     const padLength = decimalToUseForConversion - (valueString.length - 1);
 
-    const parsedValueString = padLength > 0 ? '0'.repeat(padLength) + valueString : valueString;
+    const parsedValueString = padLength > 0 ? "0".repeat(padLength) + valueString : valueString;
 
     const decimalIndex = parsedValueString.length - decimalToUseForConversion;
     let decimalString = parsedValueString.slice(-decimalToUseForConversion);
@@ -285,13 +285,13 @@ export class BigIntArithmetics {
       decimalString = decimalString.substring(0, bigIntDecimal);
     }
 
-    return `${isNegative ? '-' : ''}${parsedValueString.slice(
+    return `${isNegative ? "-" : ""}${parsedValueString.slice(
       0,
       decimalIndex,
-    )}.${decimalString}`.replace(/\.?0*$/, '');
+    )}.${decimalString}`.replace(/\.?0*$/, "");
   }
 
-  #arithmetics(method: 'add' | 'sub' | 'mul' | 'div', ...args: InitialisationValueType[]): this {
+  #arithmetics(method: "add" | "sub" | "mul" | "div", ...args: InitialisationValueType[]): this {
     const precisionDecimal = this.#retrievePrecisionDecimal(this, ...args);
     const decimal = Math.max(precisionDecimal, decimalFromMultiplier(this.decimalMultiplier));
     const precisionDecimalMultiplier = toMultiplier(decimal);
@@ -301,9 +301,9 @@ export class BigIntArithmetics {
         const value = this.getBigIntValue(arg, decimal);
 
         switch (method) {
-          case 'add':
+          case "add":
             return acc + value;
-          case 'sub':
+          case "sub":
             return acc - value;
           /**
            * Multiplication & division would end up with wrong result if we don't adjust the value
@@ -313,10 +313,10 @@ export class BigIntArithmetics {
            * 200000000n * 200000000n = 40000000000000000n / 100000000n (decimals) => 400000000n
            * (200000000n * 100000000n (decimals)) / 200000000n => 100000000n
            */
-          case 'mul':
+          case "mul":
             return (acc * value) / precisionDecimalMultiplier;
-          case 'div': {
-            if (value === 0n) throw new RangeError('Division by zero');
+          case "div": {
+            if (value === 0n) throw new RangeError("Division by zero");
             return (acc * precisionDecimalMultiplier) / value;
           }
           default:
@@ -342,34 +342,34 @@ export class BigIntArithmetics {
     });
   }
 
-  #comparison(method: 'gt' | 'gte' | 'lt' | 'lte' | 'eqValue', ...args: InitialisationValueType[]) {
+  #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':
+      case "gt":
         return compareToValue > value;
-      case 'gte':
+      case "gte":
         return compareToValue >= value;
-      case 'lt':
+      case "lt":
         return compareToValue < value;
-      case 'lte':
+      case "lte":
         return compareToValue <= value;
-      case 'eqValue':
+      case "eqValue":
         return compareToValue === value;
     }
   }
 
   #setValue(value: InitialisationValueType) {
-    const safeValue = toSafeValue(value) || '0';
+    const safeValue = toSafeValue(value) || "0";
     this.bigIntValue = this.#toBigInt(safeValue);
   }
 
   #retrievePrecisionDecimal(...args: InitialisationValueType[]) {
     const decimals = args
       .map((arg) => {
-        const isObject = typeof arg === 'object';
+        const isObject = typeof arg === "object";
         const value = isObject
           ? arg.decimal || decimalFromMultiplier(arg.decimalMultiplier)
           : getFloatDecimals(toSafeValue(arg));
@@ -384,36 +384,36 @@ export class BigIntArithmetics {
   #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')}`);
+    return BigInt(`${integerPart}${decimalPart.padEnd(padDecimal, "0")}`);
   }
 }
 
-const numberFormatter = Intl.NumberFormat('fullwide', {
+const numberFormatter = Intl.NumberFormat("fullwide", {
   useGrouping: false,
   maximumFractionDigits: 20,
 });
 
 function toSafeValue(value: InitialisationValueType) {
   const parsedValue =
-    typeof value === 'number' ? numberFormatter.format(value) : getStringValue(value);
-  const splitValue = `${parsedValue}`.replaceAll(',', '.').split('.');
+    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.slice(0, -1).join("")}.${splitValue.at(-1)}`
     : splitValue[0];
 }
 
 function getFloatDecimals(value: string) {
-  const decimals = value.split('.')[1]?.length || 0;
+  const decimals = value.split(".")[1]?.length || 0;
   return Math.max(decimals, DEFAULT_DECIMAL);
 }
 
 function getStringValue(param: SKBigIntParams) {
-  return typeof param === 'object'
-    ? 'getValue' in param
-      ? param.getValue('string')
+  return typeof param === "object"
+    ? "getValue" in param
+      ? param.getValue("string")
       : param.value
     : param;
 }

package/src/modules/swapKitError.ts

@@ -31,6 +31,7 @@ const errorMessages = {
   core_swap_contract_not_supported: 10205,
   core_swap_transaction_error: 10206,
   core_swap_quote_mode_not_supported: 10207,
+  core_swap_provider_not_found: 10208,
   /**
    * Core - Transaction
    */
@@ -59,6 +60,15 @@ const errorMessages = {
   wallet_ledger_device_not_found: 20004,
   wallet_ledger_device_locked: 20005,
 
+  /**
+   * Chainflip
+   */
+  chainflip_channel_error: 30001,
+
+  /**
+   * THORChain
+   */
+
   /**
    * Helpers
    */
@@ -70,10 +80,15 @@ export type ErrorKeys = keyof typeof errorMessages;
 export class SwapKitError extends Error {
   constructor(errorKey: ErrorKeys, sourceError?: any) {
     if (sourceError) {
-      console.error(sourceError, { stack: sourceError?.stack, message: sourceError?.message });
+      console.error(sourceError, {
+        stack: sourceError?.stack,
+        message: sourceError?.message,
+      });
     }
 
-    super(errorKey, { cause: { code: errorMessages[errorKey], message: errorKey } });
+    super(errorKey, {
+      cause: { code: errorMessages[errorKey], message: errorKey },
+    });
     Object.setPrototypeOf(this, SwapKitError.prototype);
   }
 }

package/src/modules/swapKitNumber.ts

@@ -1,4 +1,4 @@
-import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
+import { BigIntArithmetics, formatBigIntToSafeValue } from "./bigIntArithmetics.ts";
 
 export type SwapKitValueType = BigIntArithmetics | string | number;