@swapkit/helpers 1.0.0-rc.100 → 1.0.0-rc.102

package/package.json

@@ -2,16 +2,18 @@
   "author": "swapkit-oss",
   "description": "SwapKit - Helpers",
   "dependencies": {
-    "ky": "1.2.3"
+    "ky": "1.2.3",
+    "zod": "3.23.8"
   },
   "devDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.51",
-    "bun-types": "1.1.2",
+    "@swapkit/tokens": "1.0.0-rc.52",
+    "bun-types": "1.1.8",
     "ethers": "6.11.1"
   },
   "peerDependencies": {
-    "@swapkit/tokens": "1.0.0-rc.51",
-    "ky": "1.2.3"
+    "@swapkit/tokens": "1.0.0-rc.52",
+    "ky": "1.2.3",
+    "zod": "3.23.8"
   },
   "files": [
     "src/",
@@ -36,5 +38,5 @@
   },
   "type": "module",
   "types": "./src/index.ts",
-  "version": "1.0.0-rc.100"
+  "version": "1.0.0-rc.102"
 }

package/src/helpers/web3wallets.ts

@@ -1,5 +1,10 @@
 import type { BrowserProvider } from "ethers";
-import { ChainId, WalletOption } from "../types";
+import {
+  ChainId,
+  type EIP6963AnnounceProviderEvent,
+  type EIP6963Provider,
+  WalletOption,
+} from "../types";
 
 export type EthereumWindowProvider = BrowserProvider & {
   __XDEFI?: boolean;
@@ -142,7 +147,7 @@ export const isDetected = (walletOption: WalletOption) => {
   return listWeb3EVMWallets().includes(walletOption);
 };
 
-const listWeb3EVMWallets = () => {
+export const listWeb3EVMWallets = () => {
   const metamaskEnabled = window?.ethereum && !window.ethereum?.isBraveWallet;
   // @ts-ignore that should be implemented in xdefi and hooked up via swapkit core
   const xdefiEnabled = window?.xfi || window?.ethereum?.__XDEFI;
@@ -164,6 +169,24 @@ const listWeb3EVMWallets = () => {
   return wallets;
 };
 
+export function getEIP6963Wallets() {
+  const providers: EIP6963Provider[] = [];
+
+  function onAnnouncement(event: EIP6963AnnounceProviderEvent) {
+    if (providers.map((p) => p.info.uuid).includes(event.detail.info.uuid)) return;
+    providers.push(event.detail);
+  }
+
+  window.addEventListener("eip6963:announceProvider", onAnnouncement);
+  window.dispatchEvent(new Event("eip6963:requestProvider"));
+
+  function removeEIP6963EventListener() {
+    window.removeEventListener("eip6963:announceProvider", onAnnouncement);
+  }
+
+  return { providers, removeEIP6963EventListener };
+}
+
 export const okxMobileEnabled = () => {
   const ua = navigator.userAgent;
   const isIOS = /iphone|ipad|ipod|ios/i.test(ua);

package/src/modules/requestClient.ts

@@ -21,10 +21,9 @@ function getKyClient() {
   return kyClient;
 }
 
-const getTypedBaseRequestClient = (kyClient: KyInstance) => ({
-  get: <T>(url: string | URL | Request, options?: Options) => kyClient.get(url, options).json<T>(),
-  post: <T>(url: string | URL | Request, options?: Options) =>
-    kyClient.post(url, options).json<T>(),
+const getTypedBaseRequestClient = (ky: KyInstance) => ({
+  get: <T>(url: string | URL | Request, options?: Options) => ky.get(url, options).json<T>(),
+  post: <T>(url: string | URL | Request, options?: Options) => ky.post(url, options).json<T>(),
 });
 
 export const RequestClient = {

package/src/modules/swapKitError.ts

@@ -73,6 +73,11 @@ const errorMessages = {
    * THORChain
    */
 
+  /**
+   * SwapKit API
+   */
+  api_v2_invalid_response: 40001,
+
   /**
    * Helpers
    */

package/src/types/index.ts

@@ -8,3 +8,4 @@ export * from "./network";
 export * from "./tokens";
 export * from "./wallet";
 export * from "./sdk";
+export * from "./quotes";

package/src/types/quotes.ts

@@ -0,0 +1,391 @@
+import { z } from "zod";
+
+export enum WarningCodeEnum {
+  highSlippage = "highSlippage",
+  highPriceImpact = "highPriceImpact",
+}
+
+export const EVMTransactionDetailsParamsSchema = z.array(
+  z.union([
+    z.string(),
+    z.number(),
+    z.array(z.string()),
+    z
+      .object({
+        from: z.string(),
+        value: z.string(),
+      })
+      .describe("Parameters to pass to the contract method"),
+  ]),
+);
+
+export type EVMTransactionDetailsParams = z.infer<typeof EVMTransactionDetailsParamsSchema>;
+
+export const EVMTransactionDetailsSchema = z.object({
+  contractAddress: z.string({
+    description: "Address of the contract to interact with",
+  }),
+  contractMethod: z.string({
+    description: "Name of the method to call",
+  }),
+  contractParams: EVMTransactionDetailsParamsSchema,
+  // contractParamsStreaming: z.array(
+  //   z.string({
+  //     description:
+  //       "If making a streaming swap through THORChain, parameters to pass to the contract method",
+  //   }),
+  // ),
+  contractParamNames: z.array(
+    z.string({
+      description: "Names of the parameters to pass to the contract method",
+    }),
+  ),
+  approvalToken: z.optional(
+    z.string({
+      description: "Address of the token to approve spending of",
+    }),
+  ),
+  approvalSpender: z.optional(
+    z.string({
+      description: "Address of the spender to approve",
+    }),
+  ),
+});
+
+export type EVMTransactionDetails = z.infer<typeof EVMTransactionDetailsSchema>;
+
+export const EstimatedTimeSchema = z.object({
+  inbound: z.optional(
+    z.number({
+      description: "Time to receive inbound asset in seconds",
+    }),
+  ),
+  swap: z.optional(
+    z.number({
+      description: "Time to swap assets in seconds",
+    }),
+  ),
+  outbound: z.optional(
+    z.number({
+      description: "Time to receive outbound asset in seconds",
+    }),
+  ),
+  total: z.number({
+    description: "Total time in seconds",
+  }),
+});
+
+export type EstimatedTime = z.infer<typeof EstimatedTimeSchema>;
+
+export enum ProviderName {
+  CHAINFLIP = "CHAINFLIP",
+  TRADERJOE_V1 = "TRADERJOE_V1",
+  PANGOLIN_V1 = "PANGOLIN_V1",
+  UNISWAP_V2 = "UNISWAP_V2",
+  THORCHAIN = "THORCHAIN",
+  THORCHAIN_STREAMING = "THORCHAIN_STREAMING",
+  MAYACHAIN = "MAYACHAIN",
+  ONEINCH = "ONEINCH",
+  SUSHISWAP_V2 = "SUSHISWAP_V2",
+  WOOFI_V2 = "WOOFI_V2",
+  PANCAKESWAP = "PANCAKESWAP",
+}
+
+export enum FeeTypeEnum {
+  LIQUIDITY = "liquidity",
+  NETWORK = "network",
+  INBOUND = "inbound",
+  OUTBOUND = "outbound",
+  AFFILIATE = "affiliate",
+  TAX = "tax",
+}
+
+export const FeesSchema = z.array(
+  z.object({
+    type: z.nativeEnum(FeeTypeEnum),
+    amount: z.string(),
+    asset: z.string(),
+    chain: z.string(),
+    protocol: z.nativeEnum(ProviderName),
+  }),
+);
+
+export type Fees = z.infer<typeof FeesSchema>;
+
+export const RouteLegSchema = z.object({
+  sellAsset: z.string({
+    description: "Asset to sell",
+  }),
+  buyAsset: z.string({
+    description: "Asset to buy",
+  }),
+  provider: z.nativeEnum(ProviderName),
+  sourceAddress: z.string({
+    description: "Source address",
+  }),
+  destinationAddress: z.string({
+    description: "Destination address",
+  }),
+  estimatedTime: EstimatedTimeSchema.optional(),
+  affiliate: z
+    .string({
+      description: "Affiliate address",
+    })
+    .optional(),
+  affiliateFee: z
+    .number({
+      description: "Affiliate fee",
+    })
+    .optional(),
+  slipPercentage: z.number({
+    description: "Slippage as a percentage",
+  }),
+});
+
+export type RouteLeg = z.infer<typeof RouteLegSchema>;
+
+export const RouteLegWithoutAddressesSchema = RouteLegSchema.omit({
+  sourceAddress: true,
+  destinationAddress: true,
+  slipPercentage: true,
+});
+
+export type RouteLegWithoutAddresses = z.infer<typeof RouteLegWithoutAddressesSchema>;
+
+export const RouteQuoteMetadataAssetSchema = z.object({
+  name: z.string({
+    description: "Asset name",
+  }),
+  price: z.number({
+    description: "Price in USD",
+  }),
+  image: z.string({
+    description: "Asset image",
+  }),
+});
+
+export type RouteQuoteMetadataAsset = z.infer<typeof RouteQuoteMetadataAssetSchema>;
+
+export const RouteQuoteMetadataSchema = z.object({
+  priceImpact: z.number({
+    description: "Price impact",
+  }),
+  assets: z.optional(z.array(RouteQuoteMetadataAssetSchema)),
+});
+
+export const RouteQuoteWarningSchema = z.array(
+  z.object({
+    code: z.nativeEnum(WarningCodeEnum),
+    display: z.string(),
+    tooltip: z.string().optional(),
+  }),
+);
+
+export const RouteQuoteLegSchema = z.object({
+  sellAsset: z.string({
+    description: "Asset to sell",
+  }),
+  buyAsset: z.string({
+    description: "Asset to buy",
+  }),
+  provider: z.nativeEnum(ProviderName),
+  buyAmount: z.string({
+    description: "Amount of asset to buy",
+  }),
+  buyAmountMaxSlippage: z.string({
+    description: "Amount of asset to buy",
+  }),
+  sellAmount: z.string({
+    description: "Amount of asset to sell",
+  }),
+  sourceAddress: z.string({
+    description: "Source address",
+  }),
+  destinationAddress: z.string({
+    description: "Destination address",
+  }),
+  slippageBps: z.number({
+    description: "Slippage in bps",
+  }),
+  targetAddress: z.optional(
+    z.string({
+      description: "Target address for contract call or transfer address",
+    }),
+  ),
+  inboundAddress: z.optional(
+    z.string({
+      description: "Inbound address",
+    }),
+  ),
+  routerAddress: z.optional(
+    z.string({
+      description: "Inbound address",
+    }),
+  ),
+  contractMethod: z.optional(
+    z.string({
+      description: "Contract method",
+    }),
+  ),
+  fees: z.optional(FeesSchema),
+  estimatedTime: z.optional(EstimatedTimeSchema),
+  memo: z.optional(
+    z.string({
+      description: "Memo",
+    }),
+  ),
+  expiration: z.optional(
+    z.string({
+      description: "Expiration",
+    }),
+  ),
+});
+
+export type RouteQuoteLeg = z.infer<typeof RouteQuoteLegSchema>;
+
+export const RouteQuoteSchema = z.object({
+  providers: z.array(z.nativeEnum(ProviderName)),
+  sellAsset: z.string({
+    description: "Asset to sell",
+  }),
+  sellAmount: z.string({
+    description: "sell amount",
+  }),
+  buyAsset: z.string({
+    description: "Asset to buy",
+  }),
+  expectedBuyAmount: z.string({
+    description: "Expected Buy amount",
+  }),
+  expectedBuyAmountMaxSlippage: z.string({
+    description: "Expected Buy amount max slippage",
+  }),
+  sourceAddress: z.string({
+    description: "Source address",
+  }),
+  destinationAddress: z.string({
+    description: "Destination address",
+  }),
+  targetAddress: z.optional(
+    z.string({
+      description: "Target address",
+    }),
+  ),
+  routerAddress: z.optional(
+    z.string({
+      description: "Router address",
+    }),
+  ),
+  inboundAddress: z.optional(
+    z.string({
+      description: "Inbound address",
+    }),
+  ),
+  expiration: z.optional(
+    z.string({
+      description: "Expiration",
+    }),
+  ),
+  memo: z.optional(
+    z.string({
+      description: "Memo",
+    }),
+  ),
+  evmTransactionDetails: z.optional(EVMTransactionDetailsSchema),
+  routePathArray: z.optional(z.array(z.string())),
+  estimatedTime: z.optional(EstimatedTimeSchema),
+  totalSlippageBps: z.number({
+    description: "Total slippage in bps",
+  }),
+  legs: z.array(RouteQuoteLegSchema),
+  // TODO use enum
+  errorCode: z.optional(z.string()),
+  warnings: RouteQuoteWarningSchema,
+  meta: RouteQuoteMetadataSchema,
+});
+
+export type RouteQuote = z.infer<typeof RouteQuoteSchema>;
+
+const QuoteResponseRouteLegItem = z.object({
+  provider: z.nativeEnum(ProviderName),
+  sellAsset: z.string({
+    description: "Asset to sell",
+  }),
+  sellAmount: z.string({
+    description: "Sell amount",
+  }),
+  buyAsset: z.string({
+    description: "Asset to buy",
+  }),
+  buyAmount: z.string({
+    description: "Buy amount",
+  }),
+  buyAmountMaxSlippage: z.string({
+    description: "Buy amount max slippage",
+  }),
+  fees: z.optional(FeesSchema), // TODO remove optionality
+});
+
+const QuoteResponseRouteItem = z.object({
+  providers: z.array(z.nativeEnum(ProviderName)),
+  sellAsset: z.string({
+    description: "Asset to sell",
+  }),
+  sellAmount: z.string({
+    description: "sell amount",
+  }),
+  buyAsset: z.string({
+    description: "Asset to buy",
+  }),
+  expectedBuyAmount: z.string({
+    description: "Expected Buy amount",
+  }),
+  expectedBuyAmountMaxSlippage: z.string({
+    description: "Expected Buy amount max slippage",
+  }),
+  sourceAddress: z.string({
+    description: "Source address",
+  }),
+  destinationAddress: z.string({
+    description: "Destination address",
+  }),
+  targetAddress: z.optional(
+    z.string({
+      description: "Target address",
+    }),
+  ),
+  expiration: z.optional(
+    z.string({
+      description: "Expiration",
+    }),
+  ),
+  memo: z.optional(
+    z.string({
+      description: "Memo",
+    }),
+  ),
+  evmTransactionDetails: z.optional(EVMTransactionDetailsSchema),
+  estimatedTime: z.optional(EstimatedTimeSchema), // TODO remove optionality
+  totalSlippageBps: z.number({
+    description: "Total slippage in bps",
+  }),
+  legs: z.array(QuoteResponseRouteLegItem),
+  warnings: RouteQuoteWarningSchema,
+  meta: RouteQuoteMetadataSchema,
+});
+
+export const QuoteResponseSchema = z.object({
+  quoteId: z.string({
+    description: "Quote ID",
+  }),
+  routes: z.array(QuoteResponseRouteItem),
+  error: z.optional(
+    z.string({
+      description: "Error message",
+    }),
+  ),
+});
+
+export type QuoteResponse = z.infer<typeof QuoteResponseSchema>;
+export type QuoteResponseRoute = z.infer<typeof QuoteResponseRouteItem>;
+export type QuoteResponseRouteLeg = z.infer<typeof QuoteResponseRouteLegItem>;

package/src/types/sdk.ts

@@ -1,13 +1,17 @@
+import { z } from "zod";
 import type { AssetValue } from "../modules/assetValue";
+import type { QuoteResponseRoute } from "./quotes";
 
 export type GenericSwapParams = {
-  buyAsset: AssetValue;
-  sellAsset: AssetValue;
-  recipient: string;
+  buyAsset?: AssetValue;
+  sellAsset?: AssetValue;
+  recipient?: string;
+  feeOptionKey?: FeeOption;
+  route: QuoteResponseRoute;
 };
 
 export type SwapParams<PluginNames = string, T = GenericSwapParams> = T & {
-  pluginName: PluginNames;
+  pluginName?: PluginNames;
 };
 
 export enum FeeOption {
@@ -42,3 +46,81 @@ export enum MemoType {
   OPEN_LOAN = "$+",
   CLOSE_LOAN = "$-",
 }
+
+export const QuoteRequestSchema = z
+  .object({
+    sellAsset: z.string({
+      description: "Asset to sell",
+    }),
+    buyAsset: z.string({
+      description: "Asset to buy",
+    }),
+    sellAmount: z
+      .number({
+        description: "Amount of asset to sell",
+      })
+      .refine((amount) => amount > 0, {
+        message: "sellAmount must be greater than 0",
+        path: ["sellAmount"],
+      }),
+    providers: z.optional(
+      z.array(
+        z.string({
+          description: "List of providers to use",
+        }),
+      ),
+    ),
+    sourceAddress: z.optional(
+      z.string({
+        description: "Address to send asset from",
+      }),
+    ),
+    destinationAddress: z.optional(
+      z.string({
+        description: "Address to send asset to",
+      }),
+    ),
+    slippage: z.optional(
+      z.number({
+        description: "Slippage tolerance as a percentage. Default is 3%.",
+      }),
+    ),
+    affiliate: z.optional(
+      z.string({
+        description: "Affiliate thorname",
+      }),
+    ),
+    affiliateFee: z.optional(
+      z
+        .number({
+          description: "Affiliate fee in basis points",
+        })
+        .refine(
+          (fee) => {
+            return fee === Math.floor(fee) && fee >= 0;
+          },
+          { message: "affiliateFee must be a positive integer", path: ["affiliateFee"] },
+        ),
+    ),
+    allowSmartContractSender: z.optional(
+      z.boolean({
+        description: "Allow smart contract as sender",
+      }),
+    ),
+    allowSmartContractReceiver: z.optional(
+      z.boolean({
+        description: "Allow smart contract as recipient",
+      }),
+    ),
+    disableSecurityChecks: z.optional(
+      z.boolean({
+        description: "Disable security checks",
+      }),
+    ),
+  })
+  .refine((data) => data.sellAsset !== data.buyAsset, {
+    message: "Must be different",
+    path: ["sellAsset", "buyAsset"],
+  });
+
+export type QuoteRequest = z.infer<typeof QuoteRequestSchema>;

package/src/types/wallet.ts

@@ -2,9 +2,16 @@ import type { CosmosWallets, ThorchainWallets } from "@swapkit/toolbox-cosmos";
 import type { EVMWallets } from "@swapkit/toolbox-evm";
 import type { SubstrateWallets } from "@swapkit/toolbox-substrate";
 import type { UTXOWallets } from "@swapkit/toolbox-utxo";
+import type { Eip1193Provider } from "ethers";
 import type { AssetValue } from "../modules/assetValue";
 import type { Chain } from "./chains";
 
+declare global {
+  interface WindowEventMap {
+    "eip6963:announceProvider": CustomEvent;
+  }
+}
+
 export enum WalletOption {
   KEYSTORE = "KEYSTORE",
   KEEPKEY = "KEEPKEY",
@@ -20,6 +27,8 @@ export enum WalletOption {
   OKX_MOBILE = "OKX_MOBILE",
   BRAVE = "BRAVE",
   WALLETCONNECT = "WALLETCONNECT",
+  EIP6963 = "EIP6963",
+  EXODUS = "EXODUS",
 }
 
 export enum LedgerErrorCode {
@@ -45,3 +54,25 @@ export type BaseWallet<T extends EmptyWallet | unknown> = {
 export type Wallet = BaseWallet<
   EVMWallets & CosmosWallets & ThorchainWallets & UTXOWallets & SubstrateWallets
 >;
+
+export type EIP6963ProviderInfo = {
+  walletId: string;
+  uuid: string;
+  name: string;
+  icon: string;
+};
+
+export type EIP6963ProviderDetail = {
+  info: EIP6963ProviderInfo;
+  provider: Eip1193Provider;
+};
+
+export type EIP6963Provider = {
+  info: EIP6963ProviderInfo;
+  provider: Eip1193Provider;
+};
+
+// This type represents the structure of an event dispatched by a wallet to announce its presence based on EIP-6963.
+export type EIP6963AnnounceProviderEvent = Event & {
+  detail: EIP6963Provider;
+};