@swapkit/plugins 4.0.0-beta.50 → 4.0.0-beta.52

package/src/chainflip/types.ts

@@ -1,48 +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,82 +0,0 @@
-import {
-  ApproveMode,
-  type ApproveReturnType,
-  AssetValue,
-  type EVMChain,
-  EVMChains,
-  ProviderName,
-  SwapKitError,
-  type SwapKitPluginParams,
-  type SwapParams,
-  createPlugin,
-} from "@swapkit/helpers";
-import type { EVMTransaction, QuoteResponseRoute } from "@swapkit/helpers/api";
-
-function approve<T extends ApproveMode>({
-  approveMode,
-  getWallet,
-}: { approveMode: T } & SwapKitPluginParams) {
-  return function approveEVM({
-    assetValue,
-    spenderAddress,
-  }: { spenderAddress: string; assetValue: AssetValue }) {
-    const evmChain = assetValue.chain as EVMChain;
-    const isEVMChain = EVMChains.includes(evmChain);
-    const isNativeEVM = isEVMChain && assetValue.isGasAsset;
-
-    if (isNativeEVM || !isEVMChain || assetValue.isSynthetic) {
-      const isApproved = approveMode === "checkOnly" || "approved";
-      return Promise.resolve(isApproved) as ApproveReturnType<T>;
-    }
-
-    const wallet = getWallet(evmChain);
-    const walletAction = approveMode === "checkOnly" ? wallet.isApproved : wallet.approve;
-
-    if (!(assetValue.address && wallet.address)) {
-      throw new SwapKitError("core_approve_asset_address_or_from_not_found");
-    }
-
-    return walletAction({
-      amount: assetValue.getBaseValue("bigint"),
-      assetAddress: assetValue.address,
-      from: wallet.address,
-      spenderAddress,
-    });
-  };
-}
-
-export const EVMPlugin = createPlugin({
-  name: "evm",
-  properties: {
-    supportedSwapkitProviders: [
-      ProviderName.CAMELOT_V3,
-      ProviderName.OPENOCEAN_V2,
-      ProviderName.ONEINCH,
-      ProviderName.PANCAKESWAP,
-      ProviderName.PANGOLIN_V1,
-      ProviderName.SUSHISWAP_V2,
-      ProviderName.TRADERJOE_V2,
-      ProviderName.UNISWAP_V2,
-      ProviderName.UNISWAP_V3,
-    ],
-  },
-  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({ from, to, data, value: BigInt(value), feeOptionKey });
-    },
-  }),
-});

package/src/near/nearNames.ts

@@ -1,37 +0,0 @@
-import { parseNearAmount } from "near-api-js/lib/utils/format";
-
-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,192 +0,0 @@
-import {
-  AssetValue,
-  Chain,
-  type CryptoChain,
-  ProviderName,
-  SwapKitError,
-  type SwapParams,
-  createPlugin,
-} from "@swapkit/helpers";
-import { type QuoteResponseRoute, SwapKitApi } from "@swapkit/helpers/api";
-import type { NearWallet } from "@swapkit/toolboxes/near";
-import { calculateNearNameCost, validateNearName } from "./nearNames";
-import type { NearNameRegistrationParams } from "./types";
-
-export const NearPlugin = createPlugin({
-  name: "near",
-  properties: {
-    supportedSwapkitProviders: [ProviderName.NEAR],
-  },
-  methods: ({ getWallet }) => ({
-    async swap(swapParams: SwapParams<"near", QuoteResponseRoute>) {
-      const {
-        route: {
-          buyAsset: buyAssetString,
-          sellAsset: sellAssetString,
-          sellAmount,
-          meta: { near },
-        },
-      } = swapParams;
-
-      if (!(sellAssetString && buyAssetString && near?.sellAsset)) {
-        throw new SwapKitError("core_swap_asset_not_recognized");
-      }
-
-      const sellAsset = await AssetValue.from({
-        asyncTokenLookup: true,
-        asset: sellAssetString,
-        value: sellAmount,
-      });
-
-      const wallet = getWallet(sellAsset.chain as Exclude<CryptoChain, Chain.Radix>);
-
-      if (!wallet) {
-        throw new SwapKitError("core_wallet_connection_not_found");
-      }
-
-      const { depositAddress } = await SwapKitApi.getNearDepositChannel(near);
-
-      const tx = await wallet.transfer({
-        assetValue: sellAsset,
-        recipient: depositAddress,
-        isProgramDerivedAddress: true,
-      });
-
-      return tx as string;
-    },
-
-    // NEAR Names functionality
-    nearNames: {
-      async resolve(name: string) {
-        try {
-          const normalizedName = name.toLowerCase().replace(/\.near$/, "");
-
-          if (!validateNearName(normalizedName)) {
-            throw new SwapKitError("plugin_near_invalid_name");
-          }
-
-          const wallet = getWallet(Chain.Near);
-
-          if (!wallet) {
-            throw new SwapKitError("plugin_near_no_connection");
-          }
-
-          const result = await wallet.provider.query({
-            request_type: "call_function",
-            finality: "final",
-            account_id: "near",
-            method_name: "resolve",
-            args_base64: Buffer.from(JSON.stringify({ name: normalizedName })).toString("base64"),
-          });
-
-          const response = JSON.parse(Buffer.from((result as any).result).toString());
-          return response?.owner || null;
-        } catch {
-          return null;
-        }
-      },
-
-      async isAvailable(name: string) {
-        const owner = await this.resolve(name);
-        return owner === null;
-      },
-
-      async getInfo(name: string) {
-        try {
-          const normalizedName = name.toLowerCase().replace(/\.near$/, "");
-
-          if (!validateNearName(normalizedName)) {
-            throw new SwapKitError("plugin_near_invalid_name");
-          }
-
-          const wallet = getWallet(Chain.Near);
-
-          if (!wallet) {
-            throw new SwapKitError("plugin_near_no_connection");
-          }
-
-          const result = await wallet.provider.query({
-            request_type: "call_function",
-            finality: "final",
-            account_id: "near",
-            method_name: "get_info",
-            args_base64: Buffer.from(JSON.stringify({ name: normalizedName })).toString("base64"),
-          });
-
-          const response = JSON.parse(Buffer.from((result as any).result).toString());
-          return response || null;
-        } catch {
-          return null;
-        }
-      },
-
-      async lookupNames(accountId: string) {
-        try {
-          const wallet = getWallet(Chain.Near);
-
-          if (!wallet) {
-            throw new SwapKitError("plugin_near_no_connection");
-          }
-
-          const result = await wallet.provider.query({
-            request_type: "call_function",
-            finality: "final",
-            account_id: "near",
-            method_name: "get_names_by_owner",
-            args_base64: Buffer.from(JSON.stringify({ account_id: accountId })).toString("base64"),
-          });
-
-          const response = JSON.parse(Buffer.from((result as any).result).toString());
-          return Array.isArray(response) ? response.map((n) => `${n}.near`) : [];
-        } 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({
-          contractId: "near",
-          methodName: "create_account",
-          args: {
-            new_account_id: `${normalizedName}.near`,
-            new_public_key: newPublicKey,
-          },
-          deposit: cost,
-        });
-      },
-
-      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({
-          contractId: "near",
-          methodName: "transfer",
-          args: {
-            name: normalizedName,
-            new_owner: newOwner,
-          },
-          deposit: "1",
-        });
-      },
-    },
-  }),
-});

package/src/near/types.ts

@@ -1,11 +0,0 @@
-export type NearNameInfo = {
-  owner: string;
-  price?: string;
-  expiresAt?: string;
-  registeredAt?: string;
-};
-
-export type NearNameRegistrationParams = {
-  name: string;
-  publicKey?: string;
-};

package/src/radix/index.ts

@@ -1,36 +0,0 @@
-import {
-  AssetValue,
-  Chain,
-  ProviderName,
-  SwapKitError,
-  type SwapParams,
-  createPlugin,
-} from "@swapkit/helpers";
-import type { QuoteResponseRoute } from "@swapkit/helpers/api";
-
-export const RadixPlugin = createPlugin({
-  name: "radix",
-  properties: { supportedSwapkitProviders: [ProviderName.CAVIAR_V1] },
-  methods: ({ getWallet }) => ({
-    swap: async function radixSwap({
-      route: { tx, sellAmount, sellAsset },
-    }: SwapParams<"radix", QuoteResponseRoute>) {
-      const assetValue = await AssetValue.from({
-        asyncTokenLookup: true,
-        value: sellAmount,
-        asset: sellAsset,
-      });
-
-      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);
-      }
-    },
-  }),
-});

package/src/solana/plugin.ts

@@ -1,36 +0,0 @@
-import {
-  AssetValue,
-  Chain,
-  ProviderName,
-  SwapKitError,
-  type SwapParams,
-  createPlugin,
-} from "@swapkit/helpers";
-import type { QuoteResponseRoute } from "@swapkit/helpers/api";
-
-export const SolanaPlugin = createPlugin({
-  name: "solana",
-  properties: {
-    supportedSwapkitProviders: [ProviderName.JUPITER],
-  },
-  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);
-    },
-  }),
-});