@swapkit/helpers 1.0.0-rc.99 → 1.0.1

package/src/types/derivationPath.ts

@@ -13,7 +13,6 @@ export enum DerivationPath {
   ARB = "m/44'/60'/0'/0",
   AVAX = "m/44'/60'/0'/0",
   BCH = "m/44'/145'/0'/0",
-  BNB = "m/44'/714'/0'/0",
   BSC = "m/44'/60'/0'/0",
   BTC = "m/84'/0'/0'/0",
   DASH = "m/44'/5'/0'/0",
@@ -27,7 +26,9 @@ export enum DerivationPath {
   MATIC = "m/44'/60'/0'/0",
   MAYA = "m/44'/931'/0'/0",
   OP = "m/44'/60'/0'/0",
+  SOL = "m/44'/501'/0'/0",
   THOR = "m/44'/931'/0'/0",
+  XRD = "////",
 }
 
 export type DerivationPathArray = [number, number, number, number, number?];
@@ -36,7 +37,6 @@ export const NetworkDerivationPath: Record<Chain, DerivationPathArray> = {
   ARB: [44, 60, 0, 0, 0],
   AVAX: [44, 60, 0, 0, 0],
   BCH: [44, 145, 0, 0, 0],
-  BNB: [44, 714, 0, 0, 0],
   BSC: [44, 60, 0, 0, 0],
   BTC: [84, 0, 0, 0, 0],
   DASH: [44, 5, 0, 0, 0],
@@ -48,9 +48,11 @@ export const NetworkDerivationPath: Record<Chain, DerivationPathArray> = {
   MATIC: [44, 60, 0, 0, 0],
   MAYA: [44, 931, 0, 0, 0],
   OP: [44, 60, 0, 0, 0],
+  SOL: [44, 501, 0, 0, 0],
   THOR: [44, 931, 0, 0, 0],
 
   // Polkadot and related network derivation path is not number based
+  XRD: [0, 0, 0, 0, 0],
   DOT: [0, 0, 0, 0, 0],
   FLIP: [0, 0, 0, 0, 0],
 };

package/src/types/index.ts

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

package/src/types/network.ts

@@ -1,7 +1,6 @@
 export enum RPCUrl {
   Arbitrum = "https://arb1.arbitrum.io/rpc",
   Avalanche = "https://node-router.thorswap.net/avalanche-c",
-  Binance = "",
   BinanceSmartChain = "https://bsc-dataseed.binance.org",
   Bitcoin = "https://node-router.thorswap.net/bitcoin",
   BitcoinCash = "https://node-router.thorswap.net/bitcoin-cash",
@@ -17,14 +16,15 @@ export enum RPCUrl {
   Optimism = "https://mainnet.optimism.io",
   Polkadot = "wss://rpc.polkadot.io",
   Polygon = "https://polygon-rpc.com",
+  Radix = "https://radix-mainnet.rpc.grove.city/v1/326002fc/core",
   THORChain = "https://rpc.thorswap.net",
   THORChainStagenet = "https://stagenet-rpc.ninerealms.com",
+  Solana = "https://mainnet.helius-rpc.com/?api-key=2cbe3ae6-cfc5-4141-a093-0055d0fa3d80",
 }
 
 export enum ExplorerUrl {
   Arbitrum = "https://arbiscan.io",
   Avalanche = "https://snowtrace.io",
-  Binance = "https://explorer.binance.org",
   BinanceSmartChain = "https://bscscan.com",
   Bitcoin = "https://blockchair.com/bitcoin",
   BitcoinCash = "https://www.blockchair.com/bitcoin-cash",
@@ -37,7 +37,9 @@ export enum ExplorerUrl {
   Litecoin = "https://blockchair.com/litecoin",
   Maya = "https://www.mayascan.org",
   Optimism = "https://optimistic.etherscan.io",
-  Polkadot = "https://polkadot.subscan.io/",
+  Polkadot = "https://polkadot.subscan.io",
   Polygon = "https://polygonscan.com",
+  Radix = "https://dashboard.radixdlt.com",
   THORChain = "https://runescan.io",
+  Solana = "https://solscan.io",
 }

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/radix.ts

@@ -0,0 +1,14 @@
+export type RadixCoreStateResourceDTO = {
+  at_ledger_state?: Todo; // not needed
+  manager: {
+    resource_type: string;
+    divisibility: {
+      substate_type: string;
+      is_locked: boolean;
+      value: {
+        divisibility: number;
+      };
+    };
+  };
+  owner_role?: Todo; // not needed
+};

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 {
@@ -36,9 +40,87 @@ export enum MemoType {
   BOND = "BOND",
   DEPOSIT = "+",
   LEAVE = "LEAVE",
-  THORNAME_REGISTER = "~",
+  NAME_REGISTER = "~",
   UNBOND = "UNBOND",
   WITHDRAW = "-",
   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/tokens.ts

@@ -1,30 +1,34 @@
 import type {
   ChainflipList,
-  CoinGeckoList,
   MayaList,
-  PancakeswapETHList,
+  OneInchList,
   PancakeswapList,
   PangolinList,
-  StargateARBList,
   SushiswapList,
   ThorchainList,
-  TraderjoeList,
-  UniswapList,
-  WoofiList,
+  TraderjoeV1List,
+  TraderjoeV2List,
+  UniswapV2List,
+  UniswapV3List,
 } from "@swapkit/tokens";
 
 export type TokenTax = { buy: number; sell: number };
 
 export type TokenNames =
-  | (typeof ThorchainList)["tokens"][number]["identifier"]
-  | (typeof CoinGeckoList)["tokens"][number]["identifier"]
+  | (typeof ChainflipList)["tokens"][number]["identifier"]
   | (typeof MayaList)["tokens"][number]["identifier"]
-  | (typeof PancakeswapETHList)["tokens"][number]["identifier"]
+  | (typeof OneInchList)["tokens"][number]["identifier"]
   | (typeof PancakeswapList)["tokens"][number]["identifier"]
   | (typeof PangolinList)["tokens"][number]["identifier"]
-  | (typeof StargateARBList)["tokens"][number]["identifier"]
   | (typeof SushiswapList)["tokens"][number]["identifier"]
-  | (typeof TraderjoeList)["tokens"][number]["identifier"]
-  | (typeof WoofiList)["tokens"][number]["identifier"]
-  | (typeof UniswapList)["tokens"][number]["identifier"]
-  | (typeof ChainflipList)["tokens"][number]["identifier"];
+  | (typeof ThorchainList)["tokens"][number]["identifier"]
+  | (typeof TraderjoeV1List)["tokens"][number]["identifier"]
+  | (typeof TraderjoeV2List)["tokens"][number]["identifier"]
+  | (typeof UniswapV2List)["tokens"][number]["identifier"]
+  | (typeof UniswapV3List)["tokens"][number]["identifier"];
+//   | (typeof CoinGeckoList)["tokens"][number]["identifier"]
+//   | (typeof PancakeswapETHList)["tokens"][number]["identifier"]
+//   | (typeof StargateARBList)["tokens"][number]["identifier"]
+//   | (typeof TraderjoeList)["tokens"][number]["identifier"]
+//   | (typeof WoofiList)["tokens"][number]["identifier"]
+//   | (typeof UniswapList)["tokens"][number]["identifier"];