@velora-dex/sdk 8.0.0

package/src/methods/nftOrders/helpers/misc.ts

@@ -0,0 +1,92 @@
+import {
+  BaseFetchUrl,
+  baseFetchUrlGetterFactory,
+  BaseFetchUrlInputConstructor,
+  MinFetchUrl,
+} from '../../common/orders/misc';
+import {
+  assetAddressToUint,
+  BuildNFTOrderDataInput,
+  NFTOrderData,
+} from './buildOrderData';
+
+// any number can be assigned to AssetType enum
+// https://github.com/Microsoft/TypeScript/issues/22311
+// export enum AssetType {
+//   ERC20 = 0,
+//   ERC1155 = 1,
+//   ERC721 = 2,
+// }
+
+export const AssetType = {
+  ERC20: 0,
+  ERC1155: 1,
+  ERC721: 2,
+} as const;
+
+export function sanitizeOrderData({
+  nonceAndMeta,
+  expiry,
+  makerAsset: _makerAsset,
+  takerAsset: _takerAsset,
+  maker,
+  taker,
+  makerAmount,
+  takerAmount,
+  makerAssetId,
+  takerAssetId,
+  // asset types provided when Order has them ,e.g. got Order by hash from API
+  makerAssetType,
+  takerAssetType,
+}: NFTOrderData &
+  Partial<Pick<BuildNFTOrderDataInput, 'makerAssetType' | 'takerAssetType'>> &
+  Record<string, any>): NFTOrderData {
+  const makerAsset =
+    makerAssetType !== undefined && _makerAsset.startsWith('0x')
+      ? assetAddressToUint(_makerAsset, makerAssetType)
+      : _makerAsset;
+  const takerAsset =
+    takerAssetType !== undefined && _takerAsset.startsWith('0x')
+      ? assetAddressToUint(_takerAsset, takerAssetType)
+      : _takerAsset;
+
+  return {
+    nonceAndMeta,
+    expiry,
+    makerAsset,
+    takerAsset,
+    maker,
+    taker,
+    makerAmount,
+    takerAmount,
+    makerAssetId,
+    takerAssetId,
+  };
+}
+
+/* 
+GET
+/nft/orders/:chainId/maker/:walletAddress
+/nft/orders/:chainId/taker/:walletAddress
+/nft/p2p/:chainId/maker/:walletAddress
+/nft/p2p/:chainId/taker/:walletAddress
+*/
+export type GetOrdersURLs = `${BaseFetchUrl<'nft'>}/${
+  | 'taker'
+  | 'maker'}/${string}`;
+
+/*
+GET
+/nft/order/:orderHash (get you p2p or orders)
+*/
+export type GetOrderURL = `${MinFetchUrl<'nft'>}/${string}`;
+
+/* 
+POST create order
+/nft/orders/:chainId/
+/nft/p2p/:chainId/
+*/
+export type PostOrderURLs = BaseFetchUrl<'nft'>;
+
+export const constructBaseFetchUrlGetter: BaseFetchUrlInputConstructor<'nft'> =
+  baseFetchUrlGetterFactory('nft');

package/src/methods/nftOrders/helpers/types.ts

@@ -0,0 +1,50 @@
+import type { Address } from '../../../types';
+import type { NFTOrderData } from './buildOrderData';
+import type { AssetType } from './misc';
+
+export type NFTOrderTransaction = {
+  hash: string;
+  event_type: 'OrderFilled' | 'OrderCancelled';
+};
+
+export type NFTOrderType = 'LIMIT' | 'P2P';
+
+export type NFTOrderToSend = NFTOrderData & {
+  signature: string;
+  permitMakerAsset?: string;
+};
+
+// display states such as EXPIRED and PARTIALLY_FILLLED derived on client side
+// returned by API but can be calculated too, EXPIRED == order.expiry < Date.now()/1000
+// PARTIALLY_FILLED == order.fillableBalance < order.makerAmount && order.fillableBalance !== '0'
+export type NFTOrderState = 'PENDING' | 'FULFILLED' | 'CANCELLED' | 'EXPIRED';
+
+export type NFTOrderFromAPI = NFTOrderToSend & {
+  chainId: number;
+  makerAsset: Address;
+  takerAsset: Address;
+  createdAt: number; // timestamp
+  updatedAt: number; // timestamp
+  makerAssetType: AssetTypeVariant;
+  takerAssetType: AssetTypeVariant;
+  makerBalance: string; // min(fillableBalance, allowance(maker), balance(maker)]
+  fillableBalance: string; // amount that remains to be filled
+  orderHash: string;
+  permitMakerAsset: null | string;
+  state: NFTOrderState;
+  takerFromMeta: string; // the intended receiver, eg receiving address of p2p order where `taker` would be augustus
+  type: NFTOrderType;
+  /** @description transaction with the last event pertaining to the order: OrderFilled or OrderCancelled */
+  transactionHash: null | string;
+  // not yet returned
+  // transactions: NftOrderTransaction[];
+};
+
+export type NFTOrdersApiResponse = {
+  orders: NFTOrderFromAPI[];
+};
+export type NFTOrderApiResponse = {
+  order: NFTOrderFromAPI;
+};
+
+export type AssetTypeVariant = (typeof AssetType)[keyof typeof AssetType];

package/src/methods/nftOrders/index.ts

@@ -0,0 +1,139 @@
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+} from '../../types';
+import type { NFTOrderToSend, NFTOrderFromAPI } from './helpers/types';
+import {
+  BuildNFTOrderFunctions,
+  BuildNFTOrderInput,
+  constructBuildNFTOrder,
+} from './buildOrder';
+import {
+  CancelNFTOrderFunctions,
+  constructCancelNFTOrder,
+} from './cancelOrder';
+import { constructGetNFTOrders, GetNFTOrdersFunctions } from './getOrders';
+import { constructPostNFTOrder, PostNFTOrderFunctions } from './postOrder';
+import { constructSignNFTOrder, SignNFTOrderFunctions } from './signOrder';
+import {
+  constructApproveTokenForNFTOrder,
+  ApproveTokenForNFTOrderFunctions,
+} from './approveForOrder';
+import {
+  GetNFTOrdersContractFunctions,
+  constructGetNFTOrdersContract,
+} from './getOrdersContract';
+import {
+  BuildNFTOrdersTxFunctions,
+  constructBuildNFTOrderTx,
+} from './transaction';
+
+type SubmitNFTOrder = (
+  buildNFTOrderParams: BuildNFTOrderInput,
+  extra?: { permitMakerAsset?: string },
+  requestParams?: RequestParameters
+) => Promise<NFTOrderFromAPI>;
+
+export type SubmitNFTOrderFuncs = {
+  submitNFTOrder: SubmitNFTOrder;
+  submitP2POrder: SubmitNFTOrder;
+};
+
+export const constructSubmitNFTOrder = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitNFTOrderFuncs => {
+  const { buildNFTOrder } = constructBuildNFTOrder(options);
+  const { signNFTOrder } = constructSignNFTOrder(options);
+  const { postNFTLimitOrder, postNFTP2POrder } = constructPostNFTOrder(options);
+
+  const prepareNFTOrder = async (
+    buildNFTOrderParams: BuildNFTOrderInput,
+    extra?: { permitMakerAsset?: string }
+  ): Promise<NFTOrderToSend> => {
+    const orderData = await buildNFTOrder(buildNFTOrderParams);
+    const signature = await signNFTOrder(orderData);
+
+    const orderWithSignature: NFTOrderToSend = {
+      ...orderData.data,
+      ...extra,
+      signature,
+    };
+
+    return orderWithSignature;
+  };
+
+  const submitNFTOrder: SubmitNFTOrder = async (
+    buildNFTOrderParams,
+    extra = {},
+    requestParams
+  ) => {
+    const orderWithSignature: NFTOrderToSend = await prepareNFTOrder(
+      buildNFTOrderParams,
+      extra
+    );
+
+    const newOrder = await postNFTLimitOrder(orderWithSignature, requestParams);
+
+    return newOrder;
+  };
+
+  const submitP2POrder: SubmitNFTOrder = async (
+    buildNFTOrderParams,
+    extra = {},
+    requestParams
+  ) => {
+    const orderWithSignature: NFTOrderToSend = await prepareNFTOrder(
+      buildNFTOrderParams,
+      extra
+    );
+
+    const newOrder = await postNFTP2POrder(orderWithSignature, requestParams);
+
+    return newOrder;
+  };
+
+  return { submitNFTOrder, submitP2POrder };
+};
+
+export type NFTOrderHandlers<T> = SubmitNFTOrderFuncs &
+  BuildNFTOrderFunctions &
+  SignNFTOrderFunctions &
+  PostNFTOrderFunctions &
+  GetNFTOrdersFunctions &
+  GetNFTOrdersContractFunctions &
+  BuildNFTOrdersTxFunctions &
+  CancelNFTOrderFunctions<T> &
+  ApproveTokenForNFTOrderFunctions<T>;
+
+/** @description construct SDK with every NFTOrders-related method, fetching from API and contract calls */
+export const constructAllNFTOrdersHandlers = <TxResponse>(
+  options: ConstructProviderFetchInput<
+    TxResponse,
+    'signTypedDataCall' | 'transactCall' | 'staticCall'
+  >
+): NFTOrderHandlers<TxResponse> => {
+  const NFTOrdersGetters = constructGetNFTOrders(options);
+  const NFTOrdersContractGetter = constructGetNFTOrdersContract(options);
+
+  const NFTOrdersSubmit = constructSubmitNFTOrder(options);
+  const NFTOrdersBuild = constructBuildNFTOrder(options);
+  const NFTOrdersSign = constructSignNFTOrder(options);
+  const NFTOrdersPost = constructPostNFTOrder(options);
+
+  const NFTOrdersCancel = constructCancelNFTOrder(options);
+  const NFTOrdersApproveToken = constructApproveTokenForNFTOrder(options);
+
+  const NFTOrdersBuildTx = constructBuildNFTOrderTx(options);
+
+  return {
+    ...NFTOrdersGetters,
+    ...NFTOrdersContractGetter,
+    ...NFTOrdersSubmit,
+    ...NFTOrdersBuild,
+    ...NFTOrdersSign,
+    ...NFTOrdersPost,
+    ...NFTOrdersCancel,
+    ...NFTOrdersApproveToken,
+    ...NFTOrdersBuildTx,
+  };
+};

package/src/methods/nftOrders/postOrder.ts

@@ -0,0 +1,71 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { constructBaseFetchUrlGetter, PostOrderURLs } from './helpers/misc';
+import type {
+  NFTOrderToSend,
+  NFTOrderType,
+  NFTOrderFromAPI,
+  NFTOrderApiResponse,
+} from './helpers/types';
+
+type PostNFTOrder = (
+  NFTOrderWithSignatureAndPermit: NFTOrderToSend,
+  requestParams?: RequestParameters
+) => Promise<NFTOrderFromAPI>;
+
+export type PostNFTOrderFunctions = {
+  postNFTLimitOrder: PostNFTOrder;
+  postNFTP2POrder: PostNFTOrder;
+};
+
+export const constructPostNFTOrder = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): PostNFTOrderFunctions => {
+  const getBaseFetchURLByOrderType = constructBaseFetchUrlGetter({
+    apiURL,
+    chainId,
+  });
+
+  const postTypedOrder = async (
+    NFTOrderWithSignatureAndPermit: NFTOrderToSend,
+    type: NFTOrderType,
+    requestParams?: RequestParameters
+  ): Promise<NFTOrderFromAPI> => {
+    const fetchURL = getBaseFetchURLByOrderType(type);
+
+    // @TODO check API return matches
+    const { order: newOrder } = await fetcher<
+      NFTOrderApiResponse,
+      PostOrderURLs
+    >({
+      url: fetchURL,
+      method: 'POST',
+      data: NFTOrderWithSignatureAndPermit,
+      requestParams,
+    });
+
+    return { ...newOrder };
+  };
+
+  const postNFTLimitOrder: PostNFTOrder = (
+    NFTOrderWithSignatureAndPermit,
+    requestParams
+  ) => {
+    return postTypedOrder(
+      NFTOrderWithSignatureAndPermit,
+      'LIMIT',
+      requestParams
+    );
+  };
+
+  const postNFTP2POrder: PostNFTOrder = (
+    NFTOrderWithSignatureAndPermit,
+    requestParams
+  ) => {
+    return postTypedOrder(NFTOrderWithSignatureAndPermit, 'P2P', requestParams);
+  };
+
+  return { postNFTLimitOrder, postNFTP2POrder };
+};

package/src/methods/nftOrders/signOrder.ts

@@ -0,0 +1,29 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import type { SignableNFTOrderData } from './buildOrder';
+import { sanitizeOrderData } from './helpers/misc';
+
+export type SignNFTOrderFunctions = {
+  signNFTOrder: (signableOrderData: SignableNFTOrderData) => Promise<string>;
+};
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructSignNFTOrder = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller'
+  >
+): SignNFTOrderFunctions => {
+  const signNFTOrder: SignNFTOrderFunctions['signNFTOrder'] = (typedData) => {
+    // types allow to pass OrderData & extra_stuff, but tx will break like that
+    const typedDataOnly: SignableNFTOrderData = {
+      ...typedData,
+      // here assetType isn't provided, SignableData must already have corrent BigIntAsString
+      // @TODO consider using `template_${types}` for Address, likely bad idea when considering 3rd-party code
+      data: sanitizeOrderData(typedData.data),
+    };
+    return options.contractCaller.signTypedDataCall(typedDataOnly);
+  };
+
+  return { signNFTOrder };
+};

package/src/methods/nftOrders/transaction.ts

@@ -0,0 +1,234 @@
+import type { Address, ConstructFetchInput, OptimalRate } from '../../types';
+
+import { assert } from 'ts-essentials';
+import {
+  API_URL,
+  SwapSide,
+  ContractMethod,
+  DEFAULT_VERSION,
+} from '../../constants';
+import {
+  BuildNFTOrderTxInput,
+  BuildOptions,
+  BuildSwapAndNFTOrderTxInput,
+  TransactionParams,
+  constructBuildTx,
+} from '../swap/transaction';
+import { constructGetRate, GetRateInput, RateOptions } from '../swap/rates';
+import type { BigIntAsString, NFTOrderData } from './buildOrder';
+import { isFilledArray } from '../../helpers/misc';
+import type { RequestParameters } from '../../types';
+type MinBuildSwapAndNFTOrderTxInput = Omit<
+  // these are derived from `orders`
+  BuildSwapAndNFTOrderTxInput,
+  'srcToken' | 'srcAmount' | 'destToken' | 'destDecimals'
+>;
+
+type BuildSwapAndNFTOrdersTx = (
+  params: MinBuildSwapAndNFTOrderTxInput,
+  options?: BuildOptions,
+  requestParams?: RequestParameters
+) => Promise<TransactionParams>;
+
+type MinBuildNFTOrderTxInput = Omit<
+  BuildNFTOrderTxInput,
+  // these are derived from `orders`
+  'srcToken' | 'srcAmount' | 'destToken' | 'slippage'
+  // `slippage` doesn't participate as we derive `srcAmount` already
+>;
+
+type BuildNFTOrdersTx = (
+  params: MinBuildNFTOrderTxInput,
+  options?: BuildOptions,
+  requestParams?: RequestParameters
+) => Promise<TransactionParams>;
+
+export type BuildNFTOrdersTxFunctions = {
+  getNFTOrdersRate: GetNFTOrdersRate;
+  buildNFTOrderTx: BuildNFTOrdersTx;
+  buildSwapAndNFTOrderTx: BuildSwapAndNFTOrdersTx;
+};
+
+type GetNFTOrdersRate = (
+  // `amount`, if given, must equal the total of the orders' `takerAmounts`
+  options: Omit<GetRateInput, 'amount' | 'side'> & { amount?: string },
+  orders: CheckableOrderData[],
+  requestParams?: RequestParameters
+) => Promise<OptimalRate>;
+
+export const constructBuildNFTOrderTx = ({
+  apiURL = API_URL,
+  version = DEFAULT_VERSION,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): BuildNFTOrdersTxFunctions => {
+  const { buildTx: buildSwapTx } = constructBuildTx({
+    apiURL,
+    version,
+    chainId,
+    fetcher,
+  });
+
+  const { getRate: getSwapAndNFTOrderRate } = constructGetRate({
+    apiURL,
+    version,
+    chainId,
+    fetcher,
+  });
+
+  //  returns priceRoute that would allow from swap from srcToken to destToken(=order.takerAsset) followed by filling NFT orders
+  const getNFTOrdersRate: GetNFTOrdersRate = async (
+    { srcToken, destToken, amount, options: _options = {}, ...rest },
+    orders,
+    requestParams
+  ) => {
+    assert(orders.length > 0, 'must pass at least 1 order');
+
+    const { totalTakerAmount, takerAsset } = checkAndParseOrders(orders);
+
+    assert(
+      takerAsset.toLowerCase() === destToken.toLowerCase(),
+      'All orders must have the same takerAsset as destToken'
+    );
+
+    const takerAmountString = totalTakerAmount.toString(10);
+
+    if (amount) {
+      assert(
+        amount === takerAmountString,
+        "`amount` must equal the total of the orders' `takerAmounts`"
+      );
+    }
+
+    // The pricing must use includeContractMethods=simpleBuy and side=BUY
+    const options: RateOptions = {
+      ..._options,
+      includeContractMethods: [ContractMethod.simpleBuy],
+    };
+
+    const side = SwapSide.BUY;
+
+    const rateInput: GetRateInput = {
+      ...rest,
+      srcToken,
+      destToken,
+      amount: takerAmountString,
+      side,
+      options,
+    };
+
+    // priceRoute
+    const optimalRate = await getSwapAndNFTOrderRate(rateInput, requestParams);
+    return optimalRate;
+  };
+
+  // derive srcToken, destToken and srcAmount from orders[]
+  const buildNFTOrderTx: BuildNFTOrdersTx = (
+    params,
+    options,
+    requestParams
+  ) => {
+    const { takerAsset, totalTakerAmount } = checkAndParseOrders(params.orders);
+
+    const fillParams: BuildNFTOrderTxInput = {
+      ...params,
+      // taker supplies takerAsset
+      srcToken: takerAsset,
+      srcAmount: totalTakerAmount.toString(10),
+      // taker gets makerAsset in the end
+      destToken: 'NFT', // support any NFT
+    };
+
+    return buildSwapTx(fillParams, options, requestParams);
+  };
+  const buildSwapAndNFTOrderTx: BuildSwapAndNFTOrdersTx = (
+    params,
+    options,
+    requestParams
+  ) => {
+    checkAndParseOrders(params.orders);
+
+    const fillParams: BuildSwapAndNFTOrderTxInput = {
+      ...params,
+      // taker supplies srcToken
+      srcToken: params.priceRoute.srcToken,
+      // one or the other
+      ...(params.slippage
+        ? { slippage: params.slippage }
+        : //                                        may sneak in as part of `params`
+          { srcAmount: params.priceRoute.srcAmount, slippage: undefined }),
+      destToken: 'NFT', // support any NFT,
+      destDecimals: params.priceRoute.destDecimals,
+    };
+    return buildSwapTx(fillParams, options, requestParams);
+  };
+
+  return {
+    getNFTOrdersRate,
+    buildNFTOrderTx,
+    buildSwapAndNFTOrderTx,
+  };
+};
+
+type CheckAndParseOrdersResult = Omit<CheckableOrderData, 'takerAmount'> & {
+  totalTakerAmount: bigint;
+};
+
+type CheckableOrderData = Pick<
+  NFTOrderData,
+  'takerAsset' | 'makerAsset' | 'takerAmount' | 'maker'
+> & { taker?: NFTOrderData['taker'] };
+
+function checkAndParseOrders(
+  orders: CheckableOrderData[]
+): CheckAndParseOrdersResult {
+  assert(isFilledArray(orders), 'must pass at least 1 order');
+
+  const { takerAssetsSet, makerAssetsSet, totalTakerAmount } = orders.reduce<
+    Record<'takerAssetsSet' | 'makerAssetsSet', Set<string>> & {
+      totalTakerAmount: bigint;
+    }
+  >(
+    (accum, order) => {
+      accum.takerAssetsSet.add(order.takerAsset.toLowerCase());
+      accum.makerAssetsSet.add(order.makerAsset.toLowerCase());
+
+      accum.totalTakerAmount =
+        accum.totalTakerAmount + BigInt(order.takerAmount);
+      return accum;
+    },
+    {
+      takerAssetsSet: new Set(),
+      makerAssetsSet: new Set(),
+      totalTakerAmount: BigInt(0),
+    }
+  );
+
+  assert(
+    takerAssetsSet.size === 1,
+    'All orders must have the same takerAsset as destToken'
+  );
+  assert(makerAssetsSet.size === 1, 'All orders must have the same makerAsset');
+
+  const [{ maker, taker, makerAsset, takerAsset }] = orders;
+
+  return {
+    totalTakerAmount,
+    maker,
+    taker,
+    makerAsset: makerAsset.startsWith('0x')
+      ? makerAsset
+      : uintToAssetAddress(makerAsset),
+    takerAsset: takerAsset.startsWith('0x')
+      ? takerAsset
+      : uintToAssetAddress(takerAsset),
+  };
+}
+
+// extract asset address from makerAsset or takerAsset packed number encoded to contain AssetType
+function uintToAssetAddress(assetUint: BigIntAsString): Address {
+  return (
+    '0x' +
+    (BigInt(assetUint) & ((BigInt(1) << BigInt(160)) - BigInt(1))).toString(16)
+  );
+}