feat: ERC20 quotes can now be obtained via the nftx api

this is a huge refactor and rewrite of the pricing api, covering @nftx/api, @nftx/core, and @nftx/trade

the individual quoting methods (fetchVaultBuyPrice etc) have been removed in favour of two methods: fetchQuote, and fetchPrice
fetchPrice returns an off-chain price, fetchQuote returns an on-chain quote with executable data
the different types of pricing calls can now be chosen via the `type` parameter, which can be buy/sell/swap/mint/redeem and the new type: erc20

BREAKING CHANGE: price methods have been removed in favour of fetchPrice and fetchQuote
BREAKING CHANGE: tradeErc20 method now takes a quote object (obtained from fetchQuote) instead of a price object (from fetchTokenBuyPrice)
BREAKING CHANGE: fetchTokenBuyPrice has been replaced with fetchAmmQuote - though fetchQuote/fetchPrice should be preferred

packages/api/src/prices/fetchPrice.ts

@@ -0,0 +1,21 @@
+import { MarketplacePrice } from '@nftx/types';
+import fetchQuote, {
+  BuyArgs,
+  MintArgs,
+  RedeemArgs,
+  SellArgs,
+  TokenArgs,
+  SwapArgs,
+} from './fetchQuote';
+
+function fetchPrice(args: BuyArgs): Promise<MarketplacePrice>;
+function fetchPrice(args: SellArgs): Promise<MarketplacePrice>;
+function fetchPrice(args: SwapArgs): Promise<MarketplacePrice>;
+function fetchPrice(args: MintArgs): Promise<MarketplacePrice>;
+function fetchPrice(args: RedeemArgs): Promise<MarketplacePrice>;
+function fetchPrice(args: TokenArgs): Promise<MarketplacePrice>;
+function fetchPrice(args: any) {
+  return fetchQuote({ ...args, quoteType: 'price' });
+}
+
+export default fetchPrice;

packages/api/src/prices/fetchQuote.ts

@@ -1,82 +1,131 @@
 import type {
   Address,
+  BigIntish,
   MarketplacePrice,
   MarketplaceQuote,
+  Permit2Quote,
   TokenIds,
+  QuoteToken,
 } from '@nftx/types';
 import { queryApi } from '../utils';
 import config from '@nftx/config';
 import { getTokenIdAmounts, getUniqueTokenIds } from '@nftx/utils';
 
-type CommonArgs = {
-  type: 'buy' | 'sell' | 'swap' | 'mint' | 'redeem';
+export type BuyArgs = {
+  network?: number;
+  type: 'buy';
+  vaultId: string;
+  tokenIds: TokenIds;
+};
+export type SellArgs = {
+  network?: number;
+  type: 'sell';
+  vaultId: string;
+  tokenIds: TokenIds;
+};
+export type SwapArgs = {
+  network?: number;
+  type: 'swap';
+  vaultId: string;
+  mintTokenIds: TokenIds;
+  redeemTokenIds: TokenIds;
+};
+export type MintArgs = {
+  network?: number;
+  type: 'mint';
   vaultId: string;
-  buyTokenIds?: TokenIds;
-  sellTokenIds?: TokenIds;
+  tokenIds: TokenIds;
+};
+export type RedeemArgs = {
   network?: number;
+  type: 'redeem';
+  vaultId: string;
+  tokenIds: TokenIds;
 };
-type PriceArgs = CommonArgs & {
-  quoteType: 'price';
+export type TokenArgs = {
+  network?: number;
+  type: 'erc20';
+  buyToken: QuoteToken;
+  sellToken: QuoteToken;
+  buyAmount?: BigIntish;
+  sellAmount?: BigIntish;
 };
-type QuoteArgs = CommonArgs & {
-  quoteType: 'quote';
+
+type PriceArgs = { quoteType: 'price' };
+type QuoteArgs = {
+  quoteType?: 'quote';
   userAddress: Address;
   slippagePercentage?: number;
+  permit2?: Permit2Quote;
 };
 
-function fetchQuote(args: PriceArgs): Promise<MarketplacePrice>;
-function fetchQuote(args: QuoteArgs): Promise<MarketplaceQuote>;
-function fetchQuote(args: PriceArgs | QuoteArgs) {
+function fetchQuote(args: BuyArgs & PriceArgs): Promise<MarketplacePrice>;
+function fetchQuote(args: BuyArgs & QuoteArgs): Promise<MarketplaceQuote>;
+function fetchQuote(args: SellArgs & PriceArgs): Promise<MarketplacePrice>;
+function fetchQuote(args: SellArgs & QuoteArgs): Promise<MarketplaceQuote>;
+function fetchQuote(args: SwapArgs & PriceArgs): Promise<MarketplacePrice>;
+function fetchQuote(args: SwapArgs & QuoteArgs): Promise<MarketplaceQuote>;
+function fetchQuote(args: MintArgs & PriceArgs): Promise<MarketplacePrice>;
+function fetchQuote(args: MintArgs & QuoteArgs): Promise<MarketplaceQuote>;
+function fetchQuote(args: RedeemArgs & PriceArgs): Promise<MarketplacePrice>;
+function fetchQuote(args: RedeemArgs & QuoteArgs): Promise<MarketplaceQuote>;
+function fetchQuote(args: TokenArgs & PriceArgs): Promise<MarketplacePrice>;
+function fetchQuote(args: TokenArgs & QuoteArgs): Promise<MarketplaceQuote>;
+function fetchQuote(args: any) {
   const {
-    quoteType,
     type,
-    vaultId,
-    buyTokenIds: buyTokensAndAmounts,
+    quoteType = 'quote',
     network = config.network,
-    sellTokenIds: sellTokensAndAmounts,
+    vaultId,
+    userAddress,
+    slippagePercentage,
   } = args;
 
-  const buyTokenIds = buyTokensAndAmounts
-    ? getUniqueTokenIds(buyTokensAndAmounts)
-    : undefined;
-  const buyAmounts = buyTokensAndAmounts
-    ? getTokenIdAmounts(buyTokensAndAmounts)
-    : undefined;
-  const sellTokenIds = sellTokensAndAmounts
-    ? getUniqueTokenIds(sellTokensAndAmounts)
-    : undefined;
-  const sellAmounts = sellTokensAndAmounts
-    ? getTokenIdAmounts(sellTokensAndAmounts)
-    : undefined;
+  const url = `/${network}/quote/${type}`;
+
+  const query: Record<string, any> = {
+    vaultId,
+    userAddress,
+    slippagePercentage,
+  };
+
+  switch (type) {
+    case 'buy':
+    case 'redeem':
+      query.buyTokenIds = getUniqueTokenIds(args.tokenIds);
+      query.buyAmounts = getTokenIdAmounts(args.tokenIds);
+      break;
+    case 'sell':
+    case 'mint':
+      query.sellTokenIds = getUniqueTokenIds(args.tokenIds);
+      query.sellAmounts = getTokenIdAmounts(args.tokenIds);
+      break;
+    case 'swap':
+      query.sellTokenIds = getUniqueTokenIds(args.mintTokenIds);
+      query.sellAmounts = getTokenIdAmounts(args.mintTokenIds);
+      query.buyTokenIds = getUniqueTokenIds(args.redeemTokenIds);
+      query.buyAmounts = getTokenIdAmounts(args.redeemTokenIds);
+      break;
+    case 'erc20':
+      query.sellToken = args.sellToken;
+      query.sellAmount = args.sellAmount;
+      query.buyToken = args.buyToken;
+      query.buyAmount = args.buyAmount;
+      break;
+  }
 
-  if (quoteType === 'price') {
-    return queryApi<MarketplacePrice>({
-      url: `/${network}/price`,
-      query: {
-        type,
-        vaultId,
-        buyTokenIds,
-        buyAmounts,
-        sellTokenIds,
-        sellAmounts,
-      },
-    });
+  if (args.permit2 && quoteType === 'quote') {
+    query.permit2 = args.permit2;
   }
 
-  const { userAddress, slippagePercentage } = args;
+  type QuoteType = typeof quoteType extends 'price'
+    ? MarketplacePrice
+    : MarketplaceQuote;
 
-  return queryApi<MarketplaceQuote>({
-    url: `/${network}/quote`,
-    query: {
-      type,
-      vaultId,
-      buyTokenIds,
-      buyAmounts,
-      sellTokenIds,
-      sellAmounts,
-      userAddress,
-      slippagePercentage,
-    },
+  return queryApi<QuoteType>({
+    url,
+    query,
+    method: quoteType === 'price' ? 'GET' : 'POST',
   });
 }