@swapkit/core 1.0.0-rc.0

package/src/aggregator/getSwapParams.ts

@@ -0,0 +1,70 @@
+import type { QuoteRoute } from '@swapkit/api';
+
+import type { AGG_CONTRACT_ADDRESS } from './contracts/index.ts';
+import { lowercasedGenericAbiMappings } from './contracts/index.ts';
+
+type SwapInParams = {
+  calldata: QuoteRoute['calldata'];
+  recipient: string;
+  streamSwap?: boolean;
+  contractAddress: AGG_CONTRACT_ADDRESS;
+  toChecksumAddress: (address: string) => string;
+};
+
+export const getSwapInParams = ({
+  streamSwap,
+  contractAddress,
+  recipient,
+  toChecksumAddress,
+  calldata: {
+    amount,
+    amountOutMin = '',
+    data = '',
+    deadline,
+    memo,
+    router,
+    memoStreamingSwap,
+    tcMemo,
+    tcRouter,
+    tcVault,
+    vault,
+    token,
+  },
+}: SwapInParams) => {
+  const isGeneric = !!lowercasedGenericAbiMappings[contractAddress.toLowerCase()];
+
+  if (isGeneric && !router) {
+    throw new Error('Router is required on calldata for swapIn with GenericContract');
+  }
+
+  /**
+   * Data structure for contract calls
+   * GENERIC: tcRouter, tcVault, tcMemo, token, amount, router, data, deadline
+   * ETH_UNISWAP: tcRouter, tcVault, tcMemo, token, amount, amountOutMin, deadline
+   * AVAX_PANGOLIN: tcRouter, tcVault, tcMemo, token, amount, amountOutMin, deadline
+   * AVAX_WOOFI: router, vault, memo, token, amount, amountOutMin, deadline
+   */
+
+  const baseMemo = tcMemo || memo;
+  const transactionMemo = streamSwap ? memoStreamingSwap || baseMemo : baseMemo;
+
+  if (!tcVault && !vault) throw new Error('TC Vault is required on calldata');
+  if (!tcRouter && !router) throw new Error('TC Router is required on calldata');
+  if (!transactionMemo) throw new Error('TC Memo is required on calldata');
+  if (!token) throw new Error('Token is required on calldata');
+
+  const baseParams = [
+    // v2 contracts don't have tcVault, tcRouter, tcMemo but vault, router, memo
+    toChecksumAddress((tcRouter || router) as string),
+    toChecksumAddress((tcVault || vault) as string),
+    transactionMemo.replace('{recipientAddress}', recipient),
+    toChecksumAddress(token),
+    amount,
+  ];
+
+  const contractParams = isGeneric
+    ? [toChecksumAddress(router as string), data, deadline]
+    : [amountOutMin, deadline];
+
+  return [...baseParams, ...contractParams];
+};

package/src/client/__tests__/helpers.test.ts

@@ -0,0 +1,69 @@
+import { Chain, ChainToExplorerUrl } from '@swapkit/types';
+import { describe, expect, test } from 'vitest';
+
+import { getExplorerAddressUrl, getExplorerTxUrl } from '../explorerUrls.ts';
+
+describe('Explorer URLs', () => {
+  Object.values(Chain)
+    .filter((c) => ![Chain.Litecoin, Chain.Dogecoin, Chain.Cosmos].includes(c))
+    .forEach((chain) => {
+      test(`getExplorerTxUrl returns correct URL for ${chain}`, () => {
+        expect(getExplorerTxUrl({ chain, txHash: '0x12345' })).toBe(
+          `${ChainToExplorerUrl[chain]}/tx/0x12345`,
+        );
+
+        expect(getExplorerAddressUrl({ chain, address: 'asdfg' })).toBe(
+          `${ChainToExplorerUrl[chain]}/address/asdfg`,
+        );
+      });
+    });
+
+  test('getExplorerTxUrl throws Error for unsupported Chain', () => {
+    expect(() =>
+      getExplorerTxUrl({ chain: 'unsupported' as Chain, txHash: '0x12345' }),
+    ).toThrowError('Unsupported chain: unsupported');
+  });
+  test('getExplorerAddressUrl throws Error for unsupported Chain', () => {
+    expect(() =>
+      getExplorerAddressUrl({ chain: 'unsupported' as Chain, address: 'asdfg' }),
+    ).toThrowError('Unsupported chain: unsupported');
+  });
+  test('getExplorerTxUrl adds 0x for EVM like chains', () => {
+    expect(getExplorerTxUrl({ chain: Chain.Ethereum, txHash: '12345' })).toBe(
+      'https://etherscan.io/tx/0x12345',
+    );
+  });
+
+  test('getExplorerTxUrl returns correct URL for Litecoin', () => {
+    expect(getExplorerTxUrl({ chain: Chain.Litecoin, txHash: 'efghi' })).toBe(
+      'https://ltc.bitaps.com/efghi',
+    );
+  });
+  test('getExplorerAddressUrl returns correct URL for Litecoin', () => {
+    expect(getExplorerAddressUrl({ chain: Chain.Litecoin, address: '12345' })).toBe(
+      'https://ltc.bitaps.com/12345',
+    );
+  });
+
+  test('getExplorerTxUrl returns correct URL for Cosmos', () => {
+    expect(getExplorerTxUrl({ chain: Chain.Cosmos, txHash: 'pqrst' })).toBe(
+      'https://cosmos.bigdipper.live/transactions/pqrst',
+    );
+  });
+  test('getExplorerAddressUrl returns correct URL for Cosmos', () => {
+    expect(getExplorerAddressUrl({ chain: Chain.Cosmos, address: 'zabcd' })).toBe(
+      'https://cosmos.bigdipper.live/account/zabcd',
+    );
+  });
+
+  test('getExplorerTxUrl returns correct URL for Doge', () => {
+    expect(getExplorerTxUrl({ chain: Chain.Dogecoin, txHash: 'uvwxy' })).toBe(
+      'https://blockchair.com/dogecoin/transaction/uvwxy',
+    );
+  });
+  test('getExplorerAddressUrl returns correct URL for Doge', () => {
+    expect(getExplorerAddressUrl({ chain: Chain.Dogecoin, address: 'efghi' })).toBe(
+      'https://blockchair.com/dogecoin/address/efghi',
+    );
+  });
+});

package/src/client/explorerUrls.ts

@@ -0,0 +1,60 @@
+import { Chain, ChainToExplorerUrl } from '@swapkit/types';
+
+export const getExplorerTxUrl = ({ chain, txHash }: { txHash: string; chain: Chain }) => {
+  const baseUrl = ChainToExplorerUrl[chain];
+
+  switch (chain) {
+    case Chain.Binance:
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Maya:
+    case Chain.THORChain:
+      return `${baseUrl}/tx/${txHash}`;
+
+    case Chain.Arbitrum:
+    case Chain.Avalanche:
+    case Chain.BinanceSmartChain:
+    case Chain.Ethereum:
+    case Chain.Optimism:
+    case Chain.Polygon:
+      return `${baseUrl}/tx/${txHash.startsWith('0x') ? txHash : `0x${txHash}`}`;
+
+    case Chain.Cosmos:
+      return `${baseUrl}/transactions/${txHash}`;
+    case Chain.Dogecoin:
+      return `${baseUrl}/transaction/${txHash.toLowerCase()}`;
+    case Chain.Litecoin:
+      return `${baseUrl}/${txHash}`;
+
+    default:
+      throw new Error(`Unsupported chain: ${chain}`);
+  }
+};
+
+export const getExplorerAddressUrl = ({ chain, address }: { address: string; chain: Chain }) => {
+  const baseUrl = ChainToExplorerUrl[chain];
+
+  switch (chain) {
+    case Chain.Arbitrum:
+    case Chain.Avalanche:
+    case Chain.Binance:
+    case Chain.BinanceSmartChain:
+    case Chain.Bitcoin:
+    case Chain.BitcoinCash:
+    case Chain.Dogecoin:
+    case Chain.Ethereum:
+    case Chain.Maya:
+    case Chain.Optimism:
+    case Chain.Polygon:
+    case Chain.THORChain:
+      return `${baseUrl}/address/${address}`;
+
+    case Chain.Cosmos:
+      return `${baseUrl}/account/${address}`;
+    case Chain.Litecoin:
+      return `${baseUrl}/${address}`;
+
+    default:
+      throw new Error(`Unsupported chain: ${chain}`);
+  }
+};