@swapkit/helpers 1.0.0-rc.35 → 1.0.0-rc.37

package/package.json

@@ -8,16 +8,16 @@
     "@vitest/coverage-istanbul": "0.34.6",
     "vite": "4.5.0",
     "vitest": "0.34.6",
-    "@internal/config": "0.0.0-rc.2",
-    "@swapkit/tokens": "1.0.0-rc.17",
-    "@swapkit/types": "1.0.0-rc.16"
+    "@internal/config": "0.0.0-rc.3",
+    "@swapkit/tokens": "1.0.0-rc.18",
+    "@swapkit/types": "1.0.0-rc.17"
   },
   "eslintConfig": {
     "extends": "../../../internal/eslint-config"
   },
   "peerDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.17",
-    "@swapkit/types": "1.0.0-rc.16"
+    "@swapkit/tokens": "1.0.0-rc.18",
+    "@swapkit/types": "1.0.0-rc.17"
   },
   "exports": {
     ".": {
@@ -42,7 +42,7 @@
   "repository": "https://github.com/thorswap/SwapKit.git",
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.0-rc.35",
+  "version": "1.0.0-rc.37",
   "scripts": {
     "build": "vite build",
     "clean": "rm -rf dist vite.config.ts.* .turbo node_modules",

package/src/modules/__tests__/swapKitNumber.test.ts

@@ -328,7 +328,6 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.mul(skNumber2);
 
       // The exact result of 1.23 * 4.56 is 5.6088
-      // If we round it to 2 decimal places, we should get 5.61
       expect(result.getValue('string')).toBe('5.609');
       expect(result.getBaseValue('bigint')).toBe(5608n);
 
@@ -428,6 +427,26 @@ describe('SwapKitNumber', () => {
     });
   });
 
+  describe('extending multiplier without loosing precision', () => {
+    test('edge case 1', () => {
+      const asset1 = new SwapKitNumber({ value: 41.90963702, decimal: 8 });
+      const multiplier = 5.337952274462478;
+      const divider = 105.2562773915526;
+      const result = asset1.mul(multiplier).div(divider);
+
+      expect(result.getValue('string')).toBe('2.12539953');
+    });
+
+    test('edge case 2', () => {
+      const asset1 = new SwapKitNumber('41.90963702');
+      const multiplier = new SwapKitNumber('5.337952274462478');
+      const divider = new SwapKitNumber('105.2562773915526');
+      const result = asset1.mul(multiplier).div(divider);
+
+      expect(result.getValue('string')).toBe('2.125399527674726');
+    });
+  });
+
   describe('gt', () => {
     test('greater than', () => {
       const skNumber1 = new SwapKitNumber(10);
@@ -436,6 +455,14 @@ describe('SwapKitNumber', () => {
       expect(skNumber1.gt(skNumber2)).toBe(true);
       expect(skNumber2.gt(skNumber1)).toBe(false);
     });
+
+    test("different decimals doesn't affect comparison", () => {
+      const skNumber1 = new SwapKitNumber({ value: 10, decimal: 18 });
+      const skNumber2 = new SwapKitNumber({ value: '50', decimal: 8 });
+
+      expect(skNumber1.lt(skNumber2)).toBe(true);
+      expect(skNumber2.gt(skNumber1)).toBe(true);
+    });
   });
 
   describe('gte', () => {
@@ -481,6 +508,19 @@ describe('SwapKitNumber', () => {
     });
   });
 
+  describe('comparison edge cases with decimals', () => {
+    test('compare on cut decimals', () => {
+      const skNumber1 = new SwapKitNumber({ value: 0.001, decimal: 3 });
+      const value = '0.0019';
+
+      expect(skNumber1.lt(value)).toBe(true);
+      expect(skNumber1.gt(value)).toBe(false);
+      expect(skNumber1.eq(value)).toBe(false);
+      expect(skNumber1.lte(value)).toBe(true);
+      expect(skNumber1.gte(value)).toBe(false);
+    });
+  });
+
   describe('Throws', () => {
     test('throws if division by zero', () => {
       const skNumber1 = new SwapKitNumber(10);

package/src/modules/assetValue.ts

@@ -21,12 +21,14 @@ import type { NumberPrimitives } from './bigIntArithmetics.ts';
 import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
 import type { SwapKitValueType } from './swapKitNumber.ts';
 
+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 } & (
+type AssetValueParams = { decimal: number; value: SwapKitValueType; tax?: TokenTax } & (
   | { chain: Chain; symbol: string }
   | { identifier: string }
 );
@@ -46,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) {
@@ -67,6 +71,15 @@ const createAssetValue = async (assetString: string, value: NumberPrimitives = 0
 };
 
 export class AssetValue extends BigIntArithmetics {
+  address?: string;
+  chain: Chain;
+  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}`;
@@ -78,6 +91,7 @@ export class AssetValue extends BigIntArithmetics {
     );
 
     const assetInfo = getAssetInfo(identifier);
+
     this.type = getAssetType(assetInfo);
     this.chain = assetInfo.chain;
     this.ticker = assetInfo.ticker;
@@ -85,15 +99,9 @@ export class AssetValue extends BigIntArithmetics {
     this.address = assetInfo.address;
     this.isSynthetic = assetInfo.isSynthetic;
     this.isGasAsset = assetInfo.isGasAsset;
-  }
 
-  address?: string;
-  isSynthetic = false;
-  isGasAsset = false;
-  chain: Chain;
-  symbol: string;
-  ticker: string;
-  type: ReturnType<typeof getAssetType>;
+    this.tax = params.tax;
+  }
 
   toString(short = false) {
     // THOR.RUNE | ETH/ETH
@@ -115,16 +123,18 @@ export class AssetValue extends BigIntArithmetics {
 
   static fromStringSync(assetString: string, value: NumberPrimitives = 0) {
     const { isSynthetic } = getAssetInfo(assetString);
-    const { decimal, identifier: tokenIdentifier } = getStaticToken(
-      assetString as unknown as TokenNames,
-    );
+    const {
+      tax,
+      decimal,
+      identifier: tokenIdentifier,
+    } = getStaticToken(assetString as unknown as TokenNames);
 
     const parsedValue = safeValue(value, decimal);
 
     const asset = tokenIdentifier
-      ? new AssetValue({ decimal, identifier: tokenIdentifier, value: parsedValue })
+      ? new AssetValue({ tax, decimal, identifier: tokenIdentifier, value: parsedValue })
       : isSynthetic
-        ? new AssetValue({ decimal: 8, identifier: assetString, value: parsedValue })
+        ? new AssetValue({ tax, decimal: 8, identifier: assetString, value: parsedValue })
         : undefined;
 
     return asset;
@@ -234,6 +244,6 @@ const getAssetInfo = (identifier: string) => {
     symbol:
       (isSynthetic ? `${synthChain}/` : '') +
       (address ? `${ticker}-${address?.toLowerCase() ?? ''}` : symbol),
-    ticker: ticker,
+    ticker,
   };
 };

package/src/modules/bigIntArithmetics.ts

@@ -11,6 +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';
 
 const DEFAULT_DECIMAL = 8;
 const toMultiplier = (decimal: number) => 10n ** BigInt(decimal);
@@ -83,12 +84,14 @@ export class BigIntArithmetics {
 
   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(getFloatDecimals(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);
   }
 
@@ -109,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'>(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),
@@ -132,31 +136,27 @@ 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 * BigInt(this.decimal || 8n)) / this.decimalMultiplier;
+        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);
+        return Number(baseValue) as NumberPrimitivesType[T];
       case 'string':
-        // @ts-expect-error False positive
-        return baseValue.toString();
-      default:
-        // @ts-expect-error False positive
-        return baseValue;
+        return baseValue.toString() as NumberPrimitivesType[T];
+      case 'bigint':
+        return baseValue as NumberPrimitivesType[T];
     }
   }
 
@@ -170,39 +170,6 @@ export class BigIntArithmetics {
     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 || '';
@@ -290,13 +257,47 @@ export class BigIntArithmetics {
     }`;
   }
 
+  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*$/, '');
+  }
+
   #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':
@@ -326,13 +327,37 @@ 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) {
@@ -342,12 +367,16 @@ export class BigIntArithmetics {
 
   #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)
-          : getFloatDecimals(toSafeValue(arg)),
-      )
+          : getFloatDecimals(toSafeValue(arg));
+
+        return value;
+      })
       .filter(Boolean) as number[];
+
     return Math.max(...decimals, DEFAULT_DECIMAL);
   }