@swapkit/helpers 1.0.0-rc.11 → 1.0.0-rc.111

package/src/modules/bigIntArithmetics.ts

@@ -1,6 +1,5 @@
-import { BaseDecimal } from '@swapkit/types';
-
-import type { SwapKitNumber } from './swapKitNumber.ts';
+import { BaseDecimal } from "../types/chains.ts";
+import type { SwapKitNumber } from "./swapKitNumber.ts";
 
 type NumberPrimitivesType = {
   bigint: bigint;
@@ -11,10 +10,12 @@ 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);
-const decimalFromMultiplier = (multiplier: bigint) => Math.log10(parseFloat(multiplier.toString()));
+const decimalFromMultiplier = (multiplier: bigint) =>
+  Math.log10(Number.parseFloat(multiplier.toString()));
 
 export function formatBigIntToSafeValue({
   value,
@@ -25,38 +26,39 @@ export function formatBigIntToSafeValue({
   bigIntDecimal?: number;
   decimal?: number;
 }) {
+  if (decimal === 0) return value.toString();
   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;
+    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) {
+  if (Number.parseInt(decimalString[bigIntDecimal] || "0") >= 5) {
     // Increment the last decimal place and slice off the rest
     decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(
-      parseInt(decimalString[bigIntDecimal - 1]) + 1
+      Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1
     ).toString()}`;
   } else {
     // Just slice off the extra digits
     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) {
@@ -71,217 +73,237 @@ export class BigIntArithmetics {
     from,
     to,
   }: {
-    value: InitialisationValueType;
+    value: InstanceType<typeof SwapKitNumber>;
     from: number;
     to: number;
   }) {
-    return this.fromBigInt(
-      (new BigIntArithmetics(value).bigIntValue * toMultiplier(to)) / toMultiplier(from),
+    return BigIntArithmetics.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);
   }
 
-  /**
-   * @deprecated Use `getBaseValue('string')` instead
-   */
-  get baseValue() {
-    return this.getBaseValue('string') as string;
-  }
-  /**
-   * @deprecated Use `getBaseValue('number')` instead
-   */
-  get baseValueNumber() {
-    return this.getBaseValue('number') as number;
-  }
-  /**
-   * @deprecated Use `getBaseValue('bigint')` instead
-   */
-  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() });
   }
   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.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'>(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),
     );
 
     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;
+      case "number":
+        return Number(value) as NumberPrimitivesType[T];
+      case "string":
+        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] {
+  // @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);
-      case 'string':
-        // @ts-expect-error False positive
-        return baseValue.toString();
-      default:
-        // @ts-expect-error False positive
-        return baseValue;
+      case "number":
+        return Number(baseValue) as NumberPrimitivesType[T];
+      case "string":
+        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;
+    if (!decimal && typeof value === "object") return value.bigIntValue;
 
     const stringValue = getStringValue(value);
-    const safeValue = this.#toSafeValue(stringValue);
+    const safeValue = toSafeValue(stringValue);
 
-    if (safeValue === '0' || safeValue === 'undefined') return 0n;
+    if (safeValue === "0" || safeValue === "undefined") return 0n;
     return this.#toBigInt(safeValue, decimal);
   }
 
-  formatBigIntToSafeValue(value: bigint, decimal?: number) {
-    const bigIntDecimal = decimal || this.decimal || DEFAULT_DECIMAL;
-    const decimalToUseForConversion = Math.max(
-      bigIntDecimal,
-      decimalFromMultiplier(this.decimalMultiplier),
-    );
-    const isNegative = value < 0n;
-
-    const valueString = value.toString().substring(isNegative ? 1 : 0);
-    const padLength = decimalToUseForConversion - (valueString.length - 1);
-
-    const parsedValueString = padLength > 0 ? '0'.repeat(padLength) + valueString : valueString;
-
-    const decimalIndex = parsedValueString.length - decimalToUseForConversion;
-    let decimalString = parsedValueString.slice(-decimalToUseForConversion);
-
-    // 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 ? '-' : ''}${parsedValueString.slice(
-      0,
-      decimalIndex,
-    )}.${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;
+  toSignificant(significantDigits = 6) {
+    const [int, dec] = this.getValue("string").split(".");
+    const integer = int || "";
+    const decimal = dec || "";
+    const valueLength = Number.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)) {
+    if (Number.parseInt(integer)) {
       return `${integer}.${decimal.slice(0, significantDigits - integer.length)}`.padEnd(
-        valueLength - significantDigits,
-        '0',
+        significantDigits - integer.length,
+        "0",
       );
     }
 
-    const trimmedDecimal = parseInt(decimal);
+    const trimmedDecimal = Number.parseInt(decimal);
     const slicedDecimal = `${trimmedDecimal}`.slice(0, significantDigits);
 
     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');
+    if (Number.parseInt(integer)) {
+      return `${integer}.${decimal.slice(0, fixedDigits)}`.padEnd(fixedDigits, "0");
     }
 
-    const trimmedDecimal = parseInt(decimal);
+    const trimmedDecimal = Number.parseInt(decimal);
     const slicedDecimal = `${trimmedDecimal}`.slice(0, fixedDigits);
 
     return `0.${slicedDecimal.padStart(
       decimal.length - `${trimmedDecimal}`.length + slicedDecimal.length,
-      '0',
+      "0",
     )}`;
   }
 
-  #arithmetics(method: 'add' | 'sub' | 'mul' | 'div', ...args: InitialisationValueType[]): 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}`;
+  }
+
+  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
+        ? int === "0"
+          ? `${Number.parseFloat(`0.${dec}`)}`.replace(".", decimalSeparator)
+          : `${integer}${Number.parseInt(dec) ? `${decimalSeparator}${dec.slice(0, decimal)}` : ""}`
+        : "0.00";
+
+    return `${currencyPosition === "start" ? currency : ""}${parsedValue}${
+      currencyPosition === "end" ? currency : ""
+    }`;
+  }
+
+  formatBigIntToSafeValue(value: bigint, decimal?: number) {
+    const bigIntDecimal = decimal || this.decimal || DEFAULT_DECIMAL;
+    const decimalToUseForConversion = Math.max(
+      bigIntDecimal,
+      decimalFromMultiplier(this.decimalMultiplier),
+    );
+    const isNegative = value < 0n;
+
+    const valueString = value.toString().substring(isNegative ? 1 : 0);
+    const padLength = decimalToUseForConversion - (valueString.length - 1);
+
+    const parsedValueString = padLength > 0 ? "0".repeat(padLength) + valueString : valueString;
+
+    const decimalIndex = parsedValueString.length - decimalToUseForConversion;
+    let decimalString = parsedValueString.slice(-decimalToUseForConversion);
+
+    // Check if we need to round up
+    if (Number.parseInt(decimalString[bigIntDecimal] || "0") >= 5) {
+      // Increment the last decimal place and slice off the rest
+      decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(
+        Number.parseInt(decimalString[bigIntDecimal - 1] || "0") + 1
+      ).toString()}`;
+    } else {
+      // Just slice off the extra digits
+      decimalString = decimalString.substring(0, bigIntDecimal);
+    }
+
+    return `${isNegative ? "-" : ""}${parsedValueString.slice(
+      0,
+      decimalIndex,
+    )}.${decimalString}`.replace(/\.?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':
+          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
@@ -291,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:
@@ -306,65 +328,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] || "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')}`);
+    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] || "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;
 }

package/src/modules/requestClient.ts

@@ -0,0 +1,38 @@
+import type { KyInstance, Options } from "ky";
+import ky from "ky";
+
+let kyClient: typeof ky;
+
+export const defaultRequestHeaders =
+  typeof window !== "undefined"
+    ? ({} as Record<string, string>)
+    : { referrer: "https://sk.thorswap.net", referer: "https://sk.thorswap.net" };
+
+export function setRequestClientConfig({ apiKey, ...config }: Options & { apiKey?: string }) {
+  kyClient = ky.create({
+    ...config,
+    headers: { ...defaultRequestHeaders, ...config.headers, "x-api-key": apiKey },
+  });
+}
+
+function getKyClient() {
+  if (kyClient) return kyClient;
+  kyClient = ky.create({ headers: defaultRequestHeaders });
+  return kyClient;
+}
+
+const getTypedBaseRequestClient = (ky: KyInstance) => ({
+  get: <T>(url: string | URL | Request, options?: Options) => ky.get(url, options).json<T>(),
+  post: <T>(url: string | URL | Request, options?: Options) => ky.post(url, options).json<T>(),
+});
+
+export const RequestClient = {
+  ...getTypedBaseRequestClient(getKyClient()),
+  extend: (options: Options) => {
+    const extendedClient = getKyClient().extend(options);
+    return {
+      ...getTypedBaseRequestClient(extendedClient),
+      extend: RequestClient.extend,
+    };
+  },
+};