@velora-dex/sdk 8.0.0

package/src/methods/limitOrders/buildOrder.ts

@@ -0,0 +1,56 @@
+import { DEFAULT_VERSION } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import { constructGetSpender } from '../swap/spender';
+import {
+  buildOrderData,
+  BuildOrderDataInput,
+  SignableOrderData,
+} from './helpers/buildOrderData';
+export * from './helpers/buildOrderData';
+
+export type BuildLimitOrderInput = Omit<
+  BuildOrderDataInput,
+  'chainId' | 'verifyingContract' | 'AugustusAddress' | 'AppVersion'
+>;
+
+type BuildLimitOrder = (
+  buildLimitOrderParams: BuildLimitOrderInput,
+  requestParams?: RequestParameters
+) => Promise<SignableOrderData>;
+
+export type BuildLimitOrderFunctions = {
+  /** @description Build Orders that will be excuted through AugustusSwapper */
+  buildLimitOrder: BuildLimitOrder;
+};
+
+export const constructBuildLimitOrder = (
+  options: ConstructFetchInput
+): BuildLimitOrderFunctions => {
+  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 buildLimitOrder: BuildLimitOrder = async (
+    buildLimitOrderParams,
+    requestParams
+  ) => {
+    const { AugustusSwapper: AugustusAddress, AugustusRFQ: verifyingContract } =
+      await getContracts(requestParams);
+
+    const AppVersion = options.version ?? DEFAULT_VERSION;
+
+    return buildOrderData({
+      ...buildLimitOrderParams,
+      chainId,
+      verifyingContract,
+      AugustusAddress,
+      AppVersion,
+    });
+  };
+
+  return {
+    buildLimitOrder,
+  };
+};

package/src/methods/limitOrders/cancelOrder.ts

@@ -0,0 +1,111 @@
+import type { ExtractAbiMethodNames } from '../../helpers/misc';
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import { constructGetSpender } from '../swap/spender';
+
+export type CancelOrder<T> = (
+  orderHash: string,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type CancelOrderBulk<T> = (
+  orderHashes: string[],
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type CancelLimitOrderFunctions<T> = {
+  cancelLimitOrder: CancelOrder<T>;
+  cancelLimitOrderBulk: CancelOrderBulk<T>;
+};
+
+// much smaller than the whole AugustusRFQ_ABI
+const MinAugustusRFQAbi = [
+  {
+    inputs: [
+      {
+        internalType: 'bytes32',
+        name: 'orderHash',
+        type: 'bytes32',
+      },
+    ],
+    name: 'cancelOrder',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'bytes32[]',
+        name: 'orderHashes',
+        type: 'bytes32[]',
+      },
+    ],
+    name: 'cancelOrders',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;
+
+type AvailableMethods = ExtractAbiMethodNames<typeof MinAugustusRFQAbi>;
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructCancelLimitOrder = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): CancelLimitOrderFunctions<T> => {
+  // getAugustusRFQ is cached internally for the same instance of SDK
+  // so should persist across same apiUrl & network
+  const { getAugustusRFQ } = constructGetSpender(options);
+
+  const cancelLimitOrder: CancelOrder<T> = async (
+    orderHash,
+    overrides = {},
+    requestParams
+  ) => {
+    const verifyingContract = await getAugustusRFQ(requestParams);
+
+    const res = await options.contractCaller.transactCall<AvailableMethods>({
+      // @CHECK if verifyingContract is the one we need to approve
+      // maybe a Proxy in-between
+      address: verifyingContract,
+      abi: MinAugustusRFQAbi,
+      contractMethod: 'cancelOrder',
+      args: [orderHash],
+      overrides,
+    });
+
+    return res;
+  };
+
+  const cancelLimitOrderBulk: CancelOrderBulk<T> = async (
+    orderHashes,
+    overrides = {},
+    requestParams
+  ) => {
+    const verifyingContract = await getAugustusRFQ(requestParams);
+
+    const res = await options.contractCaller.transactCall<AvailableMethods>({
+      // @CHECK if verifyingContract is the one we need to approve
+      // maybe a Proxy in-between
+      address: verifyingContract,
+      abi: MinAugustusRFQAbi,
+      contractMethod: 'cancelOrders',
+      args: [orderHashes],
+      overrides,
+    });
+
+    return res;
+  };
+
+  return {
+    cancelLimitOrder,
+    cancelLimitOrderBulk,
+  };
+};

package/src/methods/limitOrders/fillOrderDirectly.ts

@@ -0,0 +1,277 @@
+import type { ExtractAbiMethodNames } from '../../helpers/misc';
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import type { OrderData } from './buildOrder';
+import { constructGetSpender } from '../swap/spender';
+import { sanitizeOrderData } from './helpers/misc';
+import {
+  encodeDAIlikePermitFunctionInput,
+  encodeEIP_2612PermitFunctionInput,
+} from '../common/orders/encoding';
+
+export type FillOrderDirectlyFunctions<T> = {
+  fillOrderDirectly: FillOrderDirectly<T>;
+};
+
+type TakerPermitEncodedInputParams = {
+  encodedPermitParams: string;
+};
+
+type TakerPermit1Data = {
+  signature: string;
+  deadline: number | bigint | string;
+  amount?: string;
+  isDaiPermit?: false;
+};
+
+type TakerDaiPermitData = {
+  signature: string;
+  expiry: number | bigint | string;
+  nonce: number | bigint | string;
+  isDaiPermit: true;
+};
+
+type TakerPermitObject =
+  | TakerPermitEncodedInputParams
+  | TakerPermit1Data
+  | TakerDaiPermitData;
+
+export type FillOrderDirectly<T> = (
+  orderFillData: {
+    order: OrderData;
+    signature: string;
+    /** @description Permit1 data or DAI Permit data or Token.parmit() input params encoded; Permit by taker for Taker Asset with AugustusRFQ as spender */
+    takerPermit?: TakerPermitObject;
+  },
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+// much smaller than the whole AugustusRFQ_ABI
+const MinAugustusRFQAbi = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: 'uint256',
+            name: 'nonceAndMeta',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint128',
+            name: 'expiry',
+            type: 'uint128',
+          },
+          {
+            internalType: 'address',
+            name: 'makerAsset',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'takerAsset',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'maker',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'taker',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'makerAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'takerAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct AugustusRFQ.Order',
+        name: 'order',
+        type: 'tuple',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+    ],
+    name: 'fillOrder',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: 'uint256',
+            name: 'nonceAndMeta',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint128',
+            name: 'expiry',
+            type: 'uint128',
+          },
+          {
+            internalType: 'address',
+            name: 'makerAsset',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'takerAsset',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'maker',
+            type: 'address',
+          },
+          {
+            internalType: 'address',
+            name: 'taker',
+            type: 'address',
+          },
+          {
+            internalType: 'uint256',
+            name: 'makerAmount',
+            type: 'uint256',
+          },
+          {
+            internalType: 'uint256',
+            name: 'takerAmount',
+            type: 'uint256',
+          },
+        ],
+        internalType: 'struct AugustusRFQ.Order',
+        name: 'order',
+        type: 'tuple',
+      },
+      {
+        internalType: 'bytes',
+        name: 'signature',
+        type: 'bytes',
+      },
+      {
+        internalType: 'uint256',
+        name: 'takerTokenFillAmount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'address',
+        name: 'target',
+        type: 'address',
+      },
+      {
+        internalType: 'bytes',
+        name: 'permitTakerAsset',
+        type: 'bytes',
+      },
+      {
+        internalType: 'bytes',
+        name: 'permitMakerAsset',
+        type: 'bytes',
+      },
+    ],
+    name: 'partialFillOrderWithTargetPermit',
+    outputs: [
+      {
+        internalType: 'uint256',
+        name: 'makerTokenFilledAmount',
+        type: 'uint256',
+      },
+    ],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const;
+
+type FillOrderMethods = ExtractAbiMethodNames<typeof MinAugustusRFQAbi>;
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export function constructFillOrderDirectly<T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): FillOrderDirectlyFunctions<T> {
+  // getAugustusRFQ is cached internally for the same instance of SDK
+  // so should persist across same apiUrl & network
+  const { getAugustusRFQ } = constructGetSpender(options);
+
+  const fillOrderDirectly: FillOrderDirectly<T> = async (
+    { order, signature, takerPermit },
+    overrides = {},
+    requestParams
+  ) => {
+    const AugustusRFQ = await getAugustusRFQ(requestParams);
+
+    const sanitizedOrder = sanitizeOrderData(order);
+
+    if (!takerPermit) {
+      const res = await options.contractCaller.transactCall<FillOrderMethods>({
+        address: AugustusRFQ,
+        abi: MinAugustusRFQAbi,
+        contractMethod: 'fillOrder',
+        args: [sanitizedOrder, signature],
+        overrides,
+      });
+
+      return res;
+    }
+
+    let permitTakerAsset: string;
+    if ('encodedPermitParams' in takerPermit) {
+      permitTakerAsset = takerPermit.encodedPermitParams;
+    } else if ('isDaiPermit' in takerPermit && takerPermit.isDaiPermit) {
+      // encoded DAI.permit() function params by taker with AugustusRFQ as spender
+      permitTakerAsset = encodeDAIlikePermitFunctionInput({
+        holder: order.taker,
+        spender: AugustusRFQ,
+        expiry: takerPermit.expiry,
+        nonce: takerPermit.nonce,
+        permitSignature: takerPermit.signature,
+      });
+    } else {
+      // encoded TakerAsset.permit() function params by taker with AugustusRFQ as spender, Permit1 only
+      permitTakerAsset = encodeEIP_2612PermitFunctionInput({
+        owner: order.taker,
+        spender: AugustusRFQ,
+        value: takerPermit.amount || order.takerAmount, // can use permit with a bigger value, fallback to exact Order takerAmount
+        deadline: takerPermit.deadline,
+        permitSignature: takerPermit.signature,
+      });
+    }
+
+    const res = await options.contractCaller.transactCall<FillOrderMethods>({
+      address: AugustusRFQ,
+      abi: MinAugustusRFQAbi,
+      contractMethod: 'partialFillOrderWithTargetPermit',
+      args: [
+        sanitizedOrder, // order
+        signature, // order.signature
+        order.takerAmount, // takerTokenFillAmount, can even partially fill
+        order.taker, // target
+        permitTakerAsset,
+        '0x', // permitMakerAsset, unused because hard to account for changing nonce for long running Orders
+      ],
+      overrides,
+    });
+
+    return res;
+  };
+
+  return { fillOrderDirectly };
+}

package/src/methods/limitOrders/getOrders.ts

@@ -0,0 +1,151 @@
+// @TODO getOrder, getOrders from API
+// onchain from contract can't distinguish between filled or cancelled
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type {
+  Address,
+  ConstructFetchInput,
+  RequestParameters,
+} from '../../types';
+import {
+  constructBaseFetchUrlGetter,
+  GetOrdersURLs,
+  GetOrderURL,
+  GetRequiredAllowanceURL as GetRequiredBalanceURL,
+} from './helpers/misc';
+import type {
+  LimitOrderFromApi,
+  LimitOrdersApiResponse,
+  LimitOrderType,
+} from './helpers/types';
+
+type PaginationParams = {
+  limit?: number;
+  offset?: number;
+  hideSmallBalances?: boolean;
+  orderBy?: 'createdAt' | 'updatedAt' | 'expiry';
+};
+
+//                     get orders by `maker` or `taker`
+export type LimitOrdersUserParams = (
+  | { maker: Address; type: LimitOrderType }
+  | { taker: Address; type: LimitOrderType }
+) &
+  PaginationParams;
+
+export type GetRequiredAllowanceParams = {
+  maker: Address;
+  token?: Address;
+};
+
+type GetLimitOrderByHash = (
+  orderHash: string,
+  requestParams?: RequestParameters
+) => Promise<LimitOrderFromApi>;
+type GetLimitOrders = (
+  userParams: LimitOrdersUserParams,
+  requestParams?: RequestParameters
+) => Promise<LimitOrdersApiResponse>;
+
+type GetRequiredBalance = (
+  userParams: GetRequiredAllowanceParams,
+  requestParams?: RequestParameters
+) => Promise<Record<string, string>>;
+
+export type GetLimitOrdersFunctions = {
+  getLimitOrders: GetLimitOrders;
+  getLimitOrderByHash: GetLimitOrderByHash;
+  /**
+   * Gets fillableBalance for tokens from user's active orders.
+   * User needs to have enough balance & allowance to cover active orders before creating new orders.
+   * @param userParams - parameters to get allowance for active orders
+   * @param {string} userParams.maker - user to get required allowances for
+   * @param {string=} userParams.token - if given `token`, the mapping will contain that token address only
+   * @param {RequestParameters=} requestParams - requestParams passed to fetcher, can include {signal: AbortSignal, timeout: for axios, etc.}
+   * @returns `{Lowercase<Address> => wei number as string}` mapping of token to fillableBalance
+   */
+  getRequiredBalance: GetRequiredBalance;
+};
+
+export const constructGetLimitOrders = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): GetLimitOrdersFunctions => {
+  const getBaseFetchURLByEntityType = constructBaseFetchUrlGetter({
+    apiURL,
+    chainId,
+  });
+
+  const getLimitOrders: GetLimitOrders = async (userParams, requestParams) => {
+    const baseFetchURL = getBaseFetchURLByEntityType(userParams.type);
+    const userURL =
+      'maker' in userParams
+        ? (`maker/${userParams.maker}` as const)
+        : (`taker/${userParams.taker}` as const);
+
+    const { offset, limit, hideSmallBalances, orderBy } = userParams;
+    const search = constructSearchString<PaginationParams>({
+      offset,
+      limit,
+      hideSmallBalances,
+      orderBy,
+    });
+
+    const fetchURL = `${baseFetchURL}/${userURL}${search}` as const;
+
+    const response = await fetcher<LimitOrdersApiResponse, GetOrdersURLs>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    // without any extra calls, return  what API returns
+    return response;
+  };
+
+  const getRequiredBalance: GetRequiredBalance = async (
+    userParams,
+    requestParams
+  ) => {
+    const baseFetchURL = getBaseFetchURLByEntityType('fillablebalance');
+    const userURL = `${baseFetchURL}/${userParams.maker}` as const;
+    const fetchURL = userParams.token
+      ? (`${userURL}/${userParams.token}` as const)
+      : userURL;
+
+    const response = await fetcher<
+      Record<string, string>,
+      GetRequiredBalanceURL
+    >({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    // without any extra calls, return  what API returns
+    return response;
+  };
+
+  const getLimitOrderByHash: GetLimitOrderByHash = async (
+    orderHash,
+    requestParams
+  ) => {
+    const baseFetchURL = getBaseFetchURLByEntityType();
+    const fetchURL = `${baseFetchURL}/${orderHash}` as const;
+
+    const order = await fetcher<LimitOrderFromApi, GetOrderURL>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return order;
+  };
+
+  return {
+    getLimitOrders,
+    getLimitOrderByHash,
+    getRequiredBalance,
+  };
+};

package/src/methods/limitOrders/getOrdersContract.ts

@@ -0,0 +1,20 @@
+import type { ConstructFetchInput } from '../../types';
+import { constructGetSpender, GetSpender } from '../swap/spender';
+
+export type GetLimitOrdersContractFunctions = {
+  getLimitOrdersContract: GetSpender;
+  getTokenTransferProxy: GetSpender;
+};
+
+export const constructGetLimitOrdersContract = (
+  options: ConstructFetchInput
+): GetLimitOrdersContractFunctions => {
+  // analogous to getSpender() but for Limit Orders Contract = AugustusRFQ
+
+  const {
+    getSpender: getTokenTransferProxy,
+    getAugustusRFQ: getLimitOrdersContract,
+  } = constructGetSpender(options);
+
+  return { getLimitOrdersContract, getTokenTransferProxy };
+};