@pioneer-platform/helpers 0.0.0-development.114 → 0.0.1

package/src/modules/bigIntArithmetics.ts

@@ -0,0 +1,416 @@
+import { BaseDecimal } from '@coinmasters/types';
+import type { SwapKitNumber } from './swapKitNumber';
+
+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 };
+type AllowedNumberTypes = 'bigint' | 'number' | 'string';
+
+const DEFAULT_DECIMAL = 8;
+
+const bigintPow = (base: bigint, exponent: number): bigint => {
+  let result = BigInt(1);
+  while (exponent > 0) {
+    if (exponent % 2 === 1) {
+      result *= base;
+    }
+    base *= base;
+    exponent = Math.floor(exponent / 2);
+  }
+  return result;
+};
+
+const toMultiplier = (decimal: number): bigint => {
+  console.log('toMultiplier input decimal:', decimal);
+  try {
+    const result = bigintPow(BigInt(10), decimal);
+    console.log('toMultiplier result:', result);
+    return result;
+  } catch (error) {
+    console.error('Error in toMultiplier:', error);
+    return BigInt(10);
+  }
+};
+
+const decimalFromMultiplier = (multiplier: bigint): number => Math.log10(Number(multiplier));
+
+export function formatBigIntToSafeValue({
+                                          value,
+                                          bigIntDecimal = DEFAULT_DECIMAL,
+                                          decimal = DEFAULT_DECIMAL,
+                                        }: {
+  value: bigint;
+  bigIntDecimal?: number;
+  decimal?: number;
+}): string {
+  const isNegative = value < BigInt(0);
+  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);
+
+  if (parseInt(decimalString[bigIntDecimal]) >= 5) {
+    decimalString = `${decimalString.substring(0, bigIntDecimal - 1)}${(
+        parseInt(decimalString[bigIntDecimal - 1]) + 1
+    ).toString()}`;
+  } else {
+    decimalString = decimalString.substring(0, bigIntDecimal);
+  }
+
+  return `${isNegative ? '-' : ''}${valueString.slice(0, decimalIndex)}.${decimalString}`.replace(
+      /\.?0*$/,
+      '',
+  );
+}
+
+export class BigIntArithmetics {
+  private decimalMultiplier: bigint = bigintPow(BigInt(10), 8);
+  private bigIntValue: bigint = BigInt(0);
+  private decimal?: number;
+
+  static fromBigInt(value: bigint, decimal?: number): BigIntArithmetics {
+    return new BigIntArithmetics({
+      decimal,
+      value: formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal }),
+    });
+  }
+
+  static shiftDecimals({
+                         value,
+                         from,
+                         to,
+                       }: {
+    value: InstanceType<typeof SwapKitNumber>;
+    from: number;
+    to: number;
+  }): BigIntArithmetics {
+    return this.fromBigInt(
+        (value.getBaseValue('bigint') * toMultiplier(to)) / toMultiplier(from),
+        to,
+    );
+  }
+
+  constructor(params: SKBigIntParams) {
+    console.log('Constructor Params:', params);
+    const value = getStringValue(params);
+    console.log('String Value:', value);
+    const isComplex = typeof params === 'object' && params !== null;
+    this.decimal = isComplex ? (params as { decimal?: number }).decimal : undefined;
+    console.log('Decimal:', this.decimal);
+
+    if (isComplex && 'decimalMultiplier' in (params as any)) {
+      this.decimalMultiplier = (params as any).decimalMultiplier;
+    } else {
+      const maxDecimals = Math.max(getFloatDecimals(toSafeValue(value)), this.decimal || 0);
+      this.decimalMultiplier = toMultiplier(maxDecimals);
+    }
+    console.log('Decimal Multiplier:', this.decimalMultiplier);
+
+    this.setValue(value);
+    console.log('BigInt Value:', this.bigIntValue);
+  }
+
+  set(value: SKBigIntParams): this {
+    // @ts-ignore
+    return new BigIntArithmetics({ decimal: this.decimal, value }) as this;
+  }
+
+  add(...args: InitialisationValueType[]): this {
+    return this.arithmetics('add', ...args);
+  }
+
+  sub(...args: InitialisationValueType[]): this {
+    return this.arithmetics('sub', ...args);
+  }
+
+  mul(...args: InitialisationValueType[]): this {
+    return this.arithmetics('mul', ...args);
+  }
+
+  div(...args: InitialisationValueType[]): this {
+    return this.arithmetics('div', ...args);
+  }
+
+  gt(value: InitialisationValueType): boolean {
+    return this.comparison('gt', value);
+  }
+
+  gte(value: InitialisationValueType): boolean {
+    return this.comparison('gte', value);
+  }
+
+  lt(value: InitialisationValueType): boolean {
+    return this.comparison('lt', value);
+  }
+
+  lte(value: InitialisationValueType): boolean {
+    return this.comparison('lte', value);
+  }
+
+  eqValue(value: InitialisationValueType): boolean {
+    return this.comparison('eqValue', value);
+  }
+
+  // @ts-ignore
+  getValue<T extends AllowedNumberTypes>(type: T): NumberPrimitivesType[T] {
+    const value = formatBigIntToSafeValue({
+      value: this.bigIntValue,
+      bigIntDecimal: this.decimal || decimalFromMultiplier(this.decimalMultiplier),
+    });
+
+    switch (type) {
+      case 'number':
+        return Number(value) as NumberPrimitivesType[T];
+      case 'string':
+        return value as NumberPrimitivesType[T];
+      case 'bigint':
+        return ((this.bigIntValue * bigintPow(BigInt(10), this.decimal || 8)) /
+            this.decimalMultiplier) as NumberPrimitivesType[T];
+    }
+  }
+
+  // @ts-ignore
+  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':
+        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): bigint {
+    if (!decimal && typeof value === 'object' && value !== null) {
+      return (value as BigIntArithmetics).bigIntValue;
+    }
+
+    const stringValue = getStringValue(value);
+    const safeValue = toSafeValue(stringValue);
+
+    if (safeValue === '0' || safeValue === 'undefined') return BigInt(0);
+    return this.toBigInt(safeValue, decimal);
+  }
+
+  toSignificant(significantDigits: number = 6): string {
+    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): string {
+    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): string {
+    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 = ',',
+      } = {},
+  ): string {
+    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 : ''
+    }`;
+  }
+
+  private 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);
+
+    const result = args.reduce(
+        (acc: bigint, arg) => {
+          const value = this.getBigIntValue(arg, decimal);
+
+          switch (method) {
+            case 'add':
+              return acc + value;
+            case 'sub':
+              return acc - value;
+            case 'mul':
+              return (acc * value) / precisionDecimalMultiplier;
+            case 'div': {
+              if (value === BigInt(0)) throw new RangeError('Division by zero');
+              return (acc * precisionDecimalMultiplier) / value;
+            }
+            default:
+              return acc;
+          }
+        },
+        (this.bigIntValue * precisionDecimalMultiplier) / this.decimalMultiplier,
+    );
+
+    const formattedValue = formatBigIntToSafeValue({
+      bigIntDecimal: decimal,
+      decimal,
+      value: result,
+    });
+
+    return new BigIntArithmetics({
+      decimalMultiplier: toMultiplier(decimal),
+      decimal: this.decimal,
+      value: formattedValue,
+    }) as this;
+  }
+
+  private comparison(method: 'gt' | 'gte' | 'lt' | 'lte' | 'eqValue', ...args: InitialisationValueType[]): boolean {
+    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;
+    }
+  }
+
+  private setValue(value: InitialisationValueType): void {
+    const safeValue = toSafeValue(value) || '0';
+    this.bigIntValue = this.toBigInt(safeValue);
+  }
+
+  private retrievePrecisionDecimal(...args: InitialisationValueType[]): number {
+    const decimals = args
+        .map((arg) => {
+          const isObject = typeof arg === 'object' && arg !== null;
+          const value = isObject
+              ? (arg as any).decimal || decimalFromMultiplier((arg as any).decimalMultiplier)
+              : getFloatDecimals(toSafeValue(arg));
+
+          return value;
+        })
+        .filter(Boolean) as number[];
+
+    return Math.max(...decimals, DEFAULT_DECIMAL);
+  }
+
+  private toBigInt(value: string, decimal?: number): bigint {
+    const multiplier = decimal ? toMultiplier(decimal) : this.decimalMultiplier;
+    const padDecimal = decimalFromMultiplier(multiplier);
+    const [integerPart = '', decimalPart = ''] = value.split('.');
+
+    return BigInt(`${integerPart}${decimalPart.padEnd(padDecimal, '0')}`);
+  }
+}
+
+const numberFormatter = Intl.NumberFormat('fullwide', {
+  useGrouping: false,
+  maximumFractionDigits: 20,
+});
+
+function toSafeValue(value: InitialisationValueType): string {
+  const parsedValue =
+      typeof value === 'number' ? numberFormatter.format(value) : getStringValue(value);
+  const splitValue = `${parsedValue}`.replace(/,/g, '.').split('.');
+
+  return splitValue.length > 1
+      ? `${splitValue.slice(0, -1).join('')}.${splitValue.at(-1)}`
+      : splitValue[0];
+}
+
+function getFloatDecimals(value: string): number {
+  let decimals = 0;
+  const parts = value.split('.');
+  if (parts.length > 1 && parts[1].length > 0) {
+    decimals = parts[1].length;
+  }
+  return Math.max(decimals, DEFAULT_DECIMAL);
+}
+
+function getStringValue(param: SKBigIntParams): string {
+  return typeof param === 'object' && param !== null
+      ? 'getValue' in param
+          ? (param as SwapKitNumber).getValue('string')
+          : (param as any).value
+      : (param as string);
+}

package/src/{exceptions/SwapKitError.ts → modules/swapKitError.ts}

@@ -19,6 +19,7 @@ const errorMessages = {
   core_wallet_trezor_not_installed: 10106,
   core_wallet_keplr_not_installed: 10107,
   core_wallet_okx_not_installed: 10108,
+  core_wallet_keepkey_not_installed: 10109,
   /**
    * Core - Swap
    */
@@ -28,7 +29,6 @@ const errorMessages = {
   core_swap_contract_not_found: 10203,
   core_swap_route_transaction_not_found: 10204,
   core_swap_contract_not_supported: 10205,
-  core_swap_transaction_error: 10206,
   core_swap_quote_mode_not_supported: 10207,
   /**
    * Core - Transaction
@@ -43,19 +43,30 @@ const errorMessages = {
   core_transaction_add_liquidity_asset_error: 10308,
   core_transaction_withdraw_error: 10309,
   core_transaction_deposit_to_pool_error: 10310,
+  core_transaction_deposit_insufficient_funds_error: 10311,
+  core_transaction_deposit_gas_error: 10312,
+  core_transaction_invalid_sender_address: 10313,
+  core_transaction_deposit_server_error: 10314,
 
+  core_swap_transaction_error: 10400,
   /**
    * Wallets
    */
-  wallet_ledger_connection_error: 2001,
+  wallet_ledger_connection_error: 20001,
+
+  /**
+   * Helpers
+   */
+  helpers_number_different_decimals: 99101,
 } as const;
 
-type Keys = keyof typeof errorMessages;
+export type Keys = keyof typeof errorMessages;
 
 export class SwapKitError extends Error {
   constructor(errorKey: Keys, sourceError?: any) {
-    console.error(sourceError);
+    console.error(sourceError, { stack: sourceError?.stack, message: sourceError?.message });
 
+    // @ts-ignore
     super(errorKey, { cause: { code: errorMessages[errorKey], message: errorKey } });
     Object.setPrototypeOf(this, SwapKitError.prototype);
   }

package/src/modules/swapKitNumber.ts

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

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "lib": ["es6", "es2015", "dom"],
+    "declaration": true,
+    "outDir": "lib",
+    "rootDir": "src",
+    "strict": true,
+    "types": ["node"],
+    "esModuleInterop": true
+  }
+}

package/src/__tests__/asset.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { assetFromString, assetToString } from '../asset.ts';
-import { Chain } from '@pioneer-platform/types';
-
-describe('assetToString', () => {
-  it('should return the correct string representation of an asset', () => {
-    const asset = { chain: Chain.Ethereum, symbol: 'USDT' };
-    expect(assetToString(asset)).toBe('ETH.USDT');
-
-    const synthAsset = { chain: Chain.THORChain, symbol: 'BNB/BNB' };
-    expect(assetToString(synthAsset)).toBe('THOR.BNB/BNB');
-  });
-});
-
-describe('assetFromString', () => {
-  it('should return the correct asset object from a string', () => {
-    const assetString = 'ETH.USDT';
-    const expectedAsset = { chain: Chain.Ethereum, symbol: 'USDT', ticker: 'USDT', synth: false };
-    expect(assetFromString(assetString)).toEqual(expectedAsset);
-  });
-
-  it('should return the correct asset object from a synth string', () => {
-    const assetString = 'THOR.BNB/BNB';
-    const expectedAsset = { chain: Chain.THORChain, symbol: 'BNB/BNB', ticker: 'BNB/BNB', synth: true };
-    expect(assetFromString(assetString)).toEqual(expectedAsset);
-  });
-
-  it('should return the correct asset object from a string with a hyphen', () => {
-    const assetString = 'ETH.USDT-0XA3910454BF2CB59B8B3A401589A3BACC5CA42306';
-    const expectedAsset = { chain: Chain.Ethereum, symbol: 'USDT-0XA3910454BF2CB59B8B3A401589A3BACC5CA42306', ticker: 'USDT', synth: false };
-    expect(assetFromString(assetString)).toEqual(expectedAsset);
-  });
-});

package/src/__tests__/derivationPath.test.ts

@@ -1,16 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { derivationPathToString } from '../derivationPath.ts';
-
-describe('derivationPathToString', () => {
-  it('should return the correct string for a full path', () => {
-    const path = [1, 2, 3, 4, 5];
-    const result = derivationPathToString(path);
-    expect(result).toEqual("1'/2'/3'/4/5");
-  });
-
-  it('should return the correct string for a short path', () => {
-    const path = [1, 2, 3, 4];
-    const result = derivationPathToString(path);
-    expect(result).toEqual("1'/2'/3'/4");
-  });
-});

package/src/amount.ts

@@ -1,29 +0,0 @@
-import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
-import type { AmountWithBaseDenom } from '@pioneer-platform/types';
-
-type Value = BigNumberish | AmountWithBaseDenom;
-
-const isBigNumberValue = (v: unknown): v is BigNumberish =>
-  typeof v === 'string' || typeof v === 'number' || v instanceof BigNumber;
-
-export const baseAmount = (value?: BigNumberish, decimal: number = 8): AmountWithBaseDenom => {
-  const amount = BigNumber.from(value || 0);
-
-  return {
-    amount: () => amount,
-    plus: (v: Value, d: number = decimal) =>
-      baseAmount(amount.add(isBigNumberValue(v) ? v : (v as AmountWithBaseDenom).amount()), d),
-    minus: (v: Value, d: number = decimal) =>
-      baseAmount(amount.sub(isBigNumberValue(v) ? v : (v as AmountWithBaseDenom).amount()), d),
-    times: (v: Value, d: number = decimal) =>
-      baseAmount(amount.mul(isBigNumberValue(v) ? v : (v as AmountWithBaseDenom).amount()), d),
-    div: (v: Value, d: number = decimal) =>
-      baseAmount(amount.div(isBigNumberValue(v) ? v : (v as AmountWithBaseDenom).amount()), d),
-    lt: (v: Value) => amount.lt(isBigNumberValue(v) ? v : (v as AmountWithBaseDenom).amount()),
-    lte: (v: Value) => amount.lte(isBigNumberValue(v) ? v : (v as AmountWithBaseDenom).amount()),
-    gt: (v: Value) => amount.gt(isBigNumberValue(v) ? v : (v as AmountWithBaseDenom).amount()),
-    gte: (v: Value) => amount.gte(isBigNumberValue(v) ? v : (v as AmountWithBaseDenom).amount()),
-    eq: (v: Value) => amount.eq(isBigNumberValue(v) ? v : (v as AmountWithBaseDenom).amount()),
-    decimal,
-  };
-};

package/src/asset.ts

@@ -1,13 +0,0 @@
-import { Chain } from '@pioneer-platform/types';
-
-export const assetToString = ({ chain, symbol }: { chain: Chain; symbol: string }) =>
-  `${chain}.${symbol}`;
-
-export const assetFromString = (assetString: string) => {
-  const [chain, ...symbolArray] = assetString.split('.') as [Chain, ...(string | undefined)[]];
-  const synth = assetString.includes('/');
-  const symbol = symbolArray.join('.');
-  const ticker = symbol?.split('-')?.[0];
-
-  return { chain, symbol, ticker, synth };
-};

package/src/derivationPath.ts

@@ -1,5 +0,0 @@
-export const derivationPathToString = ([network, chainId, account, change, index]: number[]) => {
-  const shortPath = typeof index !== 'number';
-
-  return `${network}'/${chainId}'/${account}'/${change}${shortPath ? '' : `/${index}`}`;
-};

package/src/exceptions/index.ts

@@ -1 +0,0 @@
-export * from './SwapKitError.ts';

package/src/fees.ts

@@ -1,13 +0,0 @@
-import { type AmountWithBaseDenom, FeeOption } from '@pioneer-platform/types';
-
-export const singleFee = (fee: AmountWithBaseDenom): Record<FeeOption, AmountWithBaseDenom> => ({
-  [FeeOption.Average]: fee,
-  [FeeOption.Fast]: fee,
-  [FeeOption.Fastest]: fee,
-});
-
-export const gasFeeMultiplier: Record<FeeOption, number> = {
-  [FeeOption.Average]: 1.2,
-  [FeeOption.Fast]: 1.5,
-  [FeeOption.Fastest]: 2,
-};

package/src/request.ts

@@ -1,34 +0,0 @@
-export const getRequest = async <T>(
-  url: string,
-  params?: { [key in string]?: any },
-): Promise<T> => {
-  const queryParams = Object.entries(params || {}).reduce((acc, [key, value]) => {
-    if (value) {
-      acc[key] = value;
-    }
-
-    return acc;
-  }, {} as { [key in string]: any });
-
-  const response = await fetch(
-    `${url}${params ? `?${new URLSearchParams(queryParams).toString()}` : ''}`,
-    { method: 'GET', mode: 'cors', credentials: 'omit' },
-  );
-
-  return response.json();
-};
-
-export const postRequest = async <T>(
-  url: string,
-  data: string,
-  headers?: Record<string, string>,
-  parseAsString = false,
-): Promise<T> => {
-  const response = await fetch(`${url}`, {
-    method: 'POST',
-    headers,
-    body: data,
-  });
-
-  return parseAsString ? response.text() : response.json();
-};