@swapkit/helpers 1.0.0-rc.0

package/src/helpers/memo.ts

@@ -0,0 +1,90 @@
+import type { Chain } from '@swapkit/types';
+import { MemoType } from '@swapkit/types';
+
+export type ThornameRegisterParam = {
+  name: string;
+  chain: string;
+  address: string;
+  owner?: string;
+  preferredAsset?: string;
+  expiryBlock?: string;
+};
+
+const getShortenedSymbol = ({
+  symbol,
+  ticker,
+  chain,
+}: {
+  ticker: string;
+  symbol: string;
+  chain: string | Chain;
+}) => (chain === 'ETH' && ticker !== 'ETH' ? `${ticker}-${symbol.slice(-3)}` : symbol);
+
+type WithAddress<T = {}> = T & { address: string };
+type WithChain<T = {}> = T & { chain: Chain };
+
+export type MemoOptions<T extends MemoType> = {
+  [MemoType.BOND]: WithAddress;
+  [MemoType.LEAVE]: WithAddress;
+  [MemoType.CLOSE_LOAN]: WithAddress<{ asset: string; minAmount?: string }>;
+  [MemoType.OPEN_LOAN]: WithAddress<{ asset: string; minAmount?: string }>;
+  [MemoType.UNBOND]: WithAddress<{ unbondAmount: number }>;
+  [MemoType.DEPOSIT]: WithChain<{ symbol: string; address?: string; singleSide?: boolean }>;
+  [MemoType.WITHDRAW]: WithChain<{
+    ticker: string;
+    symbol: string;
+    basisPoints: number;
+    targetAssetString?: string;
+    singleSide?: boolean;
+  }>;
+  [MemoType.THORNAME_REGISTER]: Omit<ThornameRegisterParam, 'preferredAsset' | 'expiryBlock'>;
+}[T];
+
+export const getMemoFor = <T extends MemoType>(memoType: T, options: MemoOptions<T>) => {
+  switch (memoType) {
+    case MemoType.LEAVE:
+    case MemoType.BOND: {
+      const { address } = options as MemoOptions<MemoType.BOND>;
+      return `${memoType}:${address}`;
+    }
+
+    case MemoType.UNBOND: {
+      const { address, unbondAmount } = options as MemoOptions<MemoType.UNBOND>;
+      return `${memoType}:${address}:${unbondAmount * 10 ** 8}`;
+    }
+
+    case MemoType.THORNAME_REGISTER: {
+      const { name, chain, address, owner } = options as MemoOptions<MemoType.THORNAME_REGISTER>;
+      return `${memoType}:${name}:${chain}:${address}${owner ? `:${owner}` : ''}`;
+    }
+
+    case MemoType.DEPOSIT: {
+      const { chain, symbol, address, singleSide } = options as MemoOptions<MemoType.DEPOSIT>;
+
+      return singleSide
+        ? `${memoType}:${chain}/${symbol}::t:0`
+        : `${memoType}:${chain}.${symbol}:${address || ''}:t:0`;
+    }
+
+    case MemoType.WITHDRAW: {
+      const { chain, ticker, symbol, basisPoints, targetAssetString, singleSide } =
+        options as MemoOptions<MemoType.WITHDRAW>;
+
+      const target = !singleSide && targetAssetString ? `:${targetAssetString}` : '';
+      const shortenedSymbol = getShortenedSymbol({ chain, symbol, ticker });
+      const assetDivider = singleSide ? '/' : '.';
+
+      return `${memoType}:${chain}${assetDivider}${shortenedSymbol}:${basisPoints}${target}`;
+    }
+
+    case MemoType.OPEN_LOAN:
+    case MemoType.CLOSE_LOAN: {
+      const { asset, address } = options as MemoOptions<MemoType.OPEN_LOAN>;
+
+      return `${memoType}:${asset}:${address}`; //:${minAmount ? `${minAmount}` : ''}:t:0`;
+    }
+
+    default:
+      return '';
+  }
+};

package/src/helpers/number.ts

@@ -0,0 +1,40 @@
+// THORChain base amount is 1e8
+export const DEFAULT_DECIMAL = 8;
+
+export const formatBigIntToSafeValue = ({
+  value,
+  bigIntDecimal = DEFAULT_DECIMAL,
+  decimal = DEFAULT_DECIMAL,
+}: {
+  value: bigint;
+  bigIntDecimal?: number;
+  decimal?: number;
+}) => {
+  const isNegative = value < 0n;
+  let valueString = value.toString().substring(isNegative ? 1 : 0);
+
+  const padLength = decimal - (valueString.length - 1);
+
+  if (padLength > 0) {
+    valueString = '0'.repeat(padLength) + valueString;
+  }
+
+  const decimalIndex = valueString.length - decimal;
+  let decimalString = valueString.slice(-decimal);
+
+  // 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 ? '-' : ''}${valueString.slice(0, decimalIndex)}.${decimalString}`.replace(
+    /\.?0*$/,
+    '',
+  );
+};

package/src/helpers/others.ts

@@ -0,0 +1,59 @@
+// 10 rune for register, 1 rune per year
+// MINIMUM_REGISTRATION_FEE = 11
+export const getTHORNameCost = (year: number) => {
+  if (year < 0) throw new Error('Invalid number of year');
+  return 10 + year;
+};
+
+export const validateTHORName = (name: string) => {
+  if (name.length > 30) return false;
+
+  const regex = /^[a-zA-Z0-9+_-]+$/g;
+
+  return !!name.match(regex);
+};
+
+export const derivationPathToString = ([network, chainId, account, change, index]: number[]) => {
+  const shortPath = typeof index !== 'number';
+
+  return `${network}'/${chainId}'/${account}'/${change}${shortPath ? '' : `/${index}`}`;
+};
+
+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();
+};
+
+export const postRequest = async <T>(
+  url: string,
+  body: string,
+  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();
+};

package/src/helpers/validators.ts

@@ -0,0 +1,17 @@
+import { Chain } from '@swapkit/types';
+
+const supportedChains = Object.values(Chain);
+
+export const validateIdentifier = (identifier: string = '') => {
+  const uppercasedIdentifier = identifier.toUpperCase();
+
+  const [chain] = uppercasedIdentifier.split('.') as [Chain, string];
+  if (supportedChains.includes(chain)) return true;
+
+  const [synthChain] = uppercasedIdentifier.split('/') as [Chain, string];
+  if (supportedChains.includes(synthChain)) return true;
+
+  throw new Error(
+    `Invalid identifier: ${identifier}. Expected format: <Chain>.<Ticker> or <Chain>.<Ticker>-<ContractAddress>`,
+  );
+};

package/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Helpers
+ */
+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';

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

@@ -0,0 +1,285 @@
+import { BaseDecimal, Chain } from '@swapkit/types';
+import { describe, expect, test } from 'vitest';
+
+import { AssetValue } from '../assetValue.ts';
+
+describe('AssetValue', () => {
+  describe('assetValue', () => {
+    test('returns asset ticker with value', () => {
+      const fakeAvaxUSDCAsset = new AssetValue({
+        decimal: 6,
+        value: 1234567890,
+        chain: Chain.Avalanche,
+        symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+      });
+      expect(fakeAvaxUSDCAsset.assetValue).toBe('1234567890 USDC');
+
+      const thor = AssetValue.fromChainOrSignature('ETH.THOR');
+      expect(thor.assetValue).toBe('0 THOR');
+
+      const ethSynth = new AssetValue({
+        chain: Chain.THORChain,
+        symbol: 'ETH/ETH',
+        decimal: 18,
+        value: 1234567890,
+      });
+      expect(ethSynth.assetValue).toBe('1234567890 ETH/ETH');
+      expect(ethSynth.toString()).toBe('THOR.ETH/ETH');
+    });
+  });
+
+  describe('eq', () => {
+    test('checks if assets are same chain and symbol', () => {
+      const firstThor = AssetValue.fromChainOrSignature('ETH.THOR');
+      const secondThor = AssetValue.fromChainOrSignature('ETH.THOR');
+      const vThor = AssetValue.fromChainOrSignature('ETH.vTHOR');
+      const firstUsdc = new AssetValue({
+        chain: Chain.Avalanche,
+        symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+        decimal: 6,
+        value: 1234567890,
+      });
+      const secondUsdc = new AssetValue({
+        chain: Chain.Avalanche,
+        symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+        decimal: 6,
+        value: 1234,
+      });
+
+      expect(firstThor.eq(firstThor)).toBe(true);
+      expect(firstThor.eq(secondThor)).toBe(true);
+      expect(firstThor.eq(vThor)).toBe(false);
+      expect(firstThor.eq(firstUsdc)).toBe(false);
+      expect(firstThor.eq(secondUsdc)).toBe(false);
+
+      expect(firstUsdc.eq(firstThor)).toBe(false);
+      expect(firstUsdc.eq(secondThor)).toBe(false);
+      expect(firstUsdc.eq(vThor)).toBe(false);
+      expect(firstUsdc.eq(firstUsdc)).toBe(true);
+      expect(firstUsdc.eq(secondUsdc)).toBe(true);
+    });
+  });
+
+  describe('toString', () => {
+    test('returns asset value string/identifier', async () => {
+      const fakeAvaxUSDCAsset = new AssetValue({
+        decimal: 6,
+        value: 1234567890,
+        chain: Chain.Avalanche,
+        symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+      });
+      expect(fakeAvaxUSDCAsset.toString()).toBe(
+        'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+      );
+
+      const thor = AssetValue.fromChainOrSignature('ETH.THOR');
+      expect(thor.toString()).toBe('ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044');
+
+      const ethSynth = await AssetValue.fromIdentifier('ETH/ETH');
+      expect(ethSynth.toString()).toBe('THOR.ETH/ETH');
+    });
+  });
+
+  describe('fromIdentifier', () => {
+    test('creates AssetValue from string', async () => {
+      const fakeAvaxUSDCAssetString = 'AVAX.USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e';
+      const fakeAvaxUSDCAsset = await AssetValue.fromIdentifier(fakeAvaxUSDCAssetString);
+
+      expect(fakeAvaxUSDCAsset).toEqual(
+        expect.objectContaining({
+          address: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+          chain: Chain.Avalanche,
+          decimal: 6,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'USDC-0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+          ticker: 'USDC',
+        }),
+      );
+    });
+  });
+
+  describe('fromString', () => {
+    test('creates AssetValue from string', () => {
+      test('creates AssetValue from string', async () => {
+        const fakeAvaxAssetString = 'AVAX.ASDF-1234';
+        const fakeAvaxAsset = await AssetValue.fromString(fakeAvaxAssetString);
+
+        expect(fakeAvaxAsset).toEqual(
+          expect.objectContaining({
+            address: '1234',
+            chain: Chain.Avalanche,
+            decimal: 10,
+            isGasAsset: false,
+            isSynthetic: false,
+            symbol: 'ASDF-1234',
+            ticker: 'ASDF',
+          }),
+        );
+      });
+    });
+  });
+
+  describe('fromIdentifierSync', () => {
+    test('(same as fromIdentifier) - creates AssetValue from string via `@swapkit/tokens` lists', async () => {
+      await AssetValue.loadStaticAssets();
+      const thor = AssetValue.fromIdentifierSync(
+        'ARB.USDT-0XFD086BC7CD5C481DCC9C85EBE478A1C0B69FCBB9',
+      );
+
+      expect(thor).toBeDefined();
+      expect(thor).toEqual(
+        expect.objectContaining({
+          address: '0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9',
+          chain: Chain.Arbitrum,
+          decimal: 6,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'USDT-0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9',
+          ticker: 'USDT',
+        }),
+      );
+    });
+  });
+
+  describe('fromStringSync', () => {
+    test('creates AssetValue from string via `@swapkit/tokens` lists', async () => {
+      await AssetValue.loadStaticAssets();
+      const thor = AssetValue.fromStringSync('ETH.THOR-0xa5f2211b9b8170f694421f2046281775e8468044');
+
+      expect(thor).toBeDefined();
+      expect(thor).toEqual(
+        expect.objectContaining({
+          address: '0xa5f2211b9b8170f694421f2046281775e8468044',
+          chain: Chain.Ethereum,
+          decimal: 18,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'THOR-0xa5f2211b9b8170f694421f2046281775e8468044',
+          ticker: 'THOR',
+        }),
+      );
+    });
+
+    test('returns undefined if string is not in `@swapkit/tokens` lists', async () => {
+      await AssetValue.loadStaticAssets();
+      const fakeAvaxUSDCAssetString = 'AVAX.USDC-1234';
+      const fakeAvaxUSDCAsset = AssetValue.fromStringSync(fakeAvaxUSDCAssetString);
+
+      expect(fakeAvaxUSDCAsset).toBeUndefined();
+    });
+  });
+
+  describe('fromChainOrSignature', () => {
+    test('creates AssetValue from common asset string or chain', () => {
+      const customBaseAsset = [Chain.Cosmos, Chain.BinanceSmartChain, Chain.THORChain, Chain.Maya];
+      Object.values(Chain)
+        .filter((c) => !customBaseAsset.includes(c))
+        .forEach((chain) => {
+          const asset = AssetValue.fromChainOrSignature(chain);
+          expect(asset).toEqual(
+            expect.objectContaining({
+              address: undefined,
+              chain,
+              decimal: BaseDecimal[chain],
+              isGasAsset: ![Chain.Arbitrum, Chain.Optimism].includes(chain),
+              isSynthetic: false,
+              symbol: chain,
+              ticker: chain,
+              type: 'Native',
+            }),
+          );
+        });
+
+      const cosmosAsset = AssetValue.fromChainOrSignature(Chain.Cosmos);
+      expect(cosmosAsset).toEqual(
+        expect.objectContaining({
+          address: undefined,
+          chain: Chain.Cosmos,
+          decimal: BaseDecimal.GAIA,
+          isGasAsset: true,
+          isSynthetic: false,
+          symbol: 'ATOM',
+          ticker: 'ATOM',
+          type: 'Native',
+        }),
+      );
+
+      const bscAsset = AssetValue.fromChainOrSignature(Chain.BinanceSmartChain);
+      expect(bscAsset).toEqual(
+        expect.objectContaining({
+          address: undefined,
+          chain: Chain.BinanceSmartChain,
+          decimal: BaseDecimal.BSC,
+          isGasAsset: true,
+          isSynthetic: false,
+          symbol: 'BNB',
+          ticker: 'BNB',
+          type: 'Native',
+        }),
+      );
+
+      const thorAsset = AssetValue.fromChainOrSignature(Chain.THORChain);
+      expect(thorAsset).toEqual(
+        expect.objectContaining({
+          address: undefined,
+          chain: Chain.THORChain,
+          decimal: BaseDecimal.THOR,
+          isGasAsset: true,
+          isSynthetic: false,
+          symbol: 'RUNE',
+          ticker: 'RUNE',
+          type: 'Native',
+        }),
+      );
+
+      const cacaoAsset = AssetValue.fromChainOrSignature(Chain.Maya);
+      expect(cacaoAsset).toEqual(
+        expect.objectContaining({
+          address: undefined,
+          chain: Chain.Maya,
+          decimal: BaseDecimal.MAYA,
+          isGasAsset: true,
+          isSynthetic: false,
+          symbol: 'CACAO',
+          ticker: 'CACAO',
+          type: 'Native',
+        }),
+      );
+
+      const thor = AssetValue.fromChainOrSignature('ETH.THOR');
+      expect(thor).toEqual(
+        expect.objectContaining({
+          address: '0xa5f2211b9b8170f694421f2046281775e8468044',
+          chain: Chain.Ethereum,
+          decimal: 18,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'THOR-0xa5f2211b9b8170f694421f2046281775e8468044',
+          ticker: 'THOR',
+        }),
+      );
+
+      const vthor = AssetValue.fromChainOrSignature('ETH.vTHOR');
+      expect(vthor).toEqual(
+        expect.objectContaining({
+          address: '0x815c23eca83261b6ec689b60cc4a58b54bc24d8d',
+          chain: Chain.Ethereum,
+          decimal: 18,
+          isGasAsset: false,
+          isSynthetic: false,
+          symbol: 'vTHOR-0x815c23eca83261b6ec689b60cc4a58b54bc24d8d',
+          ticker: 'vTHOR',
+        }),
+      );
+    });
+  });
+
+  describe('loadStaticAssets', () => {
+    test('loads static assets from `@swapkit/tokens` lists', async () => {
+      // Dummy test - think of sth more meaningful
+      const { ok } = await AssetValue.loadStaticAssets();
+      expect(ok).toBe(true);
+    });
+  });
+});