@tcswap/core 4.1.16

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

@@ -0,0 +1,36 @@
+{
+  "author": "swapkit-oss",
+  "dependencies": {
+    "@tcswap/helpers": "4.5.15",
+    "@tcswap/plugins": "4.2.15",
+    "@tcswap/toolboxes": "4.3.15",
+    "@tcswap/wallets": "4.3.16",
+    "ts-pattern": "^5.9.0"
+  },
+  "description": "USwap - Core",
+  "devDependencies": { "ts-pattern": "5.9.0" },
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "files": ["dist/", "src/"],
+  "homepage": "https://github.com/thorchain/TCSwap",
+  "license": "Apache-2.0",
+  "name": "@tcswap/core",
+  "repository": { "directory": "packages/core", "type": "git", "url": "git+https://github.com/thorchain/TCSwap.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": "echo 'bun test --coverage'",
+    "type-check": "bun tsc --noEmit",
+    "type-check:go": "tsgo"
+  },
+  "type": "module",
+  "version": "4.1.16"
+}

package/src/index.ts

@@ -0,0 +1,409 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  ApproveMode,
+  type ApproveReturnType,
+  AssetValue,
+  Chain,
+  type ChainWallet,
+  type ConditionalAssetValueReturn,
+  CosmosChains,
+  type EVMChain,
+  EVMChains,
+  type FeeOption,
+  type GenericTransferParams,
+  ProviderName as PluginNameEnum,
+  type SwapParams,
+  USwapConfig,
+  type USwapConfigState,
+  USwapError,
+  UTXOChains,
+  type WalletOption,
+} from "@tcswap/helpers";
+import type { EVMTransaction, QuoteResponseRoute } from "@tcswap/helpers/api";
+import type { createPlugin } from "@tcswap/plugins";
+import type { FullWallet } from "@tcswap/toolboxes";
+import type { EVMCreateTransactionParams, EVMTransferParams } from "@tcswap/toolboxes/evm";
+import type { createWallet } from "@tcswap/wallets";
+
+export type USwapParams<P, W> = { config?: USwapConfigState; plugins?: P; wallets?: W };
+
+export function USwap<
+  Plugins extends ReturnType<typeof createPlugin>,
+  Wallets extends ReturnType<typeof createWallet>,
+>({
+  config,
+  plugins,
+  wallets,
+  getActiveWallet,
+}: {
+  config?: USwapConfigState;
+  plugins?: Plugins;
+  wallets?: Wallets;
+  getActiveWallet?: () => WalletOption | undefined;
+} = {}) {
+  if (config) {
+    USwapConfig.set(config);
+  }
+
+  type PluginName = keyof Plugins;
+  const connectedWalletsByChain = {} as FullWallet;
+  const connectedWalletsByWallet = new Map<WalletOption, Map<Chain, FullWallet[Chain]>>();
+  type ConnectedChains = keyof typeof connectedWalletsByChain;
+  type ActionType = "transfer" | "approve" | "swap";
+
+  type ActionParams<P extends PluginName> = {
+    transfer: EVMTransferParams | (GenericTransferParams & { sender?: string });
+    approve: { assetValue: AssetValue; contractAddress: string; feeOptionKey?: FeeOption };
+    swap: SwapParams<P, QuoteResponseRoute> & { assetValue: AssetValue };
+  };
+
+  const availablePlugins = Object.entries(plugins || {}).reduce(
+    (acc, [pluginName, plugin]) => {
+      const methods = plugin({ getWallet: getSelectedWallet });
+
+      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 getUSwapPlugin<T extends PluginName>(pluginName?: T) {
+    const pluginByName = pluginName && availablePlugins[pluginName];
+    const pluginByProvider = Object.values(availablePlugins).find((plugin) =>
+      plugin.supportedUSwapProviders?.includes(pluginName),
+    );
+    const plugin = pluginByName || pluginByProvider;
+
+    if (!plugin) {
+      throw new USwapError("core_plugin_not_found");
+    }
+
+    return plugin as ReturnType<Plugins[T]>;
+  }
+
+  function addChain<T extends Chain>(connectWallet: Omit<ChainWallet<T>, "balance"> & { balance?: AssetValue[] }) {
+    const currentWallet = getWalletByChain(connectWallet.chain);
+
+    const balance = connectWallet?.balance ||
+      currentWallet?.balance || [AssetValue.from({ chain: connectWallet.chain })];
+
+    const wallet = { ...currentWallet, ...connectWallet, balance };
+    connectedWalletsByChain[connectWallet.chain] = wallet as FullWallet[T];
+
+    const walletOption = connectWallet.walletType as WalletOption;
+    let chainMap = connectedWalletsByWallet.get(walletOption);
+    if (!chainMap) {
+      chainMap = new Map<Chain, any>();
+      connectedWalletsByWallet.set(walletOption, chainMap);
+    }
+
+    chainMap.set(connectWallet.chain, wallet as FullWallet[T]);
+
+    return wallet;
+  }
+
+  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 USwapError({
+        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 = getWalletByChain(chain);
+    const walletAction = type === "checkOnly" ? wallet.isApproved : wallet.approve;
+    if (!walletAction) throw new USwapError("core_wallet_connection_not_found");
+
+    if (!(assetValue.address && wallet.address && typeof spenderAddress === "string")) {
+      throw new USwapError("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 Chain>(walletOption: WalletOption, chain: T): FullWallet[T] {
+    return connectedWalletsByWallet.get(walletOption)?.get(chain) as FullWallet[T];
+  }
+
+  function getWalletByChain<T extends ConnectedChains>(chain: T) {
+    return connectedWalletsByChain[chain];
+  }
+
+  function getSelectedWallet<T extends ConnectedChains>(chain: T): FullWallet[T] {
+    const selected = getActiveWallet?.();
+    if (!selected) {
+      throw new Error(`Unknown connected chain: ${chain}`);
+    }
+
+    return getWallet(selected, chain) as FullWallet[T];
+  }
+
+  function getAllWallets() {
+    return { ...connectedWalletsByChain };
+  }
+
+  function getAddress<T extends Chain>(chain: T) {
+    return getWalletByChain(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 = getWalletByChain(chain);
+    if (wallet?.walletType) {
+      const chainMap = connectedWalletsByWallet.get(wallet.walletType as WalletOption);
+      if (chainMap) {
+        chainMap.delete(chain);
+        if (chainMap.size === 0) {
+          connectedWalletsByWallet.delete(wallet.walletType as WalletOption);
+        }
+      }
+    }
+
+    wallet?.disconnect?.();
+    delete connectedWalletsByChain[chain];
+  }
+
+  function disconnectAll() {
+    for (const chain of Object.keys(connectedWalletsByChain) as (keyof typeof connectedWalletsByChain)[]) {
+      disconnectChain(chain);
+    }
+  }
+
+  function getBalance<T extends Chain, R extends boolean>(chain: T, refresh?: R): ConditionalAssetValueReturn<R> {
+    return (
+      refresh ? getWalletWithBalance(chain).then(({ balance }) => balance) : getWalletByChain(chain)?.balance || []
+    ) as ConditionalAssetValueReturn<R>;
+  }
+
+  async function getWalletWithBalance<T extends Chain>(chain: T, scamFilter = true) {
+    const wallet = getWalletByChain(chain);
+    if (!wallet) {
+      throw new USwapError("core_wallet_connection_not_found");
+    }
+    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 = getUSwapPlugin(pluginName || route.providers[0]);
+
+    if ("swap" in plugin) {
+      // @ts-expect-error TODO: fix this
+      return plugin.swap({ ...rest, route });
+    }
+
+    throw new USwapError("core_plugin_swap_not_found");
+  }
+
+  function transfer({ assetValue, ...params }: GenericTransferParams | EVMTransferParams) {
+    const chain = assetValue.chain;
+    if ([Chain.Radix].includes(chain) || !getWalletByChain(chain)) {
+      throw new USwapError("core_wallet_connection_not_found");
+    }
+    const wallet = getWalletByChain(chain as Exclude<Chain, typeof Chain.Radix | typeof 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 = getWalletByChain(chain);
+    if (!wallet) throw new USwapError("core_wallet_connection_not_found");
+
+    if ("signMessage" in wallet) {
+      return wallet.signMessage?.(message);
+    }
+
+    throw new USwapError({
+      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;
+  }) {
+    if (chain !== Chain.THORChain) {
+      throw new USwapError({ errorKey: "core_verify_message_not_supported", info: { chain } });
+    }
+
+    const { getCosmosToolbox } = await import("@tcswap/toolboxes/cosmos");
+    const toolbox = await getCosmosToolbox(chain);
+
+    return toolbox.verifySignature({ address, message, signature });
+  }
+
+  async function estimateTransactionFee<P extends PluginName, T extends ActionType>({
+    type,
+    feeOptionKey,
+    params,
+  }: {
+    type: T;
+    params: ActionParams<P>[T];
+    feeOptionKey: FeeOption;
+  }): Promise<AssetValue | undefined> {
+    const { assetValue } = params;
+    const { chain } = assetValue;
+
+    if (!getWalletByChain(chain as Chain)) throw new USwapError("core_wallet_connection_not_found");
+
+    const baseValue = AssetValue.from({ chain });
+    const { match } = await import("ts-pattern");
+
+    return match(chain as Chain)
+      .returnType<Promise<AssetValue | undefined> | AssetValue | undefined>()
+      .with(...EVMChains, (chain) => {
+        const { address, ...wallet } = getWalletByChain(chain);
+
+        const tx = match(type as ActionType)
+          .with("transfer", () => wallet.createTransferTx(params as EVMCreateTransactionParams))
+          .with("approve", (_t) => {
+            const { contractAddress } = params as ActionParams<P>[typeof _t];
+
+            return wallet.createApprovalTx({
+              amount: assetValue.getBaseValue("bigint"),
+              assetAddress: assetValue.address as string,
+              from: address,
+              spenderAddress: contractAddress,
+            });
+          })
+          .with("swap", (_t) => {
+            const {
+              route: {
+                providers: [plugin],
+                tx,
+              },
+            } = params as ActionParams<P>[typeof _t];
+
+            if (plugin && [PluginNameEnum.CHAINFLIP, PluginNameEnum.CHAINFLIP_STREAMING].includes(plugin)) {
+              return wallet.createTransferTx({ assetValue, recipient: address, sender: address });
+            }
+
+            const evmTx = tx as EVMTransaction;
+
+            return { ...evmTx, value: BigInt(evmTx.value) };
+          })
+          .otherwise(() => undefined);
+
+        if (!tx) return baseValue;
+
+        return wallet.estimateTransactionFee({ ...tx, chain, feeOption: feeOptionKey });
+      })
+      .with(...UTXOChains, (chain) => {
+        const { address, ...wallet } = getWalletByChain(chain);
+        return wallet.estimateTransactionFee({ ...params, feeOptionKey, recipient: address, sender: address });
+      })
+      .with(...CosmosChains, async () => {
+        const { estimateTransactionFee } = await import("@tcswap/toolboxes/cosmos");
+        return estimateTransactionFee(params);
+      })
+      .with(Chain.Polkadot, (chain) => {
+        const wallet = getWalletByChain(chain);
+        return wallet.estimateTransactionFee({ ...params, recipient: wallet.address });
+      })
+      .with(Chain.Tron, (chain) => {
+        const { address, ...wallet } = getWalletByChain(chain);
+        return wallet.estimateTransactionFee({ ...params, recipient: address, sender: address });
+      })
+      .with(Chain.Ripple, (chain) => getWalletByChain(chain).estimateTransactionFee())
+      .with(Chain.Ton, (chain) => getWalletByChain(chain).estimateTransactionFee())
+      .with(Chain.Cardano, (chain) => getWalletByChain(chain).estimateTransactionFee())
+      .with(Chain.Sui, (chain) => getWalletByChain(chain).estimateTransactionFee())
+      .otherwise(async () => baseValue);
+  }
+
+  return {
+    ...availablePlugins,
+    ...connectWalletMethods,
+
+    approveAssetValue,
+    disconnectAll,
+    disconnectChain,
+    estimateTransactionFee,
+    getAddress,
+    getAllWallets,
+    getBalance,
+    getWallet,
+    getWalletByChain,
+    getWalletWithBalance,
+    isAssetValueApproved,
+    signMessage,
+    swap,
+    transfer,
+    verifyMessage,
+  };
+}
+
+export * from "@tcswap/helpers";