@swapkit/plugins 0.0.0-nightly-20250304130539

package/src/kado/plugin.ts

@@ -0,0 +1,234 @@
+import {
+  AssetValue,
+  Chain,
+  ProviderName,
+  RequestClient,
+  SKConfig,
+  type SwapParams,
+  createPlugin,
+  warnOnce,
+} from "@swapkit/helpers";
+import type { QuoteResponse, QuoteResponseRoute } from "@swapkit/helpers/api";
+import { ChainToKadoChain, mapKadoQuoteToQuoteResponse } from "./helpers";
+import type {
+  KadoAssetsResponse,
+  KadoBlockchainsResponse,
+  KadoFiatCurrency,
+  KadoFiatMethod,
+  KadoQuoteRequest,
+  KadoQuoteResponse,
+} from "./types";
+
+export const KadoPlugin = createPlugin({
+  name: "kado",
+  methods: () => ({
+    createPopover,
+    getAssets,
+    getBlockchains,
+    getKadoWidgetUrl,
+    getOrderStatus,
+    fetchProviderQuote,
+    swap,
+  }),
+  properties: {
+    supportedSwapkitProviders: [ProviderName.KADO],
+  },
+});
+
+function swap({ route }: SwapParams<"evm", QuoteResponseRoute>) {
+  if (!(route.sourceAddress && route.destinationAddress)) {
+    throw new Error("Source and destination addresses are required");
+  }
+
+  const sellAsset = AssetValue.from({ asset: route.sellAsset });
+  const buyAsset = AssetValue.from({ asset: route.buyAsset });
+
+  // Determine if this is a buy or sell operation
+  const type = sellAsset.chain === Chain.Fiat ? "buy" : "sell";
+
+  const url = getKadoWidgetUrl({
+    sellAsset,
+    buyAsset,
+    recipient: route.destinationAddress,
+    sender: route.sourceAddress,
+    type,
+    mode: "minimal",
+  });
+
+  createPopover(url);
+
+  return {
+    status: "pending",
+    txHash: null,
+  };
+}
+
+async function fetchProviderQuote({
+  sellAsset,
+  buyAsset,
+  fiatMethod = "credit_card",
+}: {
+  sellAsset: AssetValue;
+  buyAsset: AssetValue;
+  fiatMethod: KadoFiatMethod;
+}): Promise<QuoteResponse> {
+  try {
+    const isOnRamp = sellAsset.chain === Chain.Fiat;
+    const [paymentAsset, receiveAsset] = isOnRamp ? [buyAsset, sellAsset] : [sellAsset, buyAsset];
+    const transactionType = isOnRamp ? "buy" : "sell";
+
+    const quoteRequest: KadoQuoteRequest = {
+      amount: paymentAsset.getValue("string"),
+      asset: paymentAsset.symbol,
+      blockchain: ChainToKadoChain(paymentAsset.chain),
+      currency: receiveAsset.symbol as KadoFiatCurrency,
+      fiatMethod,
+      partner: "fortress",
+      transactionType,
+    };
+
+    const kadoApiKey = SKConfig.get("apiKeys").kado;
+    warnOnce(!kadoApiKey, "plugin(kado): No Kado API key found");
+
+    const quote = await RequestClient.get<KadoQuoteResponse>(
+      "https://api.kado.money/v2/ramp/quote",
+      { searchParams: quoteRequest, headers: { "X-Widget-Id": kadoApiKey } },
+    );
+
+    if (!quote.success) {
+      throw new Error(quote.message);
+    }
+
+    return mapKadoQuoteToQuoteResponse({ quote, sellAsset, buyAsset });
+  } catch (_) {
+    throw new Error("core_swap_quote_error");
+  }
+}
+
+async function getBlockchains() {
+  const response = await RequestClient.get<KadoBlockchainsResponse>(
+    "https://api.kado.money/v1/ramp/blockchains",
+  );
+
+  if (!response.success) {
+    throw new Error(response.message);
+  }
+
+  return response.data.blockchains;
+}
+
+async function getAssets() {
+  const response = await RequestClient.get<KadoAssetsResponse>(
+    "https://api.kado.money/v1/ramp/supported-assets",
+  );
+
+  if (!response.success) {
+    throw new Error(response.message);
+  }
+
+  return response.data.assets;
+}
+
+async function getOrderStatus(orderId: string) {
+  const kadoApiKey = SKConfig.get("apiKeys").kado;
+  warnOnce(!kadoApiKey, "plugin(kado): No Kado API key found");
+
+  try {
+    const response = await RequestClient.get<{
+      success: boolean;
+      message: string;
+      data: { order: { status: string } };
+    }>(`https://api.kado.money/v2/public/orders/${orderId}`, {
+      headers: { "X-Widget-Id": kadoApiKey },
+    });
+
+    if (!response.success) {
+      throw new Error(response.message);
+    }
+
+    return response.data.order;
+  } catch (_error) {
+    throw new Error("Failed to get order status");
+  }
+}
+
+function getKadoWidgetUrl({
+  sellAsset,
+  buyAsset,
+  recipient,
+  type,
+  sender,
+  mode,
+}: {
+  sellAsset: AssetValue;
+  buyAsset: AssetValue;
+  recipient?: string;
+  sender?: string;
+  type: "buy" | "sell";
+  mode: "minimal" | "full";
+}) {
+  const kadoApiKey = SKConfig.get("apiKeys").kado;
+  warnOnce(!kadoApiKey, "plugin(kado): No Kado API key found");
+
+  const buySellParams =
+    type === "buy"
+      ? {
+          onPayAmount: sellAsset.getValue("string"),
+          onPayCurrency: sellAsset.symbol,
+          onRevCurrency: buyAsset.symbol,
+          ...(recipient ? { onToAddress: recipient } : {}),
+        }
+      : {
+          offPayAmount: sellAsset.getValue("string"),
+          offPayCurrency: sellAsset.symbol,
+          offRevCurrency: buyAsset.symbol,
+          ...(sender ? { offFromAddress: sender } : {}),
+        };
+  const network = ChainToKadoChain(type === "buy" ? buyAsset.chain : sellAsset.chain).toUpperCase();
+  const urlParams = new URLSearchParams({
+    ...buySellParams,
+    apiKey: kadoApiKey,
+    network,
+    product: type.toUpperCase(),
+    mode,
+  });
+
+  return `https://app.kado.money/?${urlParams.toString()}`;
+}
+
+function createPopover(url: string) {
+  const overlay = document.createElement("div");
+  overlay.style.cssText = `
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.5);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 9999;
+  `;
+
+  const iframe = document.createElement("iframe");
+  iframe.src = url;
+  iframe.style.cssText = `
+    width: 440px;
+    height: 700px;
+    border: none;
+    border-radius: 12px;
+    background: white;
+  `;
+
+  overlay.appendChild(iframe);
+  document.body.appendChild(overlay);
+
+  overlay.addEventListener("click", (e) => {
+    if (e.target === overlay) {
+      document.body.removeChild(overlay);
+    }
+  });
+
+  return overlay;
+}

package/src/kado/types.ts

@@ -0,0 +1,225 @@
+import type { SupportedKadoChain } from "./helpers";
+
+export const KadoSupportedFiatCurrencies = [
+  "USD",
+  "CAD",
+  "GBP",
+  "EUR",
+  "MXN",
+  "COP",
+  "INR",
+  "CHF",
+  "AUD",
+  "ARS",
+  "BRL",
+  "CLP",
+  "JPY",
+  "KRW",
+  "PEN",
+  "PHP",
+  "SGD",
+  "TRY",
+  "UYU",
+  "TWD",
+  "VND",
+  "CRC",
+  "SEK",
+  "PLN",
+  "DKK",
+  "NOK",
+  "NZD",
+] as const;
+
+export type KadoFiatCurrency = (typeof KadoSupportedFiatCurrencies)[number];
+
+export type KadoFiatMethod =
+  | "ach"
+  | "debit_card"
+  | "credit_card"
+  | "apple_pay_credit"
+  | "apple_pay_debit"
+  | "wire"
+  | "sepa"
+  | "pix"
+  | "koywe";
+
+export type KadoQuoteRequest = {
+  transactionType: "buy" | "sell";
+  fiatMethod: KadoFiatMethod;
+  partner: "fortress";
+  amount: string;
+  asset: string;
+  blockchain: string;
+  currency: KadoFiatCurrency;
+};
+
+export type KadoAsset = {
+  _id: string;
+  name: string;
+  description: string;
+  label: string;
+  symbol: string;
+  supportedProviders: string[];
+  stablecoin: boolean;
+  liveOnRamp: boolean;
+  createdAt: string;
+  updatedAt: string;
+  __v: number;
+  priority: number;
+  displayPrecision: number;
+  usesAvaxRouter: boolean;
+  squidChainId: string;
+  coingeckoId: string;
+  usesAxelarBridge: boolean;
+  squidAssetId: string;
+  address: string;
+  blockExplorerURI: string;
+  decimals: number;
+  officialChainId: keyof typeof SupportedKadoChain;
+  precision: number;
+  rampProducts: string[];
+  wallets: string[];
+  rpcURI: string;
+  usesPolygonFulfillment: boolean;
+  usesOsmoRouter: boolean;
+  ibcChannelIdOffRamp: number;
+  ibcChannelIdOnRamp: number;
+  osmoPfmChannel: number;
+  osmoPfmReceiver: string;
+  ibcDenom: string;
+  isNative: boolean;
+  avgOffRampTimeInSeconds: number;
+  avgOnRampTimeInSeconds: number;
+  providers: string[];
+  trustekAssetId: string;
+  trustekNetworkId: string;
+  kycLevels: string[];
+};
+
+export type KadoBlockchainsResponse = {
+  success: boolean;
+  message: string;
+  data: {
+    blockchains: {
+      _id: string;
+      supportedEnvironment: string;
+      network: string;
+      origin: string;
+      label: string;
+      associatedAssets: KadoAsset[];
+      avgTransactionTimeSeconds: number;
+      usesAvaxRouter: boolean;
+      liveOnRamp: boolean;
+      createdAt: string;
+      updatedAt: string;
+      __v: number;
+      priority: number;
+    }[];
+  };
+};
+
+export type KadoAssetsResponse = {
+  success: boolean;
+  message: string;
+  data: {
+    assets: {
+      _id: string;
+      name: string;
+      description: string;
+      label: string;
+      symbol: string;
+      supportedProviders: string[];
+      stablecoin: boolean;
+      liveOnRamp: boolean;
+      createdAt: string;
+      updatedAt: string;
+      __v: number;
+      priority: number;
+    }[];
+  };
+};
+
+export type KadoQuoteResponse = {
+  success: boolean;
+  message: string;
+  data: {
+    request: {
+      transactionType: string;
+      fiatMethod: KadoFiatMethod;
+      partner: string;
+      amount: number;
+      asset: string;
+      blockchain: keyof typeof SupportedKadoChain;
+      currency: KadoFiatCurrency;
+      reverse: false;
+      ipCountry: string;
+    };
+    quote: {
+      asset: string;
+      baseAmount: {
+        amount: number;
+        currency: KadoFiatCurrency;
+      };
+      price: {
+        amount: number;
+        price: number;
+        symbol: string;
+        unit: string;
+      };
+      bridgeFee: {
+        amount: number;
+        currency: KadoFiatCurrency;
+        originalAmount: number;
+        promotionModifier: number;
+      };
+      receiveAmountAfterFees: {
+        originalAmount: number;
+        amount: number;
+        currency: KadoFiatCurrency;
+      };
+      receiveUnitCountAfterFees: {
+        amount: number;
+        currency: KadoFiatCurrency;
+      };
+      feeType: string;
+      minValue: {
+        amount: number;
+        unit: string;
+      };
+      maxValue: {
+        amount: number;
+        unit: string;
+      };
+      receive: {
+        amount: number;
+        originalAmount: number;
+        symbol: string;
+        unit: string;
+        unitCount: number;
+      };
+      networkFee: {
+        amount: number;
+        currency: KadoFiatCurrency;
+        originalAmount: number;
+        promotionModifier: number;
+      };
+      processingFee: {
+        amount: number;
+        currency: KadoFiatCurrency;
+        originalAmount: number;
+        promotionModifier: number;
+      };
+      totalFee: {
+        amount: number;
+        currency: KadoFiatCurrency;
+        originalAmount: number;
+      };
+      smartContractFee: {
+        amount: number;
+        currency: KadoFiatCurrency;
+        originalAmount: number;
+        promotionModifier: number;
+      };
+    };
+  };
+};

package/src/radix/index.ts

@@ -0,0 +1,36 @@
+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/thorchain/index.ts

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