@velora-dex/sdk 8.0.0

package/src/methods/limitOrders/transaction.ts

@@ -0,0 +1,231 @@
+import type { ConstructFetchInput, OptimalRate } from '../../types';
+
+import { assert } from 'ts-essentials';
+import {
+  API_URL,
+  SwapSide,
+  ContractMethod,
+  DEFAULT_VERSION,
+} from '../../constants';
+import {
+  BuildLimitOrderTxInput,
+  BuildOptions,
+  BuildSwapAndLimitOrderTxInput,
+  TransactionParams,
+  constructBuildTx,
+} from '../swap/transaction';
+import { constructGetRate, GetRateInput, RateOptions } from '../swap/rates';
+import type { OrderData } from './buildOrder';
+import { isFilledArray } from '../../helpers/misc';
+import type { RequestParameters } from '../../types';
+
+type MinBuildSwapAndLimitOrderTxInput = Omit<
+  // these are derived from `orders`
+  BuildSwapAndLimitOrderTxInput,
+  'srcToken' | 'srcAmount' | 'destToken' | 'destDecimals'
+>;
+
+type BuildSwapAndLimitOrdersTx = (
+  params: MinBuildSwapAndLimitOrderTxInput,
+  options?: BuildOptions,
+  requestParams?: RequestParameters
+) => Promise<TransactionParams>;
+
+type MinBuildLimitOrderTxInput = Omit<
+  BuildLimitOrderTxInput,
+  // these are derived from `orders`
+  'srcToken' | 'srcAmount' | 'destToken' | 'slippage'
+  // `slippage` doesn't participate as we derive `srcAmount` already
+>;
+
+type BuildLimitOrdersTx = (
+  params: MinBuildLimitOrderTxInput,
+  options?: BuildOptions,
+  requestParams?: RequestParameters
+) => Promise<TransactionParams>;
+
+export type BuildLimitOrdersTxFunctions = {
+  getLimitOrdersRate: GetLimitOrdersRate;
+  buildLimitOrderTx: BuildLimitOrdersTx;
+  buildSwapAndLimitOrderTx: BuildSwapAndLimitOrdersTx;
+};
+
+type GetLimitOrdersRate = (
+  // `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 constructBuildLimitOrderTx = ({
+  apiURL = API_URL,
+  version = DEFAULT_VERSION,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): BuildLimitOrdersTxFunctions => {
+  const { buildTx: buildSwapTx } = constructBuildTx({
+    apiURL,
+    chainId,
+    fetcher,
+    version,
+  });
+
+  const { getRate: getSwapAndLimitOrderRate } = constructGetRate({
+    apiURL,
+    version,
+    chainId,
+    fetcher,
+  });
+
+  //  returns priceRoute that would allow to swap from srcToken to destToken(=order.takerAsset) followed by filling limit orders
+  const getLimitOrdersRate: GetLimitOrdersRate = 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 getSwapAndLimitOrderRate(
+      rateInput,
+      requestParams
+    );
+    return optimalRate;
+  };
+
+  // derive srcToken, destToken and srcAmount from orders[]
+  const buildLimitOrderTx: BuildLimitOrdersTx = (
+    params,
+    options,
+    requestParams
+  ) => {
+    const { makerAsset, takerAsset, totalTakerAmount } = checkAndParseOrders(
+      params.orders
+    );
+
+    const fillParams: BuildLimitOrderTxInput = {
+      ...params,
+      // taker supplies takerAsset
+      srcToken: takerAsset,
+      // no `slippage` in `params`
+      srcAmount: totalTakerAmount.toString(10),
+      // taker gets makerAsset in the end
+      destToken: makerAsset,
+    };
+
+    return buildSwapTx(fillParams, options, requestParams);
+  };
+
+  const buildSwapAndLimitOrderTx: BuildSwapAndLimitOrdersTx = (
+    params,
+    options,
+    requestParams
+  ) => {
+    const { makerAsset } = checkAndParseOrders(params.orders);
+
+    const fillParams: BuildSwapAndLimitOrderTxInput = {
+      ...params,
+      // taker supplies srcToken
+      srcToken: params.priceRoute.srcToken,
+      // which is swapped for makerAsset, that would go towards filling the orders
+      destToken: makerAsset,
+      destDecimals: params.priceRoute.destDecimals,
+      // one or the other
+      ...(params.slippage
+        ? { slippage: params.slippage }
+        : //                                        may sneak in as part of `params`
+          { srcAmount: params.priceRoute.srcAmount, slippage: undefined }),
+    };
+
+    return buildSwapTx(fillParams, options, requestParams);
+  };
+
+  return {
+    getLimitOrdersRate,
+    buildLimitOrderTx,
+    buildSwapAndLimitOrderTx,
+  };
+};
+
+type CheckAndParseOrdersResult = Omit<CheckableOrderData, 'takerAmount'> & {
+  totalTakerAmount: bigint;
+};
+
+type CheckableOrderData = Pick<
+  OrderData,
+  'takerAsset' | 'makerAsset' | 'takerAmount' | 'maker'
+> & { taker?: OrderData['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,
+    takerAsset,
+  };
+}

package/src/methods/nftOrders/approveForOrder.ts

@@ -0,0 +1,79 @@
+import type { ApproveToken } from '../../helpers/approve';
+import type { ExtractAbiMethodNames } from '../../helpers/misc';
+import type {
+  Address,
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import { constructApproveToken } from '../swap/approve';
+import { constructGetNFTOrdersContract } from './getOrdersContract';
+
+type ApproveNFT<T> = (
+  tokenAddress: Address,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type ApproveTokenForNFTOrderFunctions<T> = {
+  /** @description approving AugustusSwapper as spender for takerAsset (ERC20) for Limit Orders that will be executed through it */
+  approveERC20ForNFTOrder: ApproveToken<T>;
+  /** @description approving AugustusRFQ as spender for makerAsset (NFT) */
+  approveNFTForNFTOrder: ApproveNFT<T>;
+};
+
+const MinNFTAbi = [
+  {
+    constant: false,
+    inputs: [
+      {
+        name: '_operator',
+        type: 'address',
+      },
+      {
+        name: '_approved',
+        type: 'bool',
+      },
+    ],
+    name: 'setApprovalForAll',
+    outputs: [],
+    payable: false,
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;
+
+type ApprovalMethods = ExtractAbiMethodNames<typeof MinNFTAbi>;
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructApproveTokenForNFTOrder = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): ApproveTokenForNFTOrderFunctions<T> => {
+  // approving TokenTransaferProxy as for the swap
+  const { approveToken: approveERC20ForNFTOrder } =
+    constructApproveToken(options);
+
+  const { getNFTOrdersContract } = constructGetNFTOrdersContract(options);
+
+  const approveNFTForNFTOrder: ApproveNFT<T> = async (
+    tokenAddress,
+    overrides = {},
+    requestParams
+  ) => {
+    // @TODO add approvetakerAssetForNFTOrder to use AugustusSwapper as spender if we ever have SELL NFT swaps
+    const AugustusRFQ = await getNFTOrdersContract(requestParams);
+
+    const res = await options.contractCaller.transactCall<ApprovalMethods>({
+      address: tokenAddress,
+      abi: MinNFTAbi,
+      contractMethod: 'setApprovalForAll',
+      args: [AugustusRFQ, true],
+      overrides,
+    });
+
+    return res;
+  };
+
+  return { approveERC20ForNFTOrder, approveNFTForNFTOrder };
+};

package/src/methods/nftOrders/buildOrder.ts

@@ -0,0 +1,52 @@
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { constructGetSpender } from '../swap/spender';
+import {
+  buildOrderData,
+  BuildNFTOrderDataInput,
+  SignableNFTOrderData,
+} from './helpers/buildOrderData';
+export * from './helpers/buildOrderData';
+
+export type BuildNFTOrderInput = Omit<
+  BuildNFTOrderDataInput,
+  'chainId' | 'verifyingContract' | 'AugustusAddress'
+>;
+
+type BuildNFTOrder = (
+  buildNFTOrderParams: BuildNFTOrderInput,
+  requestParams?: RequestParameters
+) => Promise<SignableNFTOrderData>;
+
+export type BuildNFTOrderFunctions = {
+  /** @description Build Orders that will be excuted through AugustusSwapper */
+  buildNFTOrder: BuildNFTOrder;
+};
+
+export const constructBuildNFTOrder = (
+  options: ConstructFetchInput
+): BuildNFTOrderFunctions => {
+  const { chainId } = options;
+
+  // getContracts is cached internally for the same instance of SDK
+  // so should persist across same apiUrl & network
+  const { getContracts } = constructGetSpender(options);
+
+  const buildNFTOrder: BuildNFTOrder = async (
+    buildNFTOrderParams,
+    requestParams
+  ) => {
+    const { AugustusSwapper: AugustusAddress, AugustusRFQ: verifyingContract } =
+      await getContracts(requestParams);
+
+    return buildOrderData({
+      ...buildNFTOrderParams,
+      chainId,
+      verifyingContract,
+      AugustusAddress,
+    });
+  };
+
+  return {
+    buildNFTOrder,
+  };
+};

package/src/methods/nftOrders/cancelOrder.ts

@@ -0,0 +1,23 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import {
+  CancelOrder,
+  CancelOrderBulk,
+  constructCancelLimitOrder,
+} from '../limitOrders/cancelOrder';
+
+export type CancelNFTOrderFunctions<T> = {
+  cancelNFTOrder: CancelOrder<T>;
+  cancelNFTOrderBulk: CancelOrderBulk<T>;
+};
+
+// should work the same as for LimitOrders
+export const constructCancelNFTOrder = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): CancelNFTOrderFunctions<T> => {
+  const { cancelLimitOrder, cancelLimitOrderBulk } =
+    constructCancelLimitOrder(options);
+  return {
+    cancelNFTOrder: cancelLimitOrder,
+    cancelNFTOrderBulk: cancelLimitOrderBulk,
+  };
+};

package/src/methods/nftOrders/getOrders.ts

@@ -0,0 +1,84 @@
+import { API_URL } from '../../constants';
+import type {
+  Address,
+  ConstructFetchInput,
+  RequestParameters,
+} from '../../types';
+import {
+  constructBaseFetchUrlGetter,
+  GetOrdersURLs,
+  GetOrderURL,
+} from './helpers/misc';
+import type {
+  NFTOrderFromAPI,
+  NFTOrdersApiResponse,
+  NFTOrderType,
+} from './helpers/types';
+
+//                     get orders by `maker` or `taker`
+export type NFTOrdersUserParams =
+  | { maker: Address; type: NFTOrderType }
+  | { taker: Address; type: NFTOrderType };
+type GetNFTOrderByHash = (
+  orderHash: string,
+  requestParams?: RequestParameters
+) => Promise<NFTOrderFromAPI>;
+type GetNFTOrders = (
+  userParams: NFTOrdersUserParams,
+  requestParams?: RequestParameters
+) => Promise<NFTOrdersApiResponse>;
+
+export type GetNFTOrdersFunctions = {
+  getNFTOrders: GetNFTOrders;
+  getNFTOrderByHash: GetNFTOrderByHash;
+};
+
+export const constructGetNFTOrders = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): GetNFTOrdersFunctions => {
+  const getBaseFetchURLByOrderType = constructBaseFetchUrlGetter({
+    apiURL,
+    chainId,
+  });
+
+  const getNFTOrders: GetNFTOrders = async (userParams, requestParams) => {
+    const baseFetchURL = getBaseFetchURLByOrderType(userParams.type);
+    const userURL =
+      'maker' in userParams
+        ? (`maker/${userParams.maker}` as const)
+        : (`taker/${userParams.taker}` as const);
+    const fetchURL = `${baseFetchURL}/${userURL}` as const;
+
+    const response = await fetcher<NFTOrdersApiResponse, GetOrdersURLs>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    // without any extra calls, return  what API returns
+    return response;
+  };
+
+  const getNFTOrderByHash: GetNFTOrderByHash = async (
+    orderHash,
+    requestParams
+  ) => {
+    const baseFetchURL = getBaseFetchURLByOrderType();
+    const fetchURL = `${baseFetchURL}/${orderHash}` as const;
+
+    const order = await fetcher<NFTOrderFromAPI, GetOrderURL>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return order;
+  };
+
+  return {
+    getNFTOrders,
+    getNFTOrderByHash,
+  };
+};

package/src/methods/nftOrders/getOrdersContract.ts

@@ -0,0 +1,24 @@
+import type { ConstructFetchInput } from '../../types';
+import { constructGetSpender, GetSpender } from '../swap/spender';
+
+export type GetNFTOrdersContractFunctions = {
+  getNFTOrdersContract: GetSpender;
+  getTokenTransferProxy: GetSpender;
+};
+
+// should work the same as LimitOrders
+export const constructGetNFTOrdersContract = (
+  options: ConstructFetchInput
+): GetNFTOrdersContractFunctions => {
+  // analogous to getSpender() but for Limit Orders Contract = AugustusRFQ
+
+  const {
+    getSpender: getTokenTransferProxy,
+    getAugustusRFQ: getNFTOrdersContract,
+  } = constructGetSpender(options);
+
+  return {
+    getNFTOrdersContract,
+    getTokenTransferProxy,
+  };
+};

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

@@ -0,0 +1,131 @@
+import type { Address } from '../../../types';
+import type { AssetTypeVariant } from './types';
+import {
+  Domain,
+  name,
+  version,
+  ZERO_ADDRESS,
+} from '../../common/orders/buildOrderData';
+import { getRandomInt } from '../../../helpers/misc';
+
+const OrderNFT = [
+  { name: 'nonceAndMeta', type: 'uint256' },
+  { name: 'expiry', type: 'uint128' },
+  { name: 'makerAsset', type: 'uint256' },
+  { name: 'makerAssetId', type: 'uint256' },
+  { name: 'takerAsset', type: 'uint256' },
+  { name: 'takerAssetId', type: 'uint256' },
+  { name: 'maker', type: 'address' },
+  { name: 'taker', type: 'address' },
+  { name: 'makerAmount', type: 'uint256' },
+  { name: 'takerAmount', type: 'uint256' },
+];
+
+export interface BuildNFTOrderDataInput {
+  chainId: number;
+  verifyingContract: Address;
+  nonce?: number;
+  expiry: number;
+  makerAsset: Address;
+  takerAsset: Address;
+  makerAmount: string;
+  takerAmount: string;
+  /** @description NFT Token id, will default to 0 (ERC20), provide for NFT */
+  makerAssetId: string; // required when BUYing NFT
+  /** @description NFT Token id, will default to 0 (ERC20), provide for NFT */
+  takerAssetId?: string;
+  /** @description Token type: ERC20 = 0, ERC1155 = 1, ERC721 = 2 */
+  makerAssetType: AssetTypeVariant;
+  /** @description Token type: ERC20 = 0, ERC1155 = 1, ERC721 = 2 */
+  takerAssetType: AssetTypeVariant;
+  maker: Address;
+  // OrderData.taker must be Augustus for p2p limitOrders to involve swap through Augustus
+  // this is the actual user taker which will go into nonceAndMeta
+  taker?: Address;
+  AugustusAddress: Address;
+}
+
+export type SignableNFTOrderData = {
+  types: { OrderNFT: typeof OrderNFT };
+  domain: Domain;
+  data: NFTOrderData;
+};
+
+export type BigIntAsString = string;
+
+export type NFTOrderData = {
+  expiry: number;
+  // '1' when trading 1 NFT token
+  makerAmount: BigIntAsString;
+  makerAsset: BigIntAsString;
+  // '0' indicates ERC20
+  makerAssetId: BigIntAsString;
+  // '1' when trading 1 NFT token
+  takerAmount: BigIntAsString;
+  takerAsset: BigIntAsString;
+  // '0' indicates ERC20
+  takerAssetId: BigIntAsString;
+  nonceAndMeta: BigIntAsString;
+  maker: Address;
+  taker: Address;
+};
+
+export function buildOrderData({
+  chainId,
+  verifyingContract,
+  nonce = getRandomInt(),
+  expiry,
+  makerAsset: _makerAssetAddress,
+  takerAsset: _takerAssetAddress,
+  makerAmount,
+  takerAmount,
+  makerAssetId,
+  takerAssetId = '0',
+  makerAssetType,
+  takerAssetType,
+  maker,
+  AugustusAddress,
+  // if taker is specified -- p2p order for that taker only to fill through Augustus -- taker = Augustus, takerInNonce = _taker
+  // if taker is not specified -- limitOrder for anyone to fill through Augustus -- taker = Augustus, takerInNonce = Zero
+  taker: takerInNonce = ZERO_ADDRESS, //@TODO allow Orders outside of AugustusRFQ
+}: BuildNFTOrderDataInput): SignableNFTOrderData {
+  // first 160 bits is taker address (for p2p orders),
+  // or 0 for limitOrders, so that anyone can be the taker of the Order
+  const nonceAndMeta = (
+    BigInt(takerInNonce) +
+    (BigInt(nonce) << BigInt(160))
+  ).toString(10);
+
+  const makerAsset = assetAddressToUint(_makerAssetAddress, makerAssetType);
+
+  const takerAsset = assetAddressToUint(_takerAssetAddress, takerAssetType);
+
+  const orderNFT: NFTOrderData = {
+    nonceAndMeta,
+    expiry,
+    makerAsset,
+    takerAsset,
+    maker,
+    taker: AugustusAddress,
+    makerAmount,
+    takerAmount,
+    makerAssetId,
+    takerAssetId,
+  };
+
+  return {
+    types: { OrderNFT },
+    domain: { name, version, chainId, verifyingContract },
+    data: orderNFT,
+  };
+}
+
+// create a packed number that contains assetAddress and AssetType
+export function assetAddressToUint(
+  assetAddress: Address,
+  assetType: AssetTypeVariant
+): BigIntAsString {
+  return (BigInt(assetAddress) + (BigInt(assetType) << BigInt(160))).toString(
+    10
+  );
+}