@swapkit/helpers 1.0.0-rc.7 → 1.0.0-rc.9

package/package.json

@@ -1,20 +1,23 @@
 {
   "author": "swapkit-oss-team",
   "description": "SwapKit Lib swapkit-helpers",
+  "dependencies": {
+    "ky": "1.1.2"
+  },
   "devDependencies": {
     "@vitest/coverage-istanbul": "0.34.4",
     "vite": "4.4.9",
     "vitest": "0.34.4",
     "@internal/config": "0.0.0-internal.0",
-    "@swapkit/tokens": "1.0.0-rc.5",
-    "@swapkit/types": "1.0.0-rc.5"
+    "@swapkit/tokens": "1.0.0-rc.6",
+    "@swapkit/types": "1.0.0-rc.6"
   },
   "eslintConfig": {
     "extends": "../../../internal/eslint-config"
   },
   "peerDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.5",
-    "@swapkit/types": "1.0.0-rc.5"
+    "@swapkit/tokens": "1.0.0-rc.6",
+    "@swapkit/types": "1.0.0-rc.6"
   },
   "exports": {
     ".": {
@@ -39,7 +42,7 @@
   "repository": "https://github.com/thorswap/SwapKit.git",
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.0.0-rc.7",
+  "version": "1.0.0-rc.9",
   "scripts": {
     "build": "vite build",
     "clean": "rm -rf dist vite.config.ts.* .turbo node_modules",

package/src/helpers/asset.ts

@@ -1,9 +1,7 @@
 import type { EVMChain } from '@swapkit/types';
 import { BaseDecimal, Chain, ChainToRPC, FeeOption } from '@swapkit/types';
 
-import type { AssetValue } from '../index.ts';
-
-import { postRequest } from './others.ts';
+import { type AssetValue, RequestClient } from '../index.ts';
 
 const getDecimalMethodHex = '0x313ce567';
 
@@ -11,19 +9,15 @@ export type CommonAssetString = 'MAYA.MAYA' | 'ETH.THOR' | 'ETH.vTHOR' | Chain;
 
 const getContractDecimals = async ({ chain, to }: { chain: EVMChain; to: string }) => {
   try {
-    const response = await postRequest<string>(
-      ChainToRPC[chain],
-      JSON.stringify({
-        method: 'eth_call',
-        params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, 'latest'],
+    const { result } = await RequestClient.post<{ result: string }>(ChainToRPC[chain], {
+      headers: { accept: '*/*', 'cache-control': 'no-cache' },
+      body: JSON.stringify({
         id: 44,
         jsonrpc: '2.0',
+        method: 'eth_call',
+        params: [{ to: to.toLowerCase(), data: getDecimalMethodHex }, 'latest'],
       }),
-      { accept: '*/*', 'cache-control': 'no-cache', 'content-type': 'application/json' },
-      true,
-    );
-
-    const { result } = JSON.parse(response) as { result: string };
+    });
 
     return parseInt(BigInt(result).toString());
   } catch (error) {

package/src/helpers/others.ts

@@ -18,51 +18,3 @@ export const derivationPathToString = ([network, chainId, account, change, index
 
   return `${network}'/${chainId}'/${account}'/${change}${shortPath ? '' : `/${index}`}`;
 };
-
-export const getRequest = async <T>(
-  url: string,
-  params?: { [key in string]?: any },
-): Promise<T> => {
-  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>(
-  url: string,
-  body: string,
-  headers?: Record<string, string>,
-  parseAsString = false,
-): Promise<T> => {
-  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/helpers/request.ts

@@ -0,0 +1,16 @@
+import type { Options } from 'ky';
+import ky from 'ky';
+
+const kyClient = ky.create({
+  headers: {
+    referrer: 'https://sk.thorswap.net',
+    referer: 'https://sk.thorswap.net',
+    'Content-Type': 'application/json',
+  },
+});
+
+export const RequestClient = {
+  get: <T>(url: string | URL | Request, options?: Options) => kyClient.get(url, options).json<T>(),
+  post: <T>(url: string | URL | Request, options?: Options) =>
+    kyClient.post(url, options).json<T>(),
+};

package/src/index.ts

@@ -5,6 +5,7 @@ export * from './helpers/asset.ts';
 export * from './helpers/liquidity.ts';
 export * from './helpers/memo.ts';
 export * from './helpers/others.ts';
+export * from './helpers/request.ts';
 
 /**
  * Modules

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

@@ -79,15 +79,13 @@ describe('AssetValue', () => {
 
   describe('toString', () => {
     test('returns asset value string/identifier', async () => {
-      const fakeAvaxUSDCAsset = new AssetValue({
+      const avaxUSDCAsset = new AssetValue({
         decimal: 6,
         value: 1234567890,
         chain: Chain.Avalanche,
         symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
       });
-      expect(fakeAvaxUSDCAsset.toString()).toBe(
-        'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
-      );
+      expect(avaxUSDCAsset.toString()).toBe('AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e');
 
       const thor = AssetValue.fromChainOrSignature('ETH.THOR');
       expect(thor.toString()).toBe('ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044');
@@ -99,10 +97,11 @@ describe('AssetValue', () => {
 
   describe('fromIdentifier', () => {
     test('creates AssetValue from string', async () => {
-      const fakeAvaxUSDCAssetString = 'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e';
-      const fakeAvaxUSDCAsset = await AssetValue.fromIdentifier(fakeAvaxUSDCAssetString);
+      const avaxUSDCAsset = await AssetValue.fromIdentifier(
+        'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+      );
 
-      expect(fakeAvaxUSDCAsset).toEqual(
+      expect(avaxUSDCAsset).toEqual(
         expect.objectContaining({
           address: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
           chain: Chain.Avalanche,

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

@@ -8,37 +8,40 @@ describe('SwapKitNumber', () => {
       const skNumber1 = new SwapKitNumber(1);
       expect(skNumber1.getValue('string')).toBe('1');
       expect(skNumber1.getValue('number')).toBe(1);
-      expect(skNumber1.getValue('bigint')).toBe(100000000n);
+      expect(skNumber1.getBaseValue('bigint')).toBe(100000000n);
 
       const skNumber2 = new SwapKitNumber('1');
       expect(skNumber2.getValue('string')).toBe('1');
-      expect(skNumber2.getValue('bigint')).toBe(100000000n);
+      expect(skNumber2.getBaseValue('bigint')).toBe(100000000n);
 
+      /**
+       * because by default we have 8 decimals - it will be rounded to 0 on base value
+       */
       const skNumber3 = new SwapKitNumber('0.0000000001');
       expect(skNumber3.getValue('string')).toBe('0.0000000001');
-      expect(skNumber3.getValue('bigint')).toBe(1n);
+      expect(skNumber3.getBaseValue('bigint')).toBe(0n);
 
-      const skNumber4 = new SwapKitNumber(0.000000001);
-      expect(skNumber4.getValue('string')).toBe('0.000000001');
-      expect(skNumber4.getValue('bigint')).toBe(1n);
+      const skNumber4 = new SwapKitNumber({ value: '0.0000000001', decimal: 10 });
+      expect(skNumber4.getValue('string')).toBe('0.0000000001');
+      expect(skNumber4.getBaseValue('bigint')).toBe(1n);
 
-      const skNumber6 = new SwapKitNumber({ value: 0.1005, decimal: 3 });
-      expect(skNumber6.getValue('string')).toBe('0.101');
-      expect(skNumber6.getValue('bigint')).toBe(10050000n);
+      const skNumber5 = new SwapKitNumber({ value: 0.1005, decimal: 3 });
+      expect(skNumber5.getValue('string')).toBe('0.101');
+      expect(skNumber5.getBaseValue('bigint')).toBe(100n);
 
-      const skNumber7 = new SwapKitNumber({ value: -0.1005, decimal: 3 });
-      expect(skNumber7.getValue('string')).toBe('-0.101');
-      expect(skNumber7.getValue('bigint')).toBe(-10050000n);
-      expect(skNumber7.decimal).toBe(3);
-      expect(skNumber7.getValue('number')).toBe(-0.101);
-      expect(skNumber7.decimalMultiplier).toBe(100000000n);
+      const skNumber6 = new SwapKitNumber({ value: -0.1005, decimal: 3 });
+      expect(skNumber6.getValue('string')).toBe('-0.101');
+      expect(skNumber6.getBaseValue('bigint')).toBe(-100n);
+      expect(skNumber6.decimal).toBe(3);
+      expect(skNumber6.getValue('number')).toBe(-0.101);
+      expect(skNumber6.decimalMultiplier).toBe(100000000n);
     });
 
     test('creates SwapKitInstance from BigInt: (12.345678901234, decimals: 12)', () => {
       const skNumber = SwapKitNumber.fromBigInt(12345678901234n, 12);
 
       expect(skNumber.getValue('string')).toBe('12.345678901234');
-      expect(skNumber.getValue('bigint')).toBe(12345678901234n);
+      expect(skNumber.getBaseValue('bigint')).toBe(12345678901234n);
     });
   });
 
@@ -46,7 +49,7 @@ describe('SwapKitNumber', () => {
     test('shifts up and bumps number', () => {
       const skNumber = new SwapKitNumber(1);
       expect(skNumber.getValue('string')).toBe('1');
-      expect(skNumber.getValue('bigint')).toBe(100000000n);
+      expect(skNumber.getBaseValue('bigint')).toBe(100000000n);
 
       const shiftedSkNumber = SwapKitNumber.shiftDecimals({
         value: skNumber,
@@ -55,13 +58,13 @@ describe('SwapKitNumber', () => {
       });
 
       expect(shiftedSkNumber.getValue('string')).toBe('100');
-      expect(shiftedSkNumber.getValue('bigint')).toBe(10000000000n);
+      expect(shiftedSkNumber.getBaseValue('bigint')).toBe(10000000000n);
     });
 
     test('shifts down and rounds down number', () => {
       const skNumber = new SwapKitNumber(2.12345678);
       expect(skNumber.getValue('string')).toBe('2.12345678');
-      expect(skNumber.getValue('bigint')).toBe(212345678n);
+      expect(skNumber.getBaseValue('bigint')).toBe(212345678n);
 
       const shiftedSkNumber = SwapKitNumber.shiftDecimals({
         value: skNumber,
@@ -70,7 +73,7 @@ describe('SwapKitNumber', () => {
       });
 
       expect(shiftedSkNumber.getValue('string')).toBe('2.123456');
-      expect(shiftedSkNumber.getValue('bigint')).toBe(212345600n);
+      expect(shiftedSkNumber.getBaseValue('bigint')).toBe(2123456n);
     });
   });
 
@@ -102,7 +105,7 @@ describe('SwapKitNumber', () => {
     describe('bigint', () => {
       test('returns bigint value', () => {
         const skNumber = new SwapKitNumber(1);
-        expect(skNumber.getValue('bigint')).toBe(100000000n);
+        expect(skNumber.getBaseValue('bigint')).toBe(100000000n);
       });
     });
   });
@@ -158,7 +161,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.add(skNumber2, skNumber3);
 
       expect(result.getValue('string')).toBe('15.5');
-      expect(result.getValue('bigint')).toBe(1550000000n);
+      expect(result.getBaseValue('bigint')).toBe(1550000000n);
     });
 
     test('adds different type numbers correctly', () => {
@@ -166,14 +169,14 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.add(6, '0.5');
 
       expect(result.getValue('string')).toBe('16.5');
-      expect(result.getValue('bigint')).toBe(1650000000n);
+      expect(result.getBaseValue('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.getValue('string')).toBe('6.0000000001010005');
-      expect(result.getValue('bigint')).toBe(60000000001010005n);
+      expect(result.getBaseValue('bigint')).toBe(600000000n);
     });
   });
 
@@ -185,7 +188,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.sub(skNumber2, skNumber3);
 
       expect(result.getValue('string')).toBe('4.5');
-      expect(result.getValue('bigint')).toBe(450000000n);
+      expect(result.getBaseValue('bigint')).toBe(450000000n);
     });
 
     test('subtracts different type numbers correctly', () => {
@@ -193,7 +196,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.sub(6, '0.5');
 
       expect(result.getValue('string')).toBe('3.5');
-      expect(result.getValue('bigint')).toBe(350000000n);
+      expect(result.getBaseValue('bigint')).toBe(350000000n);
     });
 
     test('can process negative results', () => {
@@ -203,8 +206,8 @@ describe('SwapKitNumber', () => {
 
       expect(result0.getValue('string')).toBe('0');
       expect(resultMinus.getValue('string')).toBe('-10');
-      expect(result0.getValue('bigint')).toBe(0n);
-      expect(resultMinus.getValue('bigint')).toBe(-1000000000n);
+      expect(result0.getBaseValue('bigint')).toBe(0n);
+      expect(resultMinus.getBaseValue('bigint')).toBe(-1000000000n);
     });
   });
 
@@ -216,7 +219,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.mul(skNumber2, skNumber3);
 
       expect(result.getValue('string')).toBe('25');
-      expect(result.getValue('bigint')).toBe(2500000000n);
+      expect(result.getBaseValue('bigint')).toBe(2500000000n);
     });
 
     test('multiplies different type numbers correctly', () => {
@@ -224,7 +227,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.mul(6, '0.5');
 
       expect(result.getValue('string')).toBe('30');
-      expect(result.getValue('bigint')).toBe(3000000000n);
+      expect(result.getBaseValue('bigint')).toBe(3000000000n);
     });
 
     test('multiplies numbers correctly if decimals of SKN is lower than number multiplied with', () => {
@@ -232,19 +235,19 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.mul('0.00001');
 
       expect(result.getValue('string')).toBe('10');
-      expect(result.getValue('bigint')).toBe(1000000000n);
+      expect(result.getBaseValue('bigint')).toBe(100000n);
     });
 
     test('should correctly round the result of multiplication', () => {
-      const skNumber1 = new SwapKitNumber({ decimal: 2, value: 1.23 });
+      const skNumber1 = new SwapKitNumber({ decimal: 3, value: 1.23 });
       const skNumber2 = new SwapKitNumber({ decimal: 4, value: 4.56 });
 
       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.61');
-      expect(result.getValue('bigint')).toBe(560880000n);
+      expect(result.getValue('string')).toBe('5.609');
+      expect(result.getBaseValue('bigint')).toBe(5608n);
 
       const skNumber3 = new SwapKitNumber({ decimal: 2, value: 1.23 });
       const skNumber4 = new SwapKitNumber(-1.234567891);
@@ -254,7 +257,7 @@ 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.getValue('string')).toBe('-1.52');
-      expect(result2.getValue('bigint')).toBe(-1518518505n);
+      expect(result2.getBaseValue('bigint')).toBe(-151n);
     });
   });
 
@@ -266,13 +269,13 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(skNumber2, skNumber3);
 
       expect(result.getValue('string')).toBe('4');
-      expect(result.getValue('bigint')).toBe(400000000n);
+      expect(result.getBaseValue('bigint')).toBe(400000000n);
 
       const skNumber4 = new SwapKitNumber(10.12);
       const result2 = skNumber4.div(0.0001);
 
       expect(result2.getValue('string')).toBe('101200');
-      expect(result2.getValue('bigint')).toBe(10120000000000n);
+      expect(result2.getBaseValue('bigint')).toBe(10120000000000n);
     });
 
     test('divides different type numbers correctly', () => {
@@ -280,7 +283,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(5, '0.5');
 
       expect(result.getValue('string')).toBe('8');
-      expect(result.getValue('bigint')).toBe(800000000n);
+      expect(result.getBaseValue('bigint')).toBe(800000000n);
     });
 
     test('divides different type numbers correctly when decimal is set', () => {
@@ -288,7 +291,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(0.001);
 
       expect(result.getValue('string')).toBe('1200');
-      expect(result.getValue('bigint')).toBe(120000000000n);
+      expect(result.getBaseValue('bigint')).toBe(120000n);
     });
 
     test('divides smaller number by larger number', () => {
@@ -296,7 +299,7 @@ describe('SwapKitNumber', () => {
       const result = skNumber1.div(2);
 
       expect(result.getValue('string')).toBe('0.5');
-      expect(result.getValue('bigint')).toBe(50000000n);
+      expect(result.getBaseValue('bigint')).toBe(50000000n);
     });
 
     test('divides a number with 18 decimals by a negative number with less decimals', () => {
@@ -307,7 +310,7 @@ describe('SwapKitNumber', () => {
 
       // The exact result of 1.000000000000000010 / -2 is -0.500000000000000005
       expect(result.getValue('string')).toBe('-0.500000000000000005');
-      expect(result.getValue('bigint')).toBe(-500000000000000005n);
+      expect(result.getBaseValue('bigint')).toBe(-500000000000000005n);
     });
 
     test('divides a number with 2 decimals by a negative number with more decimals', () => {
@@ -318,7 +321,7 @@ describe('SwapKitNumber', () => {
 
       // The exact result of 2 / -0.000005 is -400000
       expect(result.getValue('string')).toBe('-400000');
-      expect(result.getValue('bigint')).toBe(-40000000000000n);
+      expect(result.getBaseValue('bigint')).toBe(-40000000n);
     });
   });
 
@@ -329,7 +332,7 @@ describe('SwapKitNumber', () => {
 
       const result = skNumber1.mul(skNumber2);
       expect(result.getValue('string')).toBe('987654321000000987654321000');
-      expect(result.getValue('bigint')).toBe(987654321000000987654321000000000000000000000n);
+      expect(result.getBaseValue('bigint')).toBe(987654321000000987654321000000000000000000000n);
     });
 
     test('divide huge numbers', () => {
@@ -338,7 +341,7 @@ describe('SwapKitNumber', () => {
 
       const result = skNumber1.div(skNumber2);
       expect(result.getValue('string')).toBe('1012.4999999873447625');
-      expect(result.getValue('bigint')).toBe(1012499999987344762500n);
+      expect(result.getBaseValue('bigint')).toBe(1012499999987344762500n);
     });
   });
 

package/src/modules/bigIntArithmetics.ts

@@ -1,3 +1,5 @@
+import { BaseDecimal } from '@swapkit/types';
+
 import type { SwapKitNumber } from './swapKitNumber.ts';
 
 type NumberPrimitivesType = {
@@ -141,7 +143,7 @@ export class BigIntArithmetics {
     return this.bigIntValue === this.getBigIntValue(value);
   }
 
-  getValue<T extends 'number' | 'string' | 'bigint'>(type: T): NumberPrimitivesType[T] {
+  getValue<T extends 'number' | 'string'>(type: T): NumberPrimitivesType[T] {
     const value = this.formatBigIntToSafeValue(
       this.bigIntValue,
       this.decimal || decimalFromMultiplier(this.decimalMultiplier),
@@ -156,12 +158,12 @@ export class BigIntArithmetics {
         return value;
       default:
         // @ts-expect-error False positive
-        return this.bigIntValue;
+        return (this.bigIntValue * BigInt(this.decimal || 8n)) / this.decimalMultiplier;
     }
   }
 
   getBaseValue<T extends 'number' | 'string' | 'bigint'>(type: T): NumberPrimitivesType[T] {
-    const divisor = this.decimalMultiplier / toMultiplier(this.decimal || 0);
+    const divisor = this.decimalMultiplier / toMultiplier(this.decimal || BaseDecimal.THOR);
     const baseValue = this.bigIntValue / divisor;
 
     switch (type) {
@@ -173,7 +175,7 @@ export class BigIntArithmetics {
         return baseValue.toString();
       default:
         // @ts-expect-error False positive
-        return this.bigIntValue;
+        return baseValue;
     }
   }