@swapkit/helpers 1.0.0-rc.2 → 1.0.0-rc.4

package/package.json

@@ -6,15 +6,15 @@
     "vite": "4.4.9",
     "vitest": "0.34.4",
     "@internal/config": "0.0.0-internal.0",
-    "@swapkit/tokens": "1.0.0-rc.1",
-    "@swapkit/types": "1.0.0-rc.1"
+    "@swapkit/tokens": "1.0.0-rc.3",
+    "@swapkit/types": "1.0.0-rc.3"
   },
   "eslintConfig": {
     "extends": "../../../internal/eslint-config"
   },
   "peerDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.1",
-    "@swapkit/types": "1.0.0-rc.1"
+    "@swapkit/tokens": "1.0.0-rc.3",
+    "@swapkit/types": "1.0.0-rc.3"
   },
   "exports": {
     ".": {
@@ -39,7 +39,7 @@
   "repository": "https://github.com/thorswap/SwapKit.git",
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.4",
   "scripts": {
     "build": "vite build",
     "clean": "rm -rf dist vite.config.ts.* .turbo node_modules",

package/src/helpers/others.ts

@@ -23,23 +23,28 @@ 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', referrer: 'https://sk.thorswap.net' },
-  );
-
-  return response.json();
+  try {
+    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', referrer: 'https://sk.thorswap.net' },
+    );
+
+    return response.json();
+  } catch (error) {
+    console.error(error);
+    return {} as T;
+  }
 };
 
 export const postRequest = async <T>(
@@ -48,12 +53,16 @@ export const postRequest = async <T>(
   headers?: Record<string, string>,
   parseAsString = false,
 ): Promise<T> => {
-  const response = await fetch(`${url}`, {
-    body,
-    headers,
-    method: 'POST',
-    referrer: 'https://sk.thorswap.net',
-  });
-
-  return parseAsString ? response.text() : response.json();
+  try {
+    const response = await fetch(`${url}`, {
+      body,
+      headers,
+      method: 'POST',
+      referrer: 'https://sk.thorswap.net',
+    });
+
+    return parseAsString ? response.text() : response.json();
+  } catch (error) {
+    return {} as T;
+  }
 };

package/src/index.ts

@@ -4,12 +4,12 @@
 export * from './helpers/asset.ts';
 export * from './helpers/liquidity.ts';
 export * from './helpers/memo.ts';
-export * from './helpers/number.ts';
 export * from './helpers/others.ts';
 
 /**
  * Modules
  */
-export { AssetValue, getMinAmountByChain } from './modules/assetValue.ts';
-export { type Keys, SwapKitError } from './modules/swapKitError.ts';
-export { SwapKitNumber } from './modules/swapKitNumber.ts';
+export * from './modules/assetValue.ts';
+export * from './modules/bigIntArithmetics.ts';
+export * from './modules/swapKitError.ts';
+export * from './modules/swapKitNumber.ts';

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

@@ -6,47 +6,47 @@ describe('SwapKitNumber', () => {
   describe('constructors', () => {
     test('creates numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(1);
-      expect(skNumber1.value).toBe('1');
-      expect(skNumber1.bigIntValue).toBe(100000000n);
+      expect(skNumber1.getValue('string')).toBe('1');
+      expect(skNumber1.getValue('number')).toBe(1);
+      expect(skNumber1.getValue('bigint')).toBe(100000000n);
 
       const skNumber2 = new SwapKitNumber('1');
-      expect(skNumber2.value).toBe('1');
-      expect(skNumber2.bigIntValue).toBe(100000000n);
+      expect(skNumber2.getValue('string')).toBe('1');
+      expect(skNumber2.getValue('bigint')).toBe(100000000n);
 
       const skNumber3 = new SwapKitNumber('0.0000000001');
-      expect(skNumber3.value).toBe('0.0000000001');
-      expect(skNumber3.bigIntValue).toBe(1n);
+      expect(skNumber3.getValue('string')).toBe('0.0000000001');
+      expect(skNumber3.getValue('bigint')).toBe(1n);
 
       const skNumber4 = new SwapKitNumber(0.000000001);
-      expect(skNumber4.value).toBe('0.000000001');
-      expect(skNumber4.bigIntValue).toBe(1n);
+      expect(skNumber4.getValue('string')).toBe('0.000000001');
+      expect(skNumber4.getValue('bigint')).toBe(1n);
 
       const skNumber6 = new SwapKitNumber({ value: 0.1005, decimal: 3 });
-      expect(skNumber6.value).toBe('0.101');
-      expect(skNumber6.bigIntValue).toBe(10050000n);
+      expect(skNumber6.getValue('string')).toBe('0.101');
+      expect(skNumber6.getValue('bigint')).toBe(10050000n);
 
       const skNumber7 = new SwapKitNumber({ value: -0.1005, decimal: 3 });
-      expect(skNumber7.value).toBe('-0.101');
-      expect(skNumber7.bigIntValue).toBe(-10050000n);
+      expect(skNumber7.getValue('string')).toBe('-0.101');
+      expect(skNumber7.getValue('bigint')).toBe(-10050000n);
       expect(skNumber7.decimal).toBe(3);
-      expect(skNumber7.unsafeNumber).toBe(0);
+      expect(skNumber7.getValue('number')).toBe(-0.101);
       expect(skNumber7.decimalMultiplier).toBe(100000000n);
-      expect(skNumber7.toString()).toBe('-0.101');
     });
 
     test('creates SwapKitInstance from BigInt: (12.345678901234, decimals: 12)', () => {
       const skNumber = SwapKitNumber.fromBigInt(12345678901234n, 12);
 
-      expect(skNumber.value).toBe('12.345678901234');
-      expect(skNumber.bigIntValue).toBe(12345678901234n);
+      expect(skNumber.getValue('string')).toBe('12.345678901234');
+      expect(skNumber.getValue('bigint')).toBe(12345678901234n);
     });
   });
 
   describe('shiftDecimals', () => {
     test('shifts up and bumps number', () => {
       const skNumber = new SwapKitNumber(1);
-      expect(skNumber.value).toBe('1');
-      expect(skNumber.bigIntValue).toBe(100000000n);
+      expect(skNumber.getValue('string')).toBe('1');
+      expect(skNumber.getValue('bigint')).toBe(100000000n);
 
       const shiftedSkNumber = SwapKitNumber.shiftDecimals({
         value: skNumber,
@@ -54,14 +54,14 @@ describe('SwapKitNumber', () => {
         to: 8,
       });
 
-      expect(shiftedSkNumber.value).toBe('100');
-      expect(shiftedSkNumber.bigIntValue).toBe(10000000000n);
+      expect(shiftedSkNumber.getValue('string')).toBe('100');
+      expect(shiftedSkNumber.getValue('bigint')).toBe(10000000000n);
     });
 
-    test.skip('shifts down and rounds down number', () => {
+    test('shifts down and rounds down number', () => {
       const skNumber = new SwapKitNumber(2.12345678);
-      expect(skNumber.value).toBe('2.12345678');
-      expect(skNumber.bigIntValue).toBe(212345678n);
+      expect(skNumber.getValue('string')).toBe('2.12345678');
+      expect(skNumber.getValue('bigint')).toBe(212345678n);
 
       const shiftedSkNumber = SwapKitNumber.shiftDecimals({
         value: skNumber,
@@ -69,8 +69,84 @@ describe('SwapKitNumber', () => {
         to: 6,
       });
 
-      expect(shiftedSkNumber.value).toBe('2.123456');
-      expect(shiftedSkNumber.bigIntValue).toBe(2123456n);
+      expect(shiftedSkNumber.getValue('string')).toBe('2.123456');
+      expect(shiftedSkNumber.getValue('bigint')).toBe(212345600n);
+    });
+  });
+
+  describe('getValue', () => {
+    describe('string', () => {
+      test('returns string value', () => {
+        const skNumber = new SwapKitNumber(1);
+        expect(skNumber.getValue('string')).toBe('1');
+      });
+
+      test('returns string value with decimals', () => {
+        const skNumber = new SwapKitNumber(0.01);
+        expect(skNumber.getValue('string')).toBe('0.01');
+      });
+    });
+
+    describe('number', () => {
+      test('returns number value', () => {
+        const skNumber = new SwapKitNumber(1);
+        expect(skNumber.getValue('number')).toBe(1);
+      });
+
+      test('returns number value with decimals', () => {
+        const skNumber = new SwapKitNumber(0.01);
+        expect(skNumber.getValue('number')).toBe(0.01);
+      });
+    });
+
+    describe('bigint', () => {
+      test('returns bigint value', () => {
+        const skNumber = new SwapKitNumber(1);
+        expect(skNumber.getValue('bigint')).toBe(100000000n);
+      });
+    });
+  });
+
+  describe('toSignificant', () => {
+    describe('normal cases', () => {
+      test('returns first significant number of digits', () => {
+        const usdLikeNumber = new SwapKitNumber(1234.5678);
+        expect(usdLikeNumber.toSignificant(2)).toBe('1200');
+        expect(usdLikeNumber.toSignificant(3)).toBe('1230');
+        expect(usdLikeNumber.toSignificant(4)).toBe('1234');
+        expect(usdLikeNumber.toSignificant(5)).toBe('1234.5');
+        expect(usdLikeNumber.toSignificant(6)).toBe('1234.56');
+        expect(usdLikeNumber.toSignificant(7)).toBe('1234.567');
+        expect(usdLikeNumber.toSignificant(8)).toBe('1234.5678');
+
+        const btcLikeNumber = new SwapKitNumber(0.00005678);
+        expect(btcLikeNumber.toSignificant(2)).toBe('0.000056');
+        expect(btcLikeNumber.toSignificant(3)).toBe('0.0000567');
+        expect(btcLikeNumber.toSignificant(4)).toBe('0.00005678');
+        expect(btcLikeNumber.toSignificant(5)).toBe('0.00005678');
+        expect(btcLikeNumber.toSignificant(8)).toBe('0.00005678');
+      });
+    });
+
+    describe('custom decimals', () => {
+      test('returns first significant number of digits', () => {
+        const usdLikeNumber = new SwapKitNumber({ value: 1234.5678, decimal: 2 });
+        expect(usdLikeNumber.toSignificant(2)).toBe('1200');
+        expect(usdLikeNumber.toSignificant(3)).toBe('1230');
+        expect(usdLikeNumber.toSignificant(4)).toBe('1234');
+        expect(usdLikeNumber.toSignificant(5)).toBe('1234.5');
+        expect(usdLikeNumber.toSignificant(6)).toBe('1234.57');
+        expect(usdLikeNumber.toSignificant(7)).toBe('1234.57');
+        expect(usdLikeNumber.toSignificant(8)).toBe('1234.57');
+
+        const ethLikeNumber = new SwapKitNumber({ value: 0.00005678, decimal: 18 });
+        expect(ethLikeNumber.toSignificant(2)).toBe('0.000056');
+        expect(ethLikeNumber.toSignificant(3)).toBe('0.0000567');
+        expect(ethLikeNumber.toSignificant(4)).toBe('0.00005678');
+        expect(ethLikeNumber.toSignificant(5)).toBe('0.00005678');
+        expect(ethLikeNumber.toSignificant(8)).toBe('0.00005678');
+        expect(ethLikeNumber.toSignificant(18)).toBe('0.00005678');
+      });
     });
   });
 
@@ -81,23 +157,23 @@ describe('SwapKitNumber', () => {
       const skNumber3 = new SwapKitNumber('0.5');
       const result = skNumber1.add(skNumber2, skNumber3);
 
-      expect(result.value).toBe('15.5');
-      expect(result.bigIntValue).toBe(1550000000n);
+      expect(result.getValue('string')).toBe('15.5');
+      expect(result.getValue('bigint')).toBe(1550000000n);
     });
 
     test('adds different type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(10);
       const result = skNumber1.add(6, '0.5');
 
-      expect(result.value).toBe('16.5');
-      expect(result.bigIntValue).toBe(1650000000n);
+      expect(result.getValue('string')).toBe('16.5');
+      expect(result.getValue('bigint')).toBe(1650000000n);
     });
 
     test('adds large decimal numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(0.0000000001);
       const result = skNumber1.add(6.000000000001, '0.0000000000000005');
-      expect(result.value).toBe('6.0000000001010005');
-      expect(result.bigIntValue).toBe(60000000001010005n);
+      expect(result.getValue('string')).toBe('6.0000000001010005');
+      expect(result.getValue('bigint')).toBe(60000000001010005n);
     });
   });
 
@@ -108,16 +184,16 @@ describe('SwapKitNumber', () => {
       const skNumber3 = new SwapKitNumber(0.5);
       const result = skNumber1.sub(skNumber2, skNumber3);
 
-      expect(result.value).toBe('4.5');
-      expect(result.bigIntValue).toBe(450000000n);
+      expect(result.getValue('string')).toBe('4.5');
+      expect(result.getValue('bigint')).toBe(450000000n);
     });
 
     test('subtracts different type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(10);
       const result = skNumber1.sub(6, '0.5');
 
-      expect(result.value).toBe('3.5');
-      expect(result.bigIntValue).toBe(350000000n);
+      expect(result.getValue('string')).toBe('3.5');
+      expect(result.getValue('bigint')).toBe(350000000n);
     });
 
     test('can process negative results', () => {
@@ -125,10 +201,10 @@ describe('SwapKitNumber', () => {
       const result0 = skNumber1.sub(10);
       const resultMinus = result0.sub('10');
 
-      expect(result0.value).toBe('0');
-      expect(resultMinus.value).toBe('-10');
-      expect(result0.bigIntValue).toBe(0n);
-      expect(resultMinus.bigIntValue).toBe(-1000000000n);
+      expect(result0.getValue('string')).toBe('0');
+      expect(resultMinus.getValue('string')).toBe('-10');
+      expect(result0.getValue('bigint')).toBe(0n);
+      expect(resultMinus.getValue('bigint')).toBe(-1000000000n);
     });
   });
 
@@ -139,24 +215,24 @@ describe('SwapKitNumber', () => {
       const skNumber3 = new SwapKitNumber(0.5);
       const result = skNumber1.mul(skNumber2, skNumber3);
 
-      expect(result.value).toBe('25');
-      expect(result.bigIntValue).toBe(2500000000n);
+      expect(result.getValue('string')).toBe('25');
+      expect(result.getValue('bigint')).toBe(2500000000n);
     });
 
     test('multiplies different type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(10);
       const result = skNumber1.mul(6, '0.5');
 
-      expect(result.value).toBe('30');
-      expect(result.bigIntValue).toBe(3000000000n);
+      expect(result.getValue('string')).toBe('30');
+      expect(result.getValue('bigint')).toBe(3000000000n);
     });
 
     test('multiplies numbers correctly if decimals of SKN is lower than number multiplied with', () => {
       const skNumber1 = new SwapKitNumber({ value: 1000000, decimal: 4 });
       const result = skNumber1.mul('0.00001');
 
-      expect(result.value).toBe('10');
-      expect(result.bigIntValue).toBe(1000000000n);
+      expect(result.getValue('string')).toBe('10');
+      expect(result.getValue('bigint')).toBe(1000000000n);
     });
 
     test('should correctly round the result of multiplication', () => {
@@ -167,8 +243,8 @@ describe('SwapKitNumber', () => {
 
       // 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.value).toBe('5.61');
-      expect(result.bigIntValue).toBe(560880000n);
+      expect(result.getValue('string')).toBe('5.61');
+      expect(result.getValue('bigint')).toBe(560880000n);
 
       const skNumber3 = new SwapKitNumber({ decimal: 2, value: 1.23 });
       const skNumber4 = new SwapKitNumber(-1.234567891);
@@ -177,8 +253,8 @@ describe('SwapKitNumber', () => {
 
       // The exact result of 1.23 * -1.234567891 is -1,518518505
       // If we round it to 2 decimal places, we should get 5.61
-      expect(result2.value).toBe('-1.52');
-      expect(result2.bigIntValue).toBe(-1518518505n);
+      expect(result2.getValue('string')).toBe('-1.52');
+      expect(result2.getValue('bigint')).toBe(-1518518505n);
     });
   });
 
@@ -189,38 +265,38 @@ describe('SwapKitNumber', () => {
       const skNumber3 = new SwapKitNumber(0.5);
       const result = skNumber1.div(skNumber2, skNumber3);
 
-      expect(result.value).toBe('4');
-      expect(result.bigIntValue).toBe(400000000n);
+      expect(result.getValue('string')).toBe('4');
+      expect(result.getValue('bigint')).toBe(400000000n);
 
       const skNumber4 = new SwapKitNumber(10.12);
       const result2 = skNumber4.div(0.0001);
 
-      expect(result2.value).toBe('101200');
-      expect(result2.bigIntValue).toBe(10120000000000n);
+      expect(result2.getValue('string')).toBe('101200');
+      expect(result2.getValue('bigint')).toBe(10120000000000n);
     });
 
     test('divides different type numbers correctly', () => {
       const skNumber1 = new SwapKitNumber(20);
       const result = skNumber1.div(5, '0.5');
 
-      expect(result.value).toBe('8');
-      expect(result.bigIntValue).toBe(800000000n);
+      expect(result.getValue('string')).toBe('8');
+      expect(result.getValue('bigint')).toBe(800000000n);
     });
 
     test('divides different type numbers correctly when decimal is set', () => {
       const skNumber1 = new SwapKitNumber({ value: '1.2', decimal: 2 });
       const result = skNumber1.div(0.001);
 
-      expect(result.value).toBe('1200');
-      expect(result.bigIntValue).toBe(120000000000n);
+      expect(result.getValue('string')).toBe('1200');
+      expect(result.getValue('bigint')).toBe(120000000000n);
     });
 
     test('divides smaller number by larger number', () => {
       const skNumber1 = new SwapKitNumber(1);
       const result = skNumber1.div(2);
 
-      expect(result.value).toBe('0.5');
-      expect(result.bigIntValue).toBe(50000000n);
+      expect(result.getValue('string')).toBe('0.5');
+      expect(result.getValue('bigint')).toBe(50000000n);
     });
 
     test('divides a number with 18 decimals by a negative number with less decimals', () => {
@@ -230,8 +306,8 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(skNumber2);
 
       // The exact result of 1.000000000000000010 / -2 is -0.500000000000000005
-      expect(result.value).toBe('-0.500000000000000005');
-      expect(result.bigIntValue).toBe(-500000000000000005n);
+      expect(result.getValue('string')).toBe('-0.500000000000000005');
+      expect(result.getValue('bigint')).toBe(-500000000000000005n);
     });
 
     test('divides a number with 2 decimals by a negative number with more decimals', () => {
@@ -241,8 +317,8 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(skNumber2);
 
       // The exact result of 2 / -0.000005 is -400000
-      expect(result.value).toBe('-400000');
-      expect(result.bigIntValue).toBe(-40000000000000n);
+      expect(result.getValue('string')).toBe('-400000');
+      expect(result.getValue('bigint')).toBe(-40000000000000n);
     });
   });
 
@@ -252,8 +328,8 @@ describe('SwapKitNumber', () => {
       const skNumber2 = new SwapKitNumber({ value: 987_654_321_000, decimal: 18 });
 
       const result = skNumber1.mul(skNumber2);
-      expect(result.value).toBe('987654321000000987654321000');
-      expect(result.bigIntValue).toBe(987654321000000987654321000000000000000000000n);
+      expect(result.getValue('string')).toBe('987654321000000987654321000');
+      expect(result.getValue('bigint')).toBe(987654321000000987654321000000000000000000000n);
     });
 
     test('divide huge numbers', () => {
@@ -261,8 +337,8 @@ describe('SwapKitNumber', () => {
       const skNumber2 = new SwapKitNumber({ value: 987_654_321_000, decimal: 18 });
 
       const result = skNumber1.div(skNumber2);
-      expect(result.value).toBe('1012.4999999873447625');
-      expect(result.bigIntValue).toBe(1012499999987344762500n);
+      expect(result.getValue('string')).toBe('1012.4999999873447625');
+      expect(result.getValue('bigint')).toBe(1012499999987344762500n);
     });
   });
 

package/src/modules/assetValue.ts

@@ -59,6 +59,46 @@ const createAssetValue = async (assetString: string, value: number | string = 0)
 };
 
 export class AssetValue extends BigIntArithmetics {
+  address?: string;
+  chain: Chain;
+  isSynthetic = false;
+  isGasAsset = false;
+  symbol: string;
+  ticker: string;
+  type: ReturnType<typeof getAssetType>;
+
+  constructor(params: AssetValueParams) {
+    super(
+      params.value instanceof BigIntArithmetics
+        ? params.value
+        : { decimal: params.decimal, value: params.value },
+    );
+
+    const identifier =
+      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
+    const assetInfo = getAssetInfo(identifier);
+
+    this.type = getAssetType(assetInfo);
+    this.chain = assetInfo.chain;
+    this.ticker = assetInfo.ticker;
+    this.symbol = assetInfo.symbol;
+    this.address = assetInfo.address;
+    this.isSynthetic = assetInfo.isSynthetic;
+    this.isGasAsset = assetInfo.isGasAsset;
+  }
+
+  get assetValue() {
+    return `${this.getValue('string')} ${this.ticker}`;
+  }
+
+  toString() {
+    return `${this.chain}.${this.symbol}`;
+  }
+
+  eq({ chain, symbol }: { chain: Chain; symbol: string }) {
+    return this.chain === chain && this.symbol === symbol;
+  }
+
   static async fromString(assetString: string, value: number | string = 0) {
     return createAssetValue(assetString, value);
   }
@@ -149,46 +189,6 @@ export class AssetValue extends BigIntArithmetics {
       },
     );
   }
-
-  address?: string;
-  chain: Chain;
-  isSynthetic = false;
-  isGasAsset = false;
-  symbol: string;
-  ticker: string;
-  type: ReturnType<typeof getAssetType>;
-
-  constructor(params: AssetValueParams) {
-    super(
-      params.value instanceof BigIntArithmetics
-        ? params.value
-        : { decimal: params.decimal, value: params.value },
-    );
-
-    const identifier =
-      'identifier' in params ? params.identifier : `${params.chain}.${params.symbol}`;
-    const assetInfo = getAssetInfo(identifier);
-
-    this.type = getAssetType(assetInfo);
-    this.chain = assetInfo.chain;
-    this.ticker = assetInfo.ticker;
-    this.symbol = assetInfo.symbol;
-    this.address = assetInfo.address;
-    this.isSynthetic = assetInfo.isSynthetic;
-    this.isGasAsset = assetInfo.isGasAsset;
-  }
-
-  get assetValue() {
-    return `${this.value} ${this.ticker}`;
-  }
-
-  toString() {
-    return `${this.chain}.${this.symbol}`;
-  }
-
-  eq({ chain, symbol }: { chain: Chain; symbol: string }) {
-    return this.chain === chain && this.symbol === symbol;
-  }
 }
 
 export const getMinAmountByChain = (chain: Chain) => {