@swapkit/plugins 4.2.9 → 4.6.18

package/src/chainflip/index.ts

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

package/src/chainflip/plugin.ts

@@ -1,52 +0,0 @@
-import { AssetValue, type Chain, ProviderName, SwapKitError } from "@swapkit/helpers";
-import { SwapKitApi } from "@swapkit/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 SwapKitError("core_swap_invalid_params", { ...swapParams });
-      }
-
-      const {
-        route: {
-          buyAsset: buyAssetString,
-          sellAsset: sellAssetString,
-          sellAmount,
-          meta: { chainflip },
-        },
-        maxBoostFeeBps = 0,
-      } = swapParams;
-
-      if (!(sellAssetString && buyAssetString)) {
-        throw new SwapKitError("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 SwapKitError("core_wallet_connection_not_found");
-      }
-
-      const { depositAddress } = await SwapKitApi.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: { supportedSwapkitProviders: [ProviderName.CHAINFLIP, ProviderName.CHAINFLIP_STREAMING] as const },
-});

package/src/chainflip/types.ts

@@ -1,37 +0,0 @@
-import type { AssetValue, SwapParams } from "@swapkit/helpers";
-import type { QuoteResponseRoute } from "@swapkit/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

@@ -1,45 +0,0 @@
-import {
-  ApproveMode,
-  AssetValue,
-  type EVMChain,
-  EVMChains,
-  ProviderName,
-  SwapKitError,
-  type SwapParams,
-} from "@swapkit/helpers";
-import type { EVMTransaction, QuoteResponseRoute } from "@swapkit/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 SwapKitError("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: {
-    supportedSwapkitProviders: [
-      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

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

package/src/garden/plugin.ts

@@ -1,54 +0,0 @@
-import { VersionedTransaction } from "@solana/web3.js";
-import {
-  ApproveMode,
-  AssetValue,
-  Chain,
-  EVMChains,
-  ProviderName,
-  SwapKitError,
-  type SwapParams,
-} from "@swapkit/helpers";
-import type { EVMTransaction, QuoteResponseRoute } from "@swapkit/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 SwapKitError("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: { supportedSwapkitProviders: [ProviderName.GARDEN] as const },
-});

package/src/index.ts

@@ -1,37 +0,0 @@
-import type { PluginName, SKPlugins } 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 SKPlugins[P];
-}

package/src/near/index.ts

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

package/src/near/nearNames.ts

@@ -1,37 +0,0 @@
-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";
-}

package/src/near/plugin.ts

@@ -1,216 +0,0 @@
-import { AssetValue, Chain, ProviderName, SwapKitError, type SwapParams } from "@swapkit/helpers";
-import type { QuoteResponseRoute } from "@swapkit/helpers/api";
-import type { NearWallet } from "@swapkit/toolboxes/near";
-import { createPlugin } from "../utils";
-import { calculateNearNameCost, validateNearName } from "./nearNames";
-import type { NearAccountInfo, NearNameRegistrationParams } from "./types";
-
-export const NearPlugin = createPlugin({
-  methods: ({ getWallet }) => ({
-    nearNames: {
-      async getInfo(name: string): Promise<NearAccountInfo | null> {
-        const normalizedName = name.toLowerCase().replace(/\.near$/, "");
-
-        if (!validateNearName(normalizedName)) {
-          throw new SwapKitError("plugin_near_invalid_name");
-        }
-
-        const accountId = `${normalizedName}.near`;
-        const wallet = getWallet(Chain.Near);
-
-        if (!wallet) {
-          throw new SwapKitError("plugin_near_no_connection");
-        }
-
-        try {
-          // Get account info
-          const accountInfo = await wallet.provider.query({
-            account_id: accountId,
-            finality: "final",
-            request_type: "view_account",
-          });
-
-          // Optionally get the account's public keys
-          const keysInfo = await wallet.provider.query({
-            account_id: accountId,
-            finality: "final",
-            request_type: "view_access_key_list",
-          });
-
-          return {
-            accountId,
-            balance: (accountInfo as any).amount,
-            codeHash: (accountInfo as any).code_hash,
-            publicKeys: (keysInfo as any).keys?.map((k: any) => k.public_key) || [],
-            storageUsed: (accountInfo as any).storage_usage,
-          };
-        } catch (err: any) {
-          if (/UNKNOWN_ACCOUNT|does not exist while viewing/.test(err.message)) {
-            return null;
-          }
-          throw err;
-        }
-      },
-
-      async isAvailable(name: string) {
-        const owner = await this.resolve(name);
-        return owner === null;
-      },
-
-      async lookupNames(accountId: string) {
-        // NEAR doesn't have a central registry to look up all names owned by an account
-        // This would require indexing or an external service
-        // For now, we can only check if a specific account exists
-        const wallet = getWallet(Chain.Near);
-
-        if (!wallet) {
-          throw new SwapKitError("plugin_near_no_connection");
-        }
-
-        try {
-          // Check if the account exists
-          await wallet.provider.query({ account_id: accountId, finality: "final", request_type: "view_account" });
-
-          // If the account ID ends with .near, it's a NEAR name
-          if (accountId.endsWith(".near")) {
-            return [accountId];
-          }
-
-          // Otherwise, we can't determine what names they own without an indexer
-          return [];
-        } catch {
-          return [];
-        }
-      },
-
-      async register(params: NearNameRegistrationParams) {
-        const { name, publicKey: publicKeyOverwrite } = params;
-        const normalizedName = name.toLowerCase().replace(/\.near$/, "");
-
-        if (!validateNearName(normalizedName)) {
-          throw new SwapKitError("plugin_near_invalid_name");
-        }
-
-        const wallet = getWallet(Chain.Near) as NearWallet;
-
-        const newPublicKey = publicKeyOverwrite || (await wallet.getPublicKey());
-
-        const cost = calculateNearNameCost(normalizedName);
-
-        return wallet.callFunction({
-          args: { new_account_id: `${normalizedName}.near`, new_public_key: newPublicKey },
-          contractId: "near",
-          deposit: cost,
-          methodName: "create_account",
-        });
-      },
-      async resolve(name: string) {
-        const normalizedName = name.toLowerCase().replace(/\.near$/, "");
-
-        if (!validateNearName(normalizedName)) {
-          throw new SwapKitError("plugin_near_invalid_name");
-        }
-
-        const accountId = `${normalizedName}.near`;
-        const wallet = getWallet(Chain.Near);
-
-        if (!wallet) {
-          throw new SwapKitError("plugin_near_no_connection");
-        }
-
-        try {
-          // Ask RPC whether the account exists
-          await wallet.provider.query({ account_id: accountId, finality: "final", request_type: "view_account" });
-          // If no error is thrown, the account exists
-          return accountId; // Account is taken, return the account ID as "owner"
-        } catch (err: any) {
-          // UNKNOWN_ACCOUNT means it hasn't been created yet → available
-          if (/UNKNOWN_ACCOUNT|does not exist while viewing/.test(err.message)) {
-            return null;
-          }
-          // Re-throw any unexpected errors
-          throw err;
-        }
-      },
-
-      transfer(name: string, newOwner: string) {
-        const normalizedName = name.toLowerCase().replace(/\.near$/, "");
-
-        if (!validateNearName(normalizedName)) {
-          throw new SwapKitError("plugin_near_invalid_name");
-        }
-
-        const wallet = getWallet(Chain.Near) as NearWallet;
-
-        return wallet.callFunction({
-          args: { name: normalizedName, new_owner: newOwner },
-          contractId: "near",
-          deposit: "1",
-          methodName: "transfer",
-        });
-      },
-    },
-    async swap(swapParams: SwapParams<"near", QuoteResponseRoute>) {
-      const {
-        route: {
-          buyAsset: buyAssetString,
-          sellAsset: sellAssetString,
-          inboundAddress,
-          sellAmount,
-          meta: { near },
-        },
-      } = swapParams;
-
-      if (!(sellAssetString && buyAssetString && near?.sellAsset)) {
-        throw new SwapKitError("core_swap_asset_not_recognized");
-      }
-
-      if (!inboundAddress) {
-        throw new SwapKitError("core_swap_invalid_params", { missing: ["inboundAddress"] });
-      }
-
-      const sellAsset = await AssetValue.from({ asset: sellAssetString, value: sellAmount });
-
-      const sellAssetChain = sellAsset.chain;
-
-      const wallet = getWallet(sellAsset.chain as Exclude<Chain, typeof Chain.Radix>);
-
-      if (sellAssetChain === Chain.Near && !sellAsset.isGasAsset) {
-        const wallet = getWallet(sellAsset.chain as Chain.Near);
-        if (!wallet) {
-          throw new SwapKitError("core_wallet_connection_not_found");
-        }
-
-        const unsignedTransaction = await wallet.createContractFunctionCall({
-          args: {
-            amount: sellAsset.getBaseValue("string"),
-            msg: JSON.stringify({ receiver_id: inboundAddress }),
-            receiver_id: "intents.near",
-          },
-          attachedDeposit: "1",
-          contractId: sellAsset.address as string,
-          gas: "250000000000000",
-          methodName: "ft_transfer_call",
-          sender: wallet.address,
-        });
-
-        return wallet.signAndSendTransaction(unsignedTransaction);
-      }
-
-      if (!wallet) {
-        throw new SwapKitError("core_wallet_connection_not_found");
-      }
-
-      const tx = await wallet.transfer({
-        assetValue: sellAsset,
-        isProgramDerivedAddress: true,
-        recipient: inboundAddress,
-        sender: wallet.address,
-      });
-
-      return tx as string;
-    },
-  }),
-  name: "near",
-  properties: { supportedSwapkitProviders: [ProviderName.NEAR] as const },
-});

package/src/near/types.ts

@@ -1,9 +0,0 @@
-export type NearAccountInfo = {
-  accountId: string;
-  balance: string;
-  storageUsed: number;
-  codeHash: string;
-  publicKeys: string[];
-};
-
-export type NearNameRegistrationParams = { name: string; publicKey?: string };

package/src/radix/index.ts

@@ -1,24 +0,0 @@
-import { AssetValue, Chain, ProviderName, SwapKitError, type SwapParams } from "@swapkit/helpers";
-import type { QuoteResponseRoute } from "@swapkit/helpers/api";
-import { createPlugin } from "../utils";
-
-export const RadixPlugin = createPlugin({
-  methods: ({ getWallet }) => ({
-    swap: async function radixSwap({ route: { tx, sellAmount, sellAsset } }: SwapParams<"radix", QuoteResponseRoute>) {
-      const assetValue = await AssetValue.from({ asset: sellAsset, asyncTokenLookup: true, value: sellAmount });
-
-      if (Chain.Radix !== assetValue.chain) {
-        throw new SwapKitError("core_swap_invalid_params");
-      }
-
-      const wallet = getWallet(assetValue.chain);
-      try {
-        return wallet.signAndBroadcast({ manifest: tx as string });
-      } catch (error) {
-        throw new SwapKitError("core_swap_invalid_params", error);
-      }
-    },
-  }),
-  name: "radix",
-  properties: { supportedSwapkitProviders: [ProviderName.CAVIAR_V1] as const },
-});

package/src/solana/index.ts

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

package/src/solana/plugin.ts

@@ -1,26 +0,0 @@
-import { AssetValue, Chain, ProviderName, SwapKitError, type SwapParams } from "@swapkit/helpers";
-import type { QuoteResponseRoute } from "@swapkit/helpers/api";
-import { createPlugin } from "../utils";
-
-export const SolanaPlugin = createPlugin({
-  methods: ({ getWallet }) => ({
-    swap: async function solanaSwap({ route }: SwapParams<"solana", QuoteResponseRoute>) {
-      const { VersionedTransaction } = await import("@solana/web3.js");
-      const { tx, sellAsset } = route;
-
-      const assetValue = await AssetValue.from({ asset: sellAsset });
-
-      const chain = assetValue.chain;
-      if (!(chain === Chain.Solana && tx)) throw new SwapKitError("core_swap_invalid_params");
-
-      const wallet = getWallet(chain);
-      const transaction = VersionedTransaction.deserialize(Buffer.from(tx as string, "base64"));
-
-      const signedTransaction = await wallet.signTransaction(transaction);
-
-      return wallet.broadcastTransaction(signedTransaction);
-    },
-  }),
-  name: "solana",
-  properties: { supportedSwapkitProviders: [ProviderName.JUPITER] as const },
-});

package/src/thorchain/index.ts

@@ -1,3 +0,0 @@
-export { MayachainPlugin, ThorchainPlugin } from "./plugin";
-export { validateAddressType } from "./shared";
-export * from "./types";