@swapkit/core 4.0.0-beta.8 → 4.0.0

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,38 +1,35 @@
 {
   "author": "swapkit-oss",
   "dependencies": {
-    "@swapkit/helpers": "3.0.0-beta.7",
-    "@swapkit/toolboxes": "1.0.0-beta.8"
+    "@swapkit/helpers": "4.0.0",
+    "@swapkit/toolboxes": "4.0.0"
   },
   "description": "SwapKit - Core",
   "exports": {
     ".": {
       "import": "./dist/index.js",
       "require": "./dist/index.cjs",
-      "types": "./src/index.ts"
+      "types": "./dist/types/index.d.ts"
     }
   },
-  "files": [
-    "src/",
-    "dist/"
-  ],
-  "homepage": "https://github.com/thorswap/SwapKit",
+  "files": ["dist/"],
+  "homepage": "https://github.com/swapkit/SwapKit",
   "license": "Apache-2.0",
   "name": "@swapkit/core",
   "repository": {
     "directory": "packages/core",
     "type": "git",
-    "url": "git+https://github.com/thorswap/SwapKit.git"
+    "url": "git+https://github.com/swapkit/SwapKit.git"
   },
   "scripts": {
     "build": "bun run ./build.ts",
     "build:clean": "rm -rf dist && bun run ./build.ts",
     "clean": "rm -rf dist node_modules *.tsbuildinfo",
     "test": "echo 'bun test'",
-    "test:ci": "bun test --coverage",
+    "test:ci": "echo 'bun test --coverage'",
     "type-check": "bun tsc --noEmit",
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "4.0.0-beta.8"
-}
+  "version": "4.0.0"
+}

package/src/__tests__/helpers.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Chain, ChainToExplorerUrl, CosmosChains, EVMChains, UTXOChains } from "@swapkit/helpers";
-import { getExplorerAddressUrl, getExplorerTxUrl } from "../helpers/explorerUrls";
-
-describe("Explorer URLs", () => {
-  describe("CosmosChains", () => {
-    for (const chain of CosmosChains) {
-      test(`getExplorerTxUrl returns correct URL for ${chain}`, () => {
-        expect(getExplorerTxUrl({ chain, txHash: "0x123456789" })).toBe(
-          `${ChainToExplorerUrl[chain]}/tx/123456789`,
-        );
-
-        expect(getExplorerAddressUrl({ chain, address: "asdfg" })).toBe(
-          `${ChainToExplorerUrl[chain]}/address/asdfg`,
-        );
-      });
-    }
-  });
-
-  describe("EVMChains & SubstrateChains", () => {
-    for (const chain of [...EVMChains, Chain.Polkadot]) {
-      test(`getExplorerTxUrl returns correct URL for ${chain}`, () => {
-        expect(getExplorerTxUrl({ chain, txHash: "0x123456789" })).toBe(
-          `${ChainToExplorerUrl[chain]}/tx/0x123456789`,
-        );
-
-        expect(getExplorerAddressUrl({ chain, address: "asdfg" })).toBe(
-          `${ChainToExplorerUrl[chain]}/address/asdfg`,
-        );
-      });
-    }
-
-    test("getExplorerTxUrl adds 0x for EVM like chains", () => {
-      expect(getExplorerTxUrl({ chain: Chain.Ethereum, txHash: "12345" })).toBe(
-        "https://etherscan.io/tx/0x12345",
-      );
-    });
-  });
-
-  describe("UTXOChains", () => {
-    for (const chain of UTXOChains.filter((c) => c !== Chain.Dash)) {
-      test(`getExplorerTxUrl returns correct URL for ${chain}`, () => {
-        expect(getExplorerTxUrl({ chain, txHash: "0x123456789" })).toBe(
-          `${ChainToExplorerUrl[chain]}/transaction/0x123456789`,
-        );
-
-        expect(getExplorerAddressUrl({ chain, address: "asdfg" })).toBe(
-          `${ChainToExplorerUrl[chain]}/address/asdfg`,
-        );
-      });
-    }
-  });
-
-  describe("Solana", () => {
-    test("getExplorerTxUrl returns correct URL for Solana", () => {
-      expect(getExplorerTxUrl({ chain: Chain.Solana, txHash: "b123456789" })).toBe(
-        "https://solscan.io/tx/b123456789",
-      );
-
-      expect(getExplorerAddressUrl({ chain: Chain.Solana, address: "asdfg" })).toBe(
-        "https://solscan.io/account/asdfg",
-      );
-    });
-  });
-});

package/src/client.ts

@@ -1,412 +0,0 @@
-import type { EVMTransaction, QuoteResponseRoute } from "@swapkit/helpers/api";
-
-import {
-  ApproveMode,
-  type ApproveReturnType,
-  AssetValue,
-  Chain,
-  type ChainWallet,
-  type ConditionalAssetValueReturn,
-  type EVMChain,
-  EVMChains,
-  type FeeOption,
-  type FullWallet,
-  type GenericTransferParams,
-  ProviderName as PluginNameEnum,
-  SKConfig,
-  type SKConfigState,
-  SwapKitError,
-  type SwapParams,
-  type createPlugin,
-  type createWallet,
-} from "@swapkit/helpers";
-import type { EVMCreateTransactionParams, EVMTransferParams } from "@swapkit/toolboxes/evm";
-
-import {
-  getExplorerAddressUrl as getAddressUrl,
-  getExplorerTxUrl as getTxUrl,
-} from "./helpers/explorerUrls";
-
-export type SwapKitParams<P, W> = {
-  config?: SKConfigState;
-  plugins?: P;
-  wallets?: W;
-};
-
-export function SwapKit<
-  Plugins extends ReturnType<typeof createPlugin>,
-  Wallets extends ReturnType<typeof createWallet>,
->({
-  config,
-  plugins,
-  wallets,
-}: { config?: SKConfigState; plugins?: Plugins; wallets?: Wallets } = {}) {
-  if (config) {
-    SKConfig.set(config);
-  }
-
-  type PluginName = keyof Plugins;
-  const connectedWallets = {} as FullWallet;
-  type ConnectedChains = keyof typeof connectedWallets;
-
-  const availablePlugins = Object.entries(plugins || {}).reduce(
-    (acc, [pluginName, plugin]) => {
-      const methods = plugin({ getWallet });
-
-      acc[pluginName as PluginName] = methods as ReturnType<Plugins[keyof Plugins]>;
-      return acc;
-    },
-    {} as { [key in PluginName]: ReturnType<Plugins[key]> },
-  );
-
-  const connectWalletMethods = Object.entries(wallets || {}).reduce(
-    (acc, [walletName, wallet]) => {
-      const connectWallet = wallet.connectWallet({ addChain });
-
-      acc[walletName as keyof Wallets] = connectWallet as ReturnType<
-        Wallets[keyof Wallets]["connectWallet"]
-      >;
-      return acc;
-    },
-    {} as {
-      [key in keyof Wallets]: ReturnType<Wallets[key]["connectWallet"]>;
-    },
-  );
-
-  function getSwapKitPlugin<T extends PluginName>(pluginName?: T) {
-    const availablePlugin = pluginName && availablePlugins[pluginName];
-    const plugin = availablePlugin || Object.values(availablePlugins)[0];
-
-    if (!plugin) {
-      throw new SwapKitError("core_plugin_not_found");
-    }
-
-    return plugin as ReturnType<Plugins[T]>;
-  }
-
-  function addChain<T extends Chain>(
-    connectWallet: Omit<ChainWallet<T>, "balance"> & { balance?: AssetValue[] },
-  ) {
-    const currentWallet = getWallet(connectWallet.chain);
-
-    const balance = connectWallet.balance ||
-      currentWallet.balance || [AssetValue.from({ chain: connectWallet.chain })];
-
-    const wallet = { ...currentWallet, ...connectWallet, balance } as FullWallet[T];
-
-    connectedWallets[connectWallet.chain] = wallet;
-
-    return wallet;
-  }
-
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
-  function approve<T extends ApproveMode>({
-    assetValue,
-    type = "checkOnly" as T,
-    contractAddress: spenderAddress,
-  }: {
-    type: T;
-    assetValue: AssetValue;
-    contractAddress: string | PluginName;
-  }) {
-    const plugin = availablePlugins[spenderAddress];
-
-    if (plugin) {
-      if (type === ApproveMode.CheckOnly && "isAssetValueApproved" in plugin) {
-        // @ts-expect-error TODO: add optional approve for plugin
-        return plugin.isAssetValueApproved({ assetValue }) as ApproveReturnType<T>;
-      }
-      if (type === ApproveMode.Approve && "approveAssetValue" in plugin) {
-        // @ts-expect-error TODO: add optional approve for plugin
-        return plugin.approveAssetValue({ assetValue }) as ApproveReturnType<T>;
-      }
-
-      throw new SwapKitError({
-        errorKey: "core_approve_asset_target_invalid",
-        info: { message: `Target ${String(spenderAddress)} cannot be used for approve operation` },
-      });
-    }
-
-    const chain = assetValue.chain as EVMChain;
-    const isEVMChain = EVMChains.includes(chain);
-    const isNativeEVM = isEVMChain && assetValue.isGasAsset;
-
-    if (isNativeEVM || !isEVMChain || assetValue.isSynthetic) {
-      return Promise.resolve(type === "checkOnly" ? true : "approved") as ApproveReturnType<T>;
-    }
-
-    const wallet = getWallet(chain);
-    const walletAction = type === "checkOnly" ? wallet.isApproved : wallet.approve;
-    if (!walletAction) throw new SwapKitError("core_wallet_connection_not_found");
-
-    if (!(assetValue.address && wallet.address && typeof spenderAddress === "string")) {
-      throw new SwapKitError("core_approve_asset_address_or_from_not_found");
-    }
-
-    return walletAction({
-      amount: assetValue.getBaseValue("bigint"),
-      assetAddress: assetValue.address,
-      from: wallet.address,
-      spenderAddress,
-    }) as ApproveReturnType<T>;
-  }
-
-  /**
-   * @Public
-   */
-  function getWallet<T extends ConnectedChains>(chain: T) {
-    return connectedWallets[chain] || {};
-  }
-
-  function getAllWallets() {
-    return { ...connectedWallets };
-  }
-
-  function getAddress<T extends Chain>(chain: T) {
-    return getWallet(chain)?.address || "";
-  }
-
-  function approveAssetValue(assetValue: AssetValue, contractAddress: string | PluginName) {
-    return approve({ assetValue, contractAddress, type: ApproveMode.Approve });
-  }
-
-  function isAssetValueApproved(assetValue: AssetValue, contractAddress: string | PluginName) {
-    return approve({ assetValue, contractAddress, type: ApproveMode.CheckOnly });
-  }
-
-  function disconnectChain<T extends Chain>(chain: T) {
-    const wallet = getWallet(chain);
-    wallet?.disconnect?.();
-    delete connectedWallets[chain];
-  }
-
-  function disconnectAll() {
-    for (const chain of Object.keys(connectedWallets) as (keyof typeof connectedWallets)[]) {
-      disconnectChain(chain);
-    }
-  }
-
-  function getBalance<T extends Chain, R extends boolean>(
-    chain: T,
-    refresh?: R,
-  ): ConditionalAssetValueReturn<R> {
-    return (
-      refresh
-        ? getWalletWithBalance(chain).then(({ balance }) => balance)
-        : getWallet(chain)?.balance || []
-    ) as ConditionalAssetValueReturn<R>;
-  }
-
-  async function getWalletWithBalance<T extends Chain>(
-    chain: T,
-    scamFilter = true,
-  ): Promise<ReturnType<typeof getWallet> & { balance: AssetValue[] }> {
-    if (chain === Chain.Fiat || !getWallet(chain)) {
-      throw new SwapKitError("core_wallet_connection_not_found");
-    }
-    const wallet = getWallet(chain as Exclude<Chain, Chain.Fiat>);
-    const defaultBalance = [AssetValue.from({ chain })];
-    wallet.balance = defaultBalance;
-
-    if ("getBalance" in wallet) {
-      const balance = await wallet.getBalance(wallet.address, scamFilter);
-      wallet.balance = balance;
-    }
-
-    return wallet;
-  }
-
-  function swap<T extends PluginName>({
-    route,
-    pluginName,
-    ...rest
-  }: SwapParams<T, QuoteResponseRoute>) {
-    const plugin = getSwapKitPlugin(pluginName || route.providers[0]);
-
-    if ("swap" in plugin) {
-      // @ts-expect-error TODO: fix this
-      return plugin.swap({ ...rest, route });
-    }
-
-    throw new SwapKitError("core_plugin_swap_not_found");
-  }
-
-  function transfer({ assetValue, ...params }: GenericTransferParams | EVMTransferParams) {
-    const chain = assetValue.chain;
-    if ([Chain.Fiat, Chain.Radix].includes(chain) || !getWallet(chain)) {
-      throw new SwapKitError("core_wallet_connection_not_found");
-    }
-    const wallet = getWallet(chain as Exclude<Chain, Chain.Fiat | Chain.Radix | Chain.Near>);
-
-    // we need to simplify this to one object params
-    return wallet.transfer({ ...params, assetValue });
-  }
-
-  function signMessage({ chain, message }: { chain: Chain; message: string }) {
-    const wallet = getWallet(chain);
-    if (!wallet) throw new SwapKitError("core_wallet_connection_not_found");
-
-    if ("signMessage" in wallet) {
-      return wallet.signMessage?.(message);
-    }
-
-    throw new SwapKitError({
-      errorKey: "core_wallet_sign_message_not_supported",
-      info: { chain, wallet: wallet.walletType },
-    });
-  }
-
-  async function verifyMessage({
-    address,
-    chain,
-    message,
-    signature,
-  }: { chain: Chain; signature: string; message: string; address: string }) {
-    switch (chain) {
-      case Chain.THORChain: {
-        const { getCosmosToolbox } = await import("@swapkit/toolboxes/cosmos");
-        const toolbox = await getCosmosToolbox(chain);
-
-        return toolbox.verifySignature({ signature, message, address });
-      }
-
-      default:
-        throw new SwapKitError({ errorKey: "core_verify_message_not_supported", info: { chain } });
-    }
-  }
-
-  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: TODO clean this up
-  async function estimateTransactionFee<T extends PluginName>({
-    type,
-    feeOptionKey,
-    params,
-  }: (
-    | { type: "swap"; params: SwapParams<T, QuoteResponseRoute> & { assetValue: AssetValue } }
-    | { type: "transfer"; params: EVMTransferParams | GenericTransferParams }
-    | {
-        type: "approve";
-        params: {
-          assetValue: AssetValue;
-          contractAddress: string | PluginName;
-          feeOptionKey?: FeeOption;
-        };
-      }
-  ) & {
-    feeOptionKey: FeeOption;
-  }): Promise<AssetValue | undefined> {
-    const { assetValue } = params;
-    const { chain } = assetValue;
-
-    if (!getWallet(chain as Chain)) throw new SwapKitError("core_wallet_connection_not_found");
-
-    const baseValue = AssetValue.from({ chain });
-
-    switch (chain) {
-      case Chain.Arbitrum:
-      case Chain.Avalanche:
-      case Chain.Ethereum:
-      case Chain.BinanceSmartChain:
-      case Chain.Polygon: {
-        const wallet = getWallet(chain);
-        if (type === "transfer") {
-          const txObject = await wallet.createTransferTx(params as EVMCreateTransactionParams);
-          return wallet.estimateTransactionFee({ ...txObject, chain, feeOption: feeOptionKey });
-        }
-
-        if (type === "approve" && !assetValue.isGasAsset) {
-          const approvalTx = await wallet.createApprovalTx({
-            assetAddress: assetValue.address as string,
-            spenderAddress: params.contractAddress as string,
-            amount: assetValue.getBaseValue("bigint"),
-            from: wallet.address,
-          });
-
-          return wallet.estimateTransactionFee({ ...approvalTx, chain, feeOption: feeOptionKey });
-        }
-
-        if (type === "swap") {
-          const plugin = params.route.providers[0] as PluginNameEnum;
-          if ([PluginNameEnum.CHAINFLIP, PluginNameEnum.CHAINFLIP_STREAMING].includes(plugin)) {
-            const txObject = await wallet.createTransferTx({
-              sender: wallet.address,
-              recipient: wallet.address,
-              assetValue,
-            });
-
-            return wallet.estimateTransactionFee({ ...txObject, chain, feeOption: feeOptionKey });
-          }
-
-          const { tx } = params.route;
-          if (!tx) {
-            return undefined;
-          }
-
-          return wallet.estimateTransactionFee({
-            ...(tx as EVMTransaction),
-            value: BigInt((tx as EVMTransaction).value),
-            feeOption: feeOptionKey,
-            chain,
-          });
-        }
-
-        return AssetValue.from({ chain });
-      }
-
-      case Chain.Bitcoin:
-      case Chain.BitcoinCash:
-      case Chain.Dogecoin:
-      case Chain.Dash:
-      case Chain.Litecoin: {
-        const { estimateTransactionFee, address: recipient } = getWallet(chain);
-
-        return estimateTransactionFee({ ...params, feeOptionKey, recipient, sender: recipient });
-      }
-
-      case Chain.THORChain:
-      case Chain.Maya:
-      case Chain.Kujira:
-      case Chain.Cosmos: {
-        const { estimateTransactionFee } = await import("@swapkit/toolboxes/cosmos");
-        return estimateTransactionFee(params);
-      }
-
-      case Chain.Polkadot: {
-        const { address, estimateTransactionFee } = getWallet(chain);
-
-        return estimateTransactionFee({ ...params, recipient: address });
-      }
-
-      case Chain.Ripple: {
-        const { estimateTransactionFee } = getWallet(chain);
-
-        return estimateTransactionFee();
-      }
-
-      default:
-        return baseValue;
-    }
-  }
-
-  return {
-    ...availablePlugins,
-    ...connectWalletMethods,
-
-    disconnectAll,
-    disconnectChain,
-    estimateTransactionFee,
-    getAddress,
-    getAllWallets,
-    getBalance,
-    getExplorerAddressUrl: getAddressUrl,
-    getExplorerTxUrl: getTxUrl,
-    getWallet,
-    getWalletWithBalance,
-
-    approveAssetValue,
-    isAssetValueApproved,
-    signMessage,
-    swap,
-    transfer,
-    verifyMessage,
-  };
-}

package/src/helpers/explorerUrls.ts

@@ -1,47 +0,0 @@
-import { Chain, ChainToExplorerUrl, SwapKitError } from "@swapkit/helpers";
-
-export function getExplorerTxUrl({ chain, txHash }: { txHash: string; chain: Chain }) {
-  const baseUrl = ChainToExplorerUrl[chain];
-
-  switch (chain) {
-    case Chain.Maya:
-    case Chain.Kujira:
-    case Chain.Cosmos:
-    case Chain.THORChain:
-    case Chain.Solana:
-      return `${baseUrl}/tx/${txHash.startsWith("0x") ? txHash.slice(2) : txHash}`;
-
-    case Chain.Arbitrum:
-    case Chain.Avalanche:
-    case Chain.BinanceSmartChain:
-    case Chain.Base:
-    case Chain.Ethereum:
-    case Chain.Optimism:
-    case Chain.Polkadot:
-    case Chain.Polygon:
-      return `${baseUrl}/tx/${txHash.startsWith("0x") ? txHash : `0x${txHash}`}`;
-
-    case Chain.Litecoin:
-    case Chain.Bitcoin:
-    case Chain.BitcoinCash:
-    case Chain.Dogecoin:
-    case Chain.Radix:
-      return `${baseUrl}/transaction/${txHash.toLowerCase()}`;
-
-    default:
-      throw new SwapKitError({ errorKey: "core_explorer_unsupported_chain", info: { chain } });
-  }
-}
-
-export function getExplorerAddressUrl({ chain, address }: { address: string; chain: Chain }) {
-  const baseUrl = ChainToExplorerUrl[chain];
-
-  switch (chain) {
-    case Chain.Solana:
-    case Chain.Radix:
-      return `${baseUrl}/account/${address}`;
-
-    default:
-      return `${baseUrl}/address/${address}`;
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from "@swapkit/helpers/api";
-export * from "@swapkit/helpers";
-export * from "./client";