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

package/package.json

@@ -42,7 +42,7 @@
   "repository": "https://github.com/thorswap/SwapKit.git",
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.0-rc.36",
+  "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

@@ -455,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', () => {
@@ -500,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

@@ -112,19 +112,19 @@ 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);
   }
 
   // @ts-expect-error False positive
@@ -341,6 +341,25 @@ export class BigIntArithmetics {
     });
   }
 
+  #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) {
     const safeValue = toSafeValue(value) || '0';
     this.bigIntValue = this.#toBigInt(safeValue);