@tcswap/plugins 4.2.15

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,mBAAmB,CAAC;AAEvC,MAAM,MAAM,YAAY,GAAG,OAAO,eAAe,GAC/C,OAAO,eAAe,GACtB,OAAO,WAAW,GAClB,OAAO,YAAY,GACnB,OAAO,SAAS,GAChB,OAAO,UAAU,CAAC;AAEpB,MAAM,MAAM,UAAU,GAAG,MAAM,YAAY,CAAC;AAE5C,MAAM,MAAM,mBAAmB,GAAG;IAAE,SAAS,EAAE,CAAC,CAAC,SAAS,KAAK,EAAE,KAAK,EAAE,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC"}

package/dist/types/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+import type { ApproveMode, ApproveReturnType, ProviderName } from "@tcswap/helpers";
+import { type AssetValue } from "@tcswap/helpers";
+import type { SwapKitPluginParams } from "./types";
+export declare function createPlugin<const Name extends string, T extends (params: SwapKitPluginParams) => Record<string, unknown>, K extends {
+    supportedUSwapProviders?: readonly ProviderName[];
+}>({ name, properties, methods }: {
+    name: Name;
+    properties?: K;
+    methods: T;
+}): { [key in Name]: (pluginParams: SwapKitPluginParams) => K & ReturnType<T>; };
+export declare function approve<T extends ApproveMode>({ approveMode, getWallet }: {
+    approveMode: T;
+} & SwapKitPluginParams): ({ assetValue, spenderAddress }: {
+    spenderAddress: string;
+    assetValue: AssetValue;
+}) => Promise<string> | Promise<boolean> | ApproveReturnType<T>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAY,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC9F,OAAO,EAAE,KAAK,UAAU,EAAyB,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,MAAM,EACzB,CAAC,SAAS,CAAC,MAAM,EAAE,mBAAmB,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClE,CAAC,SAAS;IAAE,uBAAuB,CAAC,EAAE,SAAS,YAAY,EAAE,CAAA;CAAE,EAC/D,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,CAAC,CAAA;CAAE,GAK5C,GAAG,GAAG,IAAI,IAAI,kBAJb,mBAAmB,KACO,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAGZ,CAC9D;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,WAAW,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,EAAE;IAAE,WAAW,EAAE,CAAC,CAAA;CAAE,GAAG,mBAAmB,IACzF,gCAAgC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,+DAwB3G"}

package/package.json

@@ -0,0 +1,88 @@
+{
+  "author": "swapkit-oss",
+  "dependencies": {
+    "@near-js/utils": "~2.5.0",
+    "@polkadot/keyring": "~13.5.7",
+    "@polkadot/util": "~13.5.7",
+    "@solana/web3.js": "~1.98.0",
+    "@tcswap/helpers": "4.5.15",
+    "@tcswap/toolboxes": "4.3.15",
+    "ts-pattern": "^5.9.0"
+  },
+  "description": "USwap Plugin - Chainflip",
+  "devDependencies": {
+    "@near-js/utils": "2.5.0",
+    "@polkadot/keyring": "13.5.7",
+    "@polkadot/util": "13.5.7",
+    "@solana/web3.js": "1.98.4",
+    "ts-pattern": "5.9.0"
+  },
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./chainflip": {
+      "bun": "./src/chainflip/index.ts",
+      "default": "./dist/chainflip/index.js",
+      "require": "./dist/chainflip/index.cjs",
+      "types": "./dist/types/chainflip/index.d.ts"
+    },
+    "./evm": {
+      "bun": "./src/evm/index.ts",
+      "default": "./dist/evm/index.js",
+      "require": "./dist/evm/index.cjs",
+      "types": "./dist/types/evm/index.d.ts"
+    },
+    "./garden": {
+      "bun": "./src/garden/index.ts",
+      "default": "./dist/garden/index.js",
+      "require": "./dist/garden/index.cjs",
+      "types": "./dist/types/garden/index.d.ts"
+    },
+    "./near": {
+      "bun": "./src/near/index.ts",
+      "default": "./dist/near/index.js",
+      "require": "./dist/near/index.cjs",
+      "types": "./dist/types/near/index.d.ts"
+    },
+    "./radix": {
+      "bun": "./src/radix/index.ts",
+      "default": "./dist/radix/index.js",
+      "require": "./dist/radix/index.cjs",
+      "types": "./dist/types/radix/index.d.ts"
+    },
+    "./solana": {
+      "bun": "./src/solana/index.ts",
+      "default": "./dist/solana/index.js",
+      "require": "./dist/solana/index.cjs",
+      "types": "./dist/types/solana/index.d.ts"
+    },
+    "./thorchain": {
+      "bun": "./src/thorchain/index.ts",
+      "default": "./dist/thorchain/index.js",
+      "require": "./dist/thorchain/index.cjs",
+      "types": "./dist/types/thorchain/index.d.ts"
+    }
+  },
+  "files": ["dist/", "src/"],
+  "homepage": "https://github.com/thorchain/TCSwap",
+  "license": "Apache-2.0",
+  "name": "@tcswap/plugins",
+  "repository": {
+    "directory": "packages/plugins",
+    "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",
+    "type-check": "bun tsc --noEmit",
+    "type-check:go": "tsgo"
+  },
+  "type": "module",
+  "version": "4.2.15"
+}

package/src/chainflip/broker.ts

@@ -0,0 +1,116 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { decodeAddress } from "@polkadot/keyring";
+import { isHex, u8aToHex } from "@polkadot/util";
+import { AssetValue, Chain, USwapError, wrapWithThrow } from "@tcswap/helpers";
+import type { getEvmToolbox } from "@tcswap/toolboxes/evm";
+import type { getSubstrateToolbox } from "@tcswap/toolboxes/substrate";
+
+import type { WithdrawFeeResponse } from "./types";
+
+type ChainflipToolbox = Awaited<ReturnType<typeof getSubstrateToolbox<typeof Chain.Chainflip>>>;
+
+export const assetIdentifierToChainflipTicker = new Map<string, string>([
+  ["ARB.ETH", "ArbEth"],
+  ["ARB.USDC-0XAF88D065E77C8CC2239327C5EDB3A432268E5831", "ArbUsdc"],
+  ["BTC.BTC", "Btc"],
+  ["DOT.DOT", "Dot"],
+  ["ETH.ETH", "Eth"],
+  ["ETH.FLIP-0X826180541412D574CF1336D22C0C0A287822678A", "Flip"],
+  ["ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48", "Usdc"],
+  ["ETH.USDT-0XDAC17F958D2EE523A2206206994597C13D831EC7", "Usdt"],
+  ["SOL.SOL", "Sol"],
+  ["SOL.USDC-EPJFWDD5AUFQSSQEM2QN1XZYBAPC8G4WEGGKZWYTDT1V", "SolUsdc"],
+]);
+
+const registerAsBroker = (toolbox: ChainflipToolbox) => () => {
+  const extrinsic = toolbox.api.tx.swapping?.registerAsBroker?.();
+
+  if (!extrinsic) {
+    throw new USwapError("chainflip_broker_register");
+  }
+
+  return toolbox.signAndBroadcast({ address: toolbox.getAddress(), tx: extrinsic });
+};
+
+const withdrawFee =
+  (toolbox: ChainflipToolbox) =>
+  ({ feeAsset, recipient }: { feeAsset: AssetValue; recipient: string }) => {
+    const isFeeChainPolkadot = feeAsset.chain === Chain.Polkadot;
+
+    const recipientAddress = wrapWithThrow(() => {
+      return isFeeChainPolkadot ? toolbox.encodeAddress(toolbox.decodeAddress(recipient), "hex") : recipient;
+    }, "chainflip_broker_recipient_error");
+
+    return new Promise<WithdrawFeeResponse>((resolve) => {
+      const extrinsic = toolbox.api.tx?.swapping?.withdraw?.(feeAsset.ticker.toLowerCase(), {
+        [feeAsset.chain.toLowerCase()]: recipientAddress,
+      });
+
+      if (!extrinsic) {
+        throw new USwapError("chainflip_broker_withdraw");
+      }
+
+      toolbox.signAndBroadcast({
+        callback: (result) => {
+          if (!result.status?.isFinalized) {
+            return;
+          }
+
+          const withdrawEvent = result.events.find((event) => event.event.method === "WithdrawalRequested");
+
+          if (!withdrawEvent) {
+            throw new USwapError("chainflip_channel_error", "Could not find 'WithdrawalRequested' event");
+          }
+          const {
+            event: {
+              data: { egressId, egressAsset, egressAmount, egressFee, destinationAddress },
+            },
+          } = withdrawEvent.toHuman() as any;
+          resolve({ destinationAddress, egressAmount, egressAsset, egressFee, egressId });
+        },
+        tx: extrinsic,
+      });
+    });
+  };
+
+const fundStateChainAccount =
+  (chainflipToolbox: ChainflipToolbox) =>
+  async ({
+    evmToolbox,
+    stateChainAccount,
+    assetValue,
+  }: {
+    evmToolbox: Awaited<ReturnType<typeof getEvmToolbox>>;
+    stateChainAccount: string;
+    assetValue: AssetValue;
+  }) => {
+    const { chainflipGateway } = await import("@tcswap/helpers/contracts");
+
+    const flipAssetValue = AssetValue.from({ asset: "ETH.FLIP" });
+
+    if (!assetValue.eqAsset(flipAssetValue)) {
+      throw new USwapError("chainflip_broker_fund_only_flip_supported");
+    }
+
+    if (!chainflipToolbox.validateAddress(stateChainAccount)) {
+      throw new USwapError("chainflip_broker_fund_invalid_address");
+    }
+
+    const hexAddress = isHex(stateChainAccount) ? stateChainAccount : u8aToHex(decodeAddress(stateChainAccount));
+
+    return evmToolbox.call<string>({
+      abi: chainflipGateway,
+      contractAddress: "0x6995ab7c4d7f4b03f467cf4c8e920427d9621dbd",
+      funcName: "fundStateChainAccount",
+      funcParams: [hexAddress, assetValue.getBaseValue("string")],
+    });
+  };
+
+export const ChainflipBroker = (chainflipToolbox: ChainflipToolbox) => ({
+  fundStateChainAccount: fundStateChainAccount(chainflipToolbox),
+  registerAsBroker: registerAsBroker(chainflipToolbox),
+  withdrawFee: withdrawFee(chainflipToolbox),
+});

package/src/chainflip/index.ts

@@ -0,0 +1,3 @@
+export * from "./broker";
+export * from "./plugin";
+export * from "./types";

package/src/chainflip/plugin.ts

@@ -0,0 +1,56 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { AssetValue, type Chain, ProviderName, USwapError } from "@tcswap/helpers";
+import { USwapApi } from "@tcswap/helpers/api";
+import { createPlugin } from "../utils";
+import type { RequestSwapDepositAddressParams } from "./types";
+
+export const ChainflipPlugin = createPlugin({
+  methods: ({ getWallet }) => ({
+    swap: async function chainflipSwap(swapParams: RequestSwapDepositAddressParams) {
+      if (!(swapParams?.route?.buyAsset && swapParams.route.meta?.chainflip)) {
+        throw new USwapError("core_swap_invalid_params", { ...swapParams });
+      }
+
+      const {
+        route: {
+          buyAsset: buyAssetString,
+          sellAsset: sellAssetString,
+          sellAmount,
+          meta: { chainflip },
+        },
+        maxBoostFeeBps = 0,
+      } = swapParams;
+
+      if (!(sellAssetString && buyAssetString)) {
+        throw new USwapError("core_swap_asset_not_recognized");
+      }
+
+      const sellAsset = await AssetValue.from({ asset: sellAssetString, asyncTokenLookup: true, value: sellAmount });
+
+      const wallet = getWallet(sellAsset.chain as Exclude<Chain, Chain.Radix>);
+
+      if (!wallet || !("transfer" in wallet)) {
+        throw new USwapError("core_wallet_connection_not_found");
+      }
+
+      const { depositAddress } = await USwapApi.getChainflipDepositChannel({
+        ...chainflip,
+        maxBoostFeeBps: maxBoostFeeBps || chainflip.maxBoostFeeBps,
+      });
+
+      const tx = await wallet.transfer({
+        assetValue: sellAsset,
+        isProgramDerivedAddress: true,
+        recipient: depositAddress,
+        sender: wallet.address,
+      });
+
+      return tx;
+    },
+  }),
+  name: "chainflip",
+  properties: { supportedUSwapProviders: [ProviderName.CHAINFLIP, ProviderName.CHAINFLIP_STREAMING] as const },
+});

package/src/chainflip/types.ts

@@ -0,0 +1,37 @@
+import type { AssetValue, SwapParams } from "@tcswap/helpers";
+import type { QuoteResponseRoute } from "@tcswap/helpers/api";
+
+export type WithdrawFeeResponse = {
+  egressId: string;
+  egressAsset: string;
+  egressAmount: string;
+  egressFee: string;
+  destinationAddress: string;
+};
+
+export type DepositChannelRequest = {
+  brokerCommissionBPS: number;
+  ccmMetadata: ccmMetadata | null;
+  maxBoostFeeBps?: number;
+  affiliateFees?: AffiliateBroker[];
+  refundParameters?: SwapRefundParameters;
+};
+
+export type ccmMetadata = { message: string; gasBudget: string; cfParameters: string };
+
+export type SwapDepositResponse = {
+  depositChannelId: string;
+  depositAddress: string;
+  srcChainExpiryBlock: number;
+  sellAsset: AssetValue;
+  buyAsset: AssetValue;
+  recipient: string;
+  brokerCommissionBPS: number;
+};
+
+export type AffiliateBroker = { brokerAddress: string; basisPoints: number };
+
+export type SwapRefundParameters = { retryDuration: number; refundAddress: string; minPrice: string };
+
+export type RequestSwapDepositAddressParams = Partial<SwapParams<"chainflip", QuoteResponseRoute>> &
+  Partial<DepositChannelRequest>;

package/src/evm/index.ts

@@ -0,0 +1,49 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import {
+  ApproveMode,
+  AssetValue,
+  type EVMChain,
+  EVMChains,
+  ProviderName,
+  type SwapParams,
+  USwapError,
+} from "@tcswap/helpers";
+import type { EVMTransaction, QuoteResponseRoute } from "@tcswap/helpers/api";
+import { approve, createPlugin } from "../utils";
+
+export const EVMPlugin = createPlugin({
+  methods: ({ getWallet }) => ({
+    approveAssetValue: approve({ approveMode: ApproveMode.Approve, getWallet }),
+    isAssetValueApproved: approve({ approveMode: ApproveMode.CheckOnly, getWallet }),
+    swap: async function evmSwap({ route: { tx, sellAsset }, feeOptionKey }: SwapParams<"evm", QuoteResponseRoute>) {
+      const assetValue = await AssetValue.from({ asset: sellAsset, asyncTokenLookup: true });
+      const evmChain = assetValue.chain as EVMChain;
+      const wallet = getWallet(evmChain);
+
+      if (!(EVMChains.includes(evmChain) && tx)) {
+        throw new USwapError("core_swap_invalid_params");
+      }
+
+      const { from, to, data, value } = tx as EVMTransaction;
+      return wallet.sendTransaction({ data, feeOptionKey, from, to, value: BigInt(value) });
+    },
+  }),
+  name: "evm",
+  properties: {
+    supportedUSwapProviders: [
+      ProviderName.CAMELOT_V3,
+      ProviderName.OPENOCEAN_V2,
+      ProviderName.OKX,
+      ProviderName.ONEINCH,
+      ProviderName.PANCAKESWAP,
+      ProviderName.PANGOLIN_V1,
+      ProviderName.SUSHISWAP_V2,
+      ProviderName.TRADERJOE_V2,
+      ProviderName.UNISWAP_V2,
+      ProviderName.UNISWAP_V3,
+    ] as const,
+  },
+});

package/src/garden/index.ts

@@ -0,0 +1 @@
+export { GardenPlugin } from "./plugin";

package/src/garden/plugin.ts

@@ -0,0 +1,50 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import { VersionedTransaction } from "@solana/web3.js";
+import { ApproveMode, AssetValue, Chain, EVMChains, ProviderName, type SwapParams, USwapError } from "@tcswap/helpers";
+import type { EVMTransaction, QuoteResponseRoute } from "@tcswap/helpers/api";
+import { match } from "ts-pattern";
+import { approve, createPlugin } from "../utils";
+
+export const GardenPlugin = createPlugin({
+  methods: ({ getWallet }) => ({
+    approveAssetValue: approve({ approveMode: ApproveMode.Approve, getWallet }),
+    isAssetValueApproved: approve({ approveMode: ApproveMode.CheckOnly, getWallet }),
+    swap: function gardenSwap({ route }: SwapParams<"garden", QuoteResponseRoute>) {
+      const { sellAsset, sellAmount, targetAddress, tx } = route;
+
+      const sellAssetValue = AssetValue.from({ asset: sellAsset, value: sellAmount });
+
+      return match(sellAssetValue.chain as Chain)
+        .returnType<Promise<string>>()
+        .with(...EVMChains, (chain) => {
+          const wallet = getWallet(chain);
+
+          const { from, to, data, value } = tx as EVMTransaction;
+          return wallet.sendTransaction({ data, from, to, value: BigInt(value) });
+        })
+        .with(Chain.Solana, async (chain) => {
+          const wallet = getWallet(chain);
+          const transaction = VersionedTransaction.deserialize(Buffer.from(tx as string, "base64"));
+
+          const signedTransaction = await wallet.signTransaction(transaction);
+
+          return wallet.broadcastTransaction(signedTransaction);
+        })
+        .otherwise(async (chain) => {
+          if (!targetAddress) {
+            throw new USwapError("plugin_garden_missing_data", { message: "Missing target address: " });
+          }
+          const wallet = getWallet(chain as Exclude<Chain, Chain.Radix>);
+
+          const txHash = await wallet.transfer({ assetValue: sellAssetValue, recipient: targetAddress });
+
+          return txHash;
+        });
+    },
+  }),
+  name: "garden",
+  properties: { supportedUSwapProviders: [ProviderName.GARDEN] as const },
+});

package/src/index.ts

@@ -0,0 +1,41 @@
+/**
+ * Modifications © 2025 Horizontal Systems.
+ */
+
+import type { PluginName, USwapPlugins } from "./types";
+
+export * from "./types";
+export * from "./utils";
+
+export async function loadPlugin<P extends PluginName>(pluginName: P) {
+  const { match } = await import("ts-pattern");
+
+  const plugin = await match(pluginName as PluginName)
+    .with("chainflip", async () => {
+      const { ChainflipPlugin } = await import("./chainflip");
+      return ChainflipPlugin;
+    })
+    .with("thorchain", async () => {
+      const { ThorchainPlugin } = await import("./thorchain");
+      return ThorchainPlugin;
+    })
+    .with("radix", async () => {
+      const { RadixPlugin } = await import("./radix");
+      return RadixPlugin;
+    })
+    .with("evm", async () => {
+      const { EVMPlugin } = await import("./evm");
+      return EVMPlugin;
+    })
+    .with("solana", async () => {
+      const { SolanaPlugin } = await import("./solana");
+      return SolanaPlugin;
+    })
+    .with("near", async () => {
+      const { NearPlugin } = await import("./near");
+      return NearPlugin;
+    })
+    .exhaustive();
+
+  return plugin as unknown as USwapPlugins[P];
+}

package/src/near/index.ts

@@ -0,0 +1,2 @@
+export * from "./plugin";
+export * from "./types";

package/src/near/nearNames.ts

@@ -0,0 +1,37 @@
+import { parseNearAmount } from "@near-js/utils";
+
+const MINIMUM_NAME_LENGTH = 2;
+const MAXIMUM_NAME_LENGTH = 64;
+
+export function validateNearName(name: string): boolean {
+  if (name.length < MINIMUM_NAME_LENGTH || name.length > MAXIMUM_NAME_LENGTH) {
+    return false;
+  }
+
+  // Only lowercase letters, numbers, and hyphens
+  // Cannot start or end with hyphen
+  // No consecutive hyphens
+  return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(name);
+}
+
+export function calculateNearNameCost(name: string): string {
+  // Pricing based on name length
+  // These are suggested prices, the actual minimum is ~0.00182 NEAR
+  const length = name.length;
+
+  let costInNear: string;
+  if (length <= 2) {
+    costInNear = "50"; // 50 NEAR for 2-char names
+  } else if (length <= 3) {
+    costInNear = "20"; // 20 NEAR for 3-char names
+  } else if (length <= 4) {
+    costInNear = "5"; // 5 NEAR for 4-char names
+  } else if (length <= 5) {
+    costInNear = "1"; // 1 NEAR for 5-char names
+  } else {
+    costInNear = "0.1"; // 0.1 NEAR for 6+ characters
+  }
+
+  // Convert NEAR to yoctoNEAR
+  return parseNearAmount(costInNear) || "0";
+}