@swapkit/helpers 1.2.4 → 1.3.0

package/src/types/quotes.ts

@@ -1,5 +1,3 @@
-import { z } from "zod";
-
 export enum ErrorCode {
   unknownError = "unknownError",
   test_error = "test_error",
@@ -119,103 +117,6 @@ export enum WarningCodeEnum {
   highPriceImpact = "highPriceImpact",
 }
 
-export const EVMTransactionSchema = z.object({
-  to: z.string({
-    description: "Address of the recipient",
-  }),
-  from: z.string({
-    description: "Address of the sender",
-  }),
-  gas: z
-    .number({
-      description: "Gas limit",
-    })
-    .optional(),
-  gasPrice: z
-    .string({
-      description: "Gas price",
-    })
-    .optional(),
-  value: z.string({
-    description: "Value to send",
-  }),
-  data: z.string({
-    description: "Data to send",
-  }),
-});
-
-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",
@@ -239,257 +140,3 @@ export enum FeeTypeEnum {
   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 type EVMTransaction = z.infer<typeof EVMTransactionSchema>;
-
-const QuoteResponseRouteLegItemDev = 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 QuoteResponseRouteItemDev = 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",
-    }),
-  ),
-  fees: FeesSchema,
-  tx: z.optional(EVMTransactionSchema),
-  transaction: z.optional(z.unknown()), // Can take many forms depending on the chains
-  estimatedTime: z.optional(EstimatedTimeSchema), // TODO remove optionality
-  totalSlippageBps: z.number({
-    description: "Total slippage in bps",
-  }),
-  legs: z.array(QuoteResponseRouteLegItemDev),
-  warnings: RouteQuoteWarningSchema,
-  meta: RouteQuoteMetadataSchema,
-});
-
-export const QuoteResponseSchemaDev = z.object({
-  quoteId: z.string({
-    description: "Quote ID",
-  }),
-  routes: z.array(QuoteResponseRouteItemDev),
-  error: z.optional(
-    z.string({
-      description: "Error message",
-    }),
-  ),
-});
-
-export type QuoteResponseDev = z.infer<typeof QuoteResponseSchemaDev>;
-export type QuoteResponseRouteDev = z.infer<typeof QuoteResponseRouteItemDev>;
-export type QuoteResponseRouteLegDev = z.infer<typeof QuoteResponseRouteLegItemDev>;
-
-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),
-  transaction: z.optional(z.unknown()), // Can take many forms depending on the chains
-  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,10 +1,8 @@
 import type { CovalentApiType, EthplorerApiType } from "@swapkit/toolbox-evm";
 import type { BlockchairApiType } from "@swapkit/toolbox-utxo";
-import { z } from "zod";
 
 import type { AssetValue } from "../modules/assetValue";
 import type { Chain, CosmosChain, UTXOChain } from "./chains";
-import { ProviderName, type QuoteResponseRoute } from "./quotes";
 
 type CovalentChains =
   | Chain.BinanceSmartChain
@@ -19,15 +17,15 @@ export type ChainApis = { [key in CovalentChains]?: CovalentApiType } & {
   [key in UTXOChain]?: BlockchairApiType;
 };
 
-export type GenericSwapParams = {
+export type GenericSwapParams<T = unknown> = {
   buyAsset?: AssetValue;
   sellAsset?: AssetValue;
   recipient?: string;
   feeOptionKey?: FeeOption;
-  route: QuoteResponseRoute;
+  route: T;
 };
 
-export type SwapParams<PluginNames = string, T = GenericSwapParams> = T & {
+export type SwapParams<PluginNames = string, R = unknown> = GenericSwapParams<R> & {
   pluginName?: PluginNames;
 };
 
@@ -65,96 +63,3 @@ export enum MemoType {
   RUNEPOOL_DEPOSIT = "POOL+",
   RUNEPOOL_WITHDRAW = "POOL-",
 }
-
-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",
-          })
-          .refine(
-            (provider) => {
-              return ProviderName[provider as ProviderName] !== undefined;
-            },
-            {
-              message: "Invalid provider",
-              path: ["providers"],
-            },
-          ),
-      ),
-    ),
-    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",
-      }),
-    ),
-    includeTx: z.optional(
-      z.boolean({
-        description: "Set to true to include an transaction object (EVM only)",
-      }),
-    ),
-  })
-  .refine((data) => data.sellAsset !== data.buyAsset, {
-    message: "Must be different",
-    path: ["sellAsset", "buyAsset"],
-  });
-
-export type QuoteRequest = z.infer<typeof QuoteRequestSchema>;

package/src/types/abis/erc20.ts

@@ -1,99 +0,0 @@
-export const erc20ABI = [
-  { inputs: [], stateMutability: "nonpayable", type: "constructor" },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "owner", type: "address" },
-      { indexed: true, internalType: "address", name: "spender", type: "address" },
-      { indexed: false, internalType: "uint256", name: "value", type: "uint256" },
-    ],
-    name: "Approval",
-    type: "event",
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: true, internalType: "address", name: "from", type: "address" },
-      { indexed: true, internalType: "address", name: "to", type: "address" },
-      { indexed: false, internalType: "uint256", name: "value", type: "uint256" },
-    ],
-    name: "Transfer",
-    type: "event",
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "", type: "address" },
-      { internalType: "address", name: "", type: "address" },
-    ],
-    name: "allowance",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "spender", type: "address" },
-      { internalType: "uint256", name: "value", type: "uint256" },
-    ],
-    name: "approve",
-    outputs: [{ internalType: "bool", name: "success", type: "bool" }],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [{ internalType: "address", name: "", type: "address" }],
-    name: "balanceOf",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "decimals",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "name",
-    outputs: [{ internalType: "string", name: "", type: "string" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "symbol",
-    outputs: [{ internalType: "string", name: "", type: "string" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [],
-    name: "totalSupply",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function",
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "to", type: "address" },
-      { internalType: "uint256", name: "value", type: "uint256" },
-    ],
-    name: "transfer",
-    outputs: [{ internalType: "bool", name: "success", type: "bool" }],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "from", type: "address" },
-      { internalType: "address", name: "to", type: "address" },
-      { internalType: "uint256", name: "value", type: "uint256" },
-    ],
-    name: "transferFrom",
-    outputs: [{ internalType: "bool", name: "success", type: "bool" }],
-    stateMutability: "nonpayable",
-    type: "function",
-  },
-];