@swapkit/helpers 1.0.0-rc.2 → 1.0.0-rc.21

package/src/modules/bigIntArithmetics.ts

@@ -1,11 +1,59 @@
-import { DEFAULT_DECIMAL, formatBigIntToSafeValue } from '../helpers/number.ts';
+import { BaseDecimal } from '@swapkit/types';
 
-type AllowedValueType = bigint | number | string;
-type ArithmeticMethod = 'add' | 'sub' | 'mul' | 'div';
+import type { SwapKitNumber } from './swapKitNumber.ts';
 
+type NumberPrimitivesType = {
+  bigint: bigint;
+  number: number;
+  string: string;
+};
+export type NumberPrimitives = bigint | number | string;
+type InitialisationValueType = NumberPrimitives | BigIntArithmetics | SwapKitNumber;
+
+type SKBigIntParams = InitialisationValueType | { decimal?: number; value: number | string };
+
+const DEFAULT_DECIMAL = 8;
 const toMultiplier = (decimal: number) => 10n ** BigInt(decimal);
 const decimalFromMultiplier = (multiplier: bigint) => Math.log10(parseFloat(multiplier.toString()));
 
+export function formatBigIntToSafeValue({
+  value,
+  bigIntDecimal = DEFAULT_DECIMAL,
+  decimal = DEFAULT_DECIMAL,
+}: {
+  value: bigint;
+  bigIntDecimal?: number;
+  decimal?: number;
+}) {
+  const isNegative = value < 0n;
+  let valueString = value.toString().substring(isNegative ? 1 : 0);
+
+  const padLength = decimal - (valueString.length - 1);
+
+  if (padLength > 0) {
+    valueString = '0'.repeat(padLength) + valueString;
+  }
+
+  const decimalIndex = valueString.length - decimal;
+  let decimalString = valueString.slice(-decimal);
+
+  // Check if we need to round up
+  if (parseInt(decimalString[bigIntDecimal]) >= 5) {
+    // Increment the last decimal place and slice off the rest
+    decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(
+      parseInt(decimalString[bigIntDecimal - 1]) + 1
+    ).toString()}`;
+  } else {
+    // Just slice off the extra digits
+    decimalString = decimalString.substring(0, bigIntDecimal);
+  }
+
+  return `${isNegative ? '-' : ''}${valueString.slice(0, decimalIndex)}.${decimalString}`.replace(
+    /\.?0*$/,
+    '',
+  );
+}
+
 export class BigIntArithmetics {
   decimalMultiplier: bigint = 10n ** 8n;
   bigIntValue: bigint = 0n;
@@ -23,26 +71,19 @@ export class BigIntArithmetics {
     from,
     to,
   }: {
-    value: BigIntArithmetics | string | number;
+    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(
-    valueOrParams:
-      | BigIntArithmetics
-      | string
-      | number
-      | { decimal?: number; value: number | string },
-  ) {
-    const complexInit = typeof valueOrParams === 'object';
-    const value = complexInit ? valueOrParams.value : valueOrParams;
-    this.decimal = complexInit ? valueOrParams.decimal : undefined;
+  constructor(params: SKBigIntParams) {
+    const value = getStringValue(params);
+    this.decimal = typeof params === 'object' ? params.decimal : undefined;
 
     // use the multiplier to keep track of decimal point - defaults to 8 if lower than 8
     this.decimalMultiplier = toMultiplier(
@@ -51,58 +92,101 @@ export class BigIntArithmetics {
     this.#setValue(value);
   }
 
-  get unsafeNumber() {
-    return parseFloat((this.bigIntValue / this.decimalMultiplier).toString());
-  }
+  /**
+   * @deprecated Use `getBaseValue('string')` instead
+   */
   get baseValue() {
-    return this.#getBaseValue('string') as string;
+    return this.getBaseValue('string') as string;
   }
+  /**
+   * @deprecated Use `getBaseValue('number')` instead
+   */
   get baseValueNumber() {
-    return this.#getBaseValue('number') as number;
+    return this.getBaseValue('number') as number;
   }
+  /**
+   * @deprecated Use `getBaseValue('bigint')` instead
+   */
   get baseValueBigInt() {
-    return this.#getBaseValue('number') as bigint;
-  }
-  get value() {
-    return this.formatBigIntToSafeValue(
-      this.bigIntValue,
-      this.decimal || decimalFromMultiplier(this.decimalMultiplier),
-    );
+    return this.getBaseValue('bigint') as bigint;
   }
 
-  add(...args: (BigIntArithmetics | string | number)[]) {
+  set(value: SKBigIntParams): this {
+    // @ts-expect-error False positive
+    return new this.constructor({ decimal: this.decimal, value, identifier: this.toString() });
+  }
+  add(...args: InitialisationValueType[]) {
     return this.#arithmetics('add', ...args);
   }
-  sub(...args: (BigIntArithmetics | string | number)[]) {
+  sub(...args: InitialisationValueType[]) {
     return this.#arithmetics('sub', ...args);
   }
-  mul(...args: (BigIntArithmetics | string | number)[]) {
+  mul(...args: InitialisationValueType[]) {
     return this.#arithmetics('mul', ...args);
   }
-  div(...args: (BigIntArithmetics | string | number)[]) {
+  div(...args: InitialisationValueType[]) {
     return this.#arithmetics('div', ...args);
   }
-  gt(value: BigIntArithmetics | string | number) {
+  gt(value: InitialisationValueType) {
     return this.bigIntValue > this.getBigIntValue(value);
   }
-  gte(value: BigIntArithmetics | string | number) {
+  gte(value: InitialisationValueType) {
     return this.bigIntValue >= this.getBigIntValue(value);
   }
-  lt(value: BigIntArithmetics | string | number) {
+  lt(value: InitialisationValueType) {
     return this.bigIntValue < this.getBigIntValue(value);
   }
-  lte(value: BigIntArithmetics | string | number) {
+  lte(value: InitialisationValueType) {
     return this.bigIntValue <= this.getBigIntValue(value);
   }
-  eqValue(value: BigIntArithmetics | string | number) {
+  eqValue(value: InitialisationValueType) {
     return this.bigIntValue === this.getBigIntValue(value);
   }
 
-  getBigIntValue(value: BigIntArithmetics | string | number, decimal?: number) {
+  getValue<T extends 'number' | 'string'>(type: T): NumberPrimitivesType[T] {
+    const value = this.formatBigIntToSafeValue(
+      this.bigIntValue,
+      this.decimal || decimalFromMultiplier(this.decimalMultiplier),
+    );
+
+    switch (type) {
+      case 'number':
+        // @ts-expect-error False positive
+        return Number(value);
+      case 'string':
+        // @ts-expect-error False positive
+        return value;
+      default:
+        // @ts-expect-error False positive
+        return (this.bigIntValue * BigInt(this.decimal || 8n)) / this.decimalMultiplier;
+    }
+  }
+
+  getBaseValue<T extends 'number' | 'string' | 'bigint'>(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);
+      case 'string':
+        // @ts-expect-error False positive
+        return baseValue.toString();
+      default:
+        // @ts-expect-error False positive
+        return baseValue;
+    }
+  }
+
+  getBigIntValue(value: InitialisationValueType, decimal?: number) {
     if (!decimal && typeof value === 'object') return value.bigIntValue;
 
-    value = typeof value === 'object' ? value.value : value;
-    return this.#toBigInt(this.#toSafeValue(value), decimal);
+    const stringValue = getStringValue(value);
+    const safeValue = this.#toSafeValue(stringValue);
+
+    if (safeValue === '0' || safeValue === 'undefined') return 0n;
+    return this.#toBigInt(safeValue, decimal);
   }
 
   formatBigIntToSafeValue(value: bigint, decimal?: number) {
@@ -113,16 +197,13 @@ export class BigIntArithmetics {
     );
     const isNegative = value < 0n;
 
-    let valueString = value.toString().substring(isNegative ? 1 : 0);
-
+    const valueString = value.toString().substring(isNegative ? 1 : 0);
     const padLength = decimalToUseForConversion - (valueString.length - 1);
 
-    if (padLength > 0) {
-      valueString = '0'.repeat(padLength) + valueString;
-    }
+    const parsedValueString = padLength > 0 ? '0'.repeat(padLength) + valueString : valueString;
 
-    const decimalIndex = valueString.length - decimalToUseForConversion;
-    let decimalString = valueString.slice(-decimalToUseForConversion);
+    const decimalIndex = parsedValueString.length - decimalToUseForConversion;
+    let decimalString = parsedValueString.slice(-decimalToUseForConversion);
 
     // Check if we need to round up
     if (parseInt(decimalString[bigIntDecimal]) >= 5) {
@@ -135,54 +216,104 @@ export class BigIntArithmetics {
       decimalString = decimalString.substring(0, bigIntDecimal);
     }
 
-    return `${isNegative ? '-' : ''}${valueString.slice(0, decimalIndex)}.${decimalString}`.replace(
-      /\.?0*$/,
-      '',
-    );
+    return `${isNegative ? '-' : ''}${parsedValueString.slice(
+      0,
+      decimalIndex,
+    )}.${decimalString}`.replace(/\.?0*$/, '');
   }
 
-  toSignificant(significantDigits?: number) {
-    const value = this.value.split('.');
-    const integer = value[0];
-    const decimal = value[1];
+  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 (decimal) {
-      return `${integer}.${decimal.slice(0, significantDigits || this.decimal)}`.replace(
-        /\.?0*$/,
-        '',
+    if (parseInt(integer)) {
+      return `${integer}.${decimal.slice(0, significantDigits - integer.length)}`.padEnd(
+        significantDigits - integer.length,
+        '0',
       );
     }
 
-    return integer;
+    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',
+    )}`;
   }
 
-  #arithmetics(method: ArithmeticMethod, ...args: (BigIntArithmetics | string | number)[]): this {
+  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}`;
+  }
+
+  #arithmetics(method: 'add' | 'sub' | 'mul' | 'div', ...args: InitialisationValueType[]): this {
     const precisionDecimal = this.#retrievePrecisionDecimal(this, ...args);
     const precisionDecimalMultiplier = toMultiplier(precisionDecimal);
 
     const result = args.reduce(
-      (acc, arg) => {
+      (acc: bigint, arg) => {
         const value = this.getBigIntValue(arg, precisionDecimal);
 
-        if ('div' === method && value === 0n) throw new RangeError('Division by zero');
-
-        /**
-         * Normal arithmetic - add & sub => 200000000n +- 200000000n
-         */
-        if ('add' === method) return acc + value;
-        if ('sub' === method) return acc - value;
-
-        /**
-         * Multiplication & division would end up with wrong result if we don't adjust the value
-         * 200000000n * 200000000n => 40000000000000000n
-         * 200000000n / 200000000n => 1n
-         * So we do the following:
-         * 200000000n * 200000000n = 40000000000000000n / 100000000n (decimals) => 400000000n
-         * (200000000n * 100000000n (decimals)) / 200000000n => 100000000n
-         */
-        if ('mul' === method) return (acc * value) / precisionDecimalMultiplier;
-        // 'div' === method
-        return (acc * precisionDecimalMultiplier) / value;
+        switch (method) {
+          case 'add':
+            return acc + value;
+          case 'sub':
+            return acc - value;
+          /**
+           * Multiplication & division would end up with wrong result if we don't adjust the value
+           * 200000000n * 200000000n => 40000000000000000n
+           * 200000000n / 200000000n => 1n
+           * So we do the following:
+           * 200000000n * 200000000n = 40000000000000000n / 100000000n (decimals) => 400000000n
+           * (200000000n * 100000000n (decimals)) / 200000000n => 100000000n
+           */
+          case 'mul':
+            return (acc * value) / precisionDecimalMultiplier;
+          case 'div': {
+            if (value === 0n) throw new RangeError('Division by zero');
+            return (acc * precisionDecimalMultiplier) / value;
+          }
+          default:
+            return acc;
+        }
       },
       //normalize is to precision multiplier base
       (this.bigIntValue * precisionDecimalMultiplier) / this.decimalMultiplier,
@@ -194,16 +325,16 @@ export class BigIntArithmetics {
       value: result,
     });
 
-    // @ts-expect-error - we know that the constructor is the same as the current class
+    // @ts-expect-error False positive
     return new this.constructor({ decimal: this.decimal, value, identifier: this.toString() });
   }
 
-  #setValue(value: AllowedValueType, bigIntValue?: bigint) {
+  #setValue(value: InitialisationValueType) {
     const safeValue = this.#toSafeValue(value) || '0';
-    this.bigIntValue = bigIntValue || this.#toBigInt(safeValue);
+    this.bigIntValue = this.#toBigInt(safeValue);
   }
 
-  #retrievePrecisionDecimal(...args: (BigIntArithmetics | AllowedValueType)[]) {
+  #retrievePrecisionDecimal(...args: InitialisationValueType[]) {
     const decimals = args
       .map((arg) =>
         typeof arg === 'object'
@@ -217,19 +348,19 @@ 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')}`);
   }
 
-  #toSafeValue(value: AllowedValueType) {
+  #toSafeValue(value: InitialisationValueType) {
     const parsedValue =
       typeof value === 'number'
         ? Number(value).toLocaleString('fullwide', {
             useGrouping: false,
             maximumFractionDigits: 20,
           })
-        : value;
+        : getStringValue(value);
 
     const splitValue = `${parsedValue}`.replaceAll(',', '.').split('.');
 
@@ -242,18 +373,12 @@ export class BigIntArithmetics {
     const decimals = value.split('.')[1]?.length || 0;
     return Math.max(decimals, DEFAULT_DECIMAL);
   }
+}
 
-  #getBaseValue<T extends 'number' | 'string' | 'bigint'>(type: T) {
-    const divisor = this.decimalMultiplier / toMultiplier(this.decimal || 0);
-    const baseValue = this.bigIntValue / divisor;
-
-    switch (type) {
-      case 'number':
-        return Number(baseValue);
-      case 'string':
-        return baseValue.toString();
-      default:
-        return baseValue;
-    }
-  }
+function getStringValue(value: SKBigIntParams) {
+  return typeof value === 'object'
+    ? 'getValue' in value
+      ? value.getValue('string')
+      : value.value
+    : value;
 }

package/src/modules/swapKitNumber.ts

@@ -1,4 +1,4 @@
-import { BigIntArithmetics } from './bigIntArithmetics.ts';
+import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
 
 export type SwapKitValueType = BigIntArithmetics | string | number;
 
@@ -7,7 +7,10 @@ export class SwapKitNumber extends BigIntArithmetics {
     return this.eqValue(value);
   }
 
-  toString() {
-    return this.value;
+  static fromBigInt(value: bigint, decimal?: number) {
+    return new SwapKitNumber({
+      decimal,
+      value: formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal }),
+    });
   }
 }

package/src/helpers/number.ts

@@ -1,40 +0,0 @@
-// THORChain base amount is 1e8
-export const DEFAULT_DECIMAL = 8;
-
-export const formatBigIntToSafeValue = ({
-  value,
-  bigIntDecimal = DEFAULT_DECIMAL,
-  decimal = DEFAULT_DECIMAL,
-}: {
-  value: bigint;
-  bigIntDecimal?: number;
-  decimal?: number;
-}) => {
-  const isNegative = value < 0n;
-  let valueString = value.toString().substring(isNegative ? 1 : 0);
-
-  const padLength = decimal - (valueString.length - 1);
-
-  if (padLength > 0) {
-    valueString = '0'.repeat(padLength) + valueString;
-  }
-
-  const decimalIndex = valueString.length - decimal;
-  let decimalString = valueString.slice(-decimal);
-
-  // Check if we need to round up
-  if (parseInt(decimalString[bigIntDecimal]) >= 5) {
-    // Increment the last decimal place and slice off the rest
-    decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(
-      parseInt(decimalString[bigIntDecimal - 1]) + 1
-    ).toString()}`;
-  } else {
-    // Just slice off the extra digits
-    decimalString = decimalString.substring(0, bigIntDecimal);
-  }
-
-  return `${isNegative ? '-' : ''}${valueString.slice(0, decimalIndex)}.${decimalString}`.replace(
-    /\.?0*$/,
-    '',
-  );
-};