@swapkit/helpers 1.0.0-rc.10 → 1.0.0-rc.12

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.10",
+  "version": "1.0.0-rc.12",
   "scripts": {
     "build": "vite build",
     "clean": "rm -rf dist vite.config.ts.* .turbo node_modules",

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

@@ -77,6 +77,16 @@ describe('AssetValue', () => {
     });
   });
 
+  describe('from bigint', () => {
+    test('returns asset value with correct decimal', async () => {
+      const avaxUSDCAsset = await AssetValue.fromIdentifier(
+        `${Chain.Avalanche}.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e`,
+        1234567800n,
+      );
+      expect(avaxUSDCAsset.getValue('string')).toBe('1234.5678');
+    });
+  });
+
   describe('toString', () => {
     test('returns asset value string/identifier', async () => {
       const avaxUSDCAsset = new AssetValue({

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

@@ -153,6 +153,37 @@ describe('SwapKitNumber', () => {
     });
   });
 
+  describe('toAbbreviation', () => {
+    test('returns abbreviation with up to 3 integer digits', () => {
+      const skNumber = new SwapKitNumber(1234.5678);
+      expect(skNumber.toAbbreviation()).toBe('1.23K');
+
+      const skNumber2 = new SwapKitNumber(1234567.5678);
+      expect(skNumber2.toAbbreviation()).toBe('1.23M');
+
+      const skNumber3 = new SwapKitNumber(1234567890.5678);
+      expect(skNumber3.toAbbreviation()).toBe('1.23B');
+
+      const skNumber4 = new SwapKitNumber(1234567890123.5678);
+      expect(skNumber4.toAbbreviation()).toBe('1.23T');
+
+      const skNumber5 = new SwapKitNumber(1234567890123456.5678);
+      expect(skNumber5.toAbbreviation()).toBe('1.23Q');
+
+      const skNumber6 = new SwapKitNumber(1234567890123456789.5678);
+      expect(skNumber6.toAbbreviation()).toBe('1.23Qi');
+
+      const skNumber7 = new SwapKitNumber(1234567890123456789012.5678);
+      expect(skNumber7.toAbbreviation()).toBe('1.23S');
+
+      const skNumber8 = new SwapKitNumber(1234.5678);
+      expect(skNumber8.toAbbreviation(0)).toBe('1K');
+
+      const skNumber9 = new SwapKitNumber(1234.5678);
+      expect(skNumber9.toAbbreviation(1)).toBe('1.2K');
+    });
+  });
+
   describe('add', () => {
     test('adds same type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(10);

package/src/modules/assetValue.ts

@@ -17,9 +17,15 @@ import type { CommonAssetString } from '../helpers/asset.ts';
 import { getAssetType, getCommonAssetInfo, getDecimal, isGasAsset } from '../helpers/asset.ts';
 import { validateIdentifier } from '../helpers/validators.ts';
 
-import { BigIntArithmetics } from './bigIntArithmetics.ts';
+import type { NumberPrimitives } from './bigIntArithmetics.ts';
+import { BigIntArithmetics, formatBigIntToSafeValue } from './bigIntArithmetics.ts';
 import type { SwapKitValueType } from './swapKitNumber.ts';
 
+const safeValue = (value: NumberPrimitives, decimal: number) =>
+  typeof value === 'bigint'
+    ? formatBigIntToSafeValue({ value, bigIntDecimal: decimal, decimal })
+    : value;
+
 type AssetValueParams = { decimal: number; value: SwapKitValueType } & (
   | { chain: Chain; symbol: string }
   | { identifier: string }
@@ -51,11 +57,13 @@ const getStaticToken = (identifier: TokenNames) => {
   return tokenInfo || { decimal: BaseDecimal.THOR, identifier: '' };
 };
 
-const createAssetValue = async (assetString: string, value: number | string = 0) => {
+const createAssetValue = async (assetString: string, value: NumberPrimitives = 0) => {
   validateIdentifier(assetString);
 
   const decimal = await getDecimal(getAssetInfo(assetString));
-  return new AssetValue({ decimal, value, identifier: assetString });
+  const parsedValue = safeValue(value, decimal);
+
+  return new AssetValue({ decimal, value: parsedValue, identifier: assetString });
 };
 
 export class AssetValue extends BigIntArithmetics {
@@ -105,47 +113,51 @@ export class AssetValue extends BigIntArithmetics {
     return this.chain === chain && this.symbol === symbol;
   }
 
-  static async fromString(assetString: string, value: number | string = 0) {
+  static async fromString(assetString: string, value: NumberPrimitives = 0) {
     return createAssetValue(assetString, value);
   }
 
-  static fromStringSync(assetString: string, value: number | string = 0) {
+  static fromStringSync(assetString: string, value: NumberPrimitives = 0) {
     const { decimal, identifier: tokenIdentifier } = getStaticToken(
       assetString as unknown as TokenNames,
     );
 
+    const parsedValue = safeValue(value, decimal);
+
     return tokenIdentifier
-      ? new AssetValue({ decimal, identifier: tokenIdentifier, value })
+      ? new AssetValue({ decimal, identifier: tokenIdentifier, value: parsedValue })
       : undefined;
   }
 
   static async fromIdentifier(
     assetString: `${Chain}.${string}` | `${Chain}/${string}` | `${Chain}.${string}-${string}`,
-    value: number | string = 0,
+    value: NumberPrimitives = 0,
   ) {
     return createAssetValue(assetString, value);
   }
 
-  static fromIdentifierSync(identifier: TokenNames, value: number | string = 0) {
+  static fromIdentifierSync(identifier: TokenNames, value: NumberPrimitives = 0) {
     const { decimal, identifier: tokenIdentifier } = getStaticToken(identifier);
+    const parsedValue = safeValue(value, decimal);
 
-    return new AssetValue({ decimal, identifier: tokenIdentifier, value });
+    return new AssetValue({ decimal, identifier: tokenIdentifier, value: parsedValue });
   }
 
-  static fromChainOrSignature(assetString: CommonAssetString, value: number | string = 0) {
+  static fromChainOrSignature(assetString: CommonAssetString, value: NumberPrimitives = 0) {
     const { decimal, identifier } = getCommonAssetInfo(assetString);
+    const parsedValue = safeValue(value, decimal);
 
-    return new AssetValue({ value, decimal, identifier });
+    return new AssetValue({ value: parsedValue, decimal, identifier });
   }
 
-  static async fromTCQuote(identifier: TCTokenNames, value: number | string = 0) {
+  static async fromTCQuote(identifier: TCTokenNames, value: NumberPrimitives = 0) {
     const decimal = await getDecimal(getAssetInfo(identifier));
     const shiftedValue = this.shiftDecimals({ value, from: BaseDecimal.THOR, to: decimal });
 
     return new AssetValue({ value: shiftedValue, identifier, decimal });
   }
 
-  static fromTCQuoteStatic(identifier: TCTokenNames, value: number | string = 0) {
+  static fromTCQuoteStatic(identifier: TCTokenNames, value: NumberPrimitives = 0) {
     const tokenInfo = getStaticToken(identifier);
     const shiftedValue = this.shiftDecimals({
       value,

package/src/modules/bigIntArithmetics.ts

@@ -7,7 +7,7 @@ type NumberPrimitivesType = {
   number: number;
   string: string;
 };
-type NumberPrimitives = bigint | number | string;
+export type NumberPrimitives = bigint | number | string;
 type InitialisationValueType = NumberPrimitives | BigIntArithmetics | SwapKitNumber;
 
 type SKBigIntParams = InitialisationValueType | { decimal?: number; value: number | string };
@@ -75,7 +75,7 @@ export class BigIntArithmetics {
     from: number;
     to: number;
   }) {
-    return BigIntArithmetics.fromBigInt(
+    return this.fromBigInt(
       (new BigIntArithmetics(value).bigIntValue * toMultiplier(to)) / toMultiplier(from),
       to,
     );
@@ -270,6 +270,20 @@ export class BigIntArithmetics {
     )}`;
   }
 
+  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 value;
+
+    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);

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;
 
@@ -6,4 +6,11 @@ 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 }),
+    });
+  }
 }