@velora-dex/sdk 9.3.5 → 9.4.0

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

@@ -1,5 +1,44 @@
+import type { EnumerateLiteral } from '../../../types';
 import { SwapSide } from '../../../constants';
 
+export type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
+
+/** @description SELL with slippage: srcAmount provided, destAmount auto-computed from deltaPrice.destAmount */
+export type AmountsSellSlippage = {
+  /** @description Slippage in basis points (bps). 10000 = 100%, 50 = 0.5% */
+  slippage: number;
+  /** @description The amount of src token to swap */
+  srcAmount: string;
+  destAmount?: never;
+  /** @description The side of the order */
+  side?: 'SELL';
+};
+/** @description BUY with slippage: destAmount provided, srcAmount auto-computed from deltaPrice.srcAmount */
+export type AmountsBuySlippage = {
+  /** @description Slippage in basis points (bps). 10000 = 100%, 50 = 0.5% */
+  slippage: number;
+  /** @description The minimum amount of dest token to receive */
+  destAmount: string;
+  srcAmount?: never;
+  /** @description The side of the order */
+  side?: 'BUY';
+};
+/** @description Explicit amounts, no slippage (backward-compatible) */
+export type AmountsExplicit = {
+  slippage?: never;
+  /** @description The amount of src token to swap */
+  srcAmount: string;
+  /** @description The minimum amount of dest token to receive */
+  destAmount: string;
+  /** @description The side of the order. Default is SELL */
+  side?: SwapSideUnion;
+};
+
+export type AmountsWithSlippage =
+  | AmountsSellSlippage
+  | AmountsBuySlippage
+  | AmountsExplicit;
+
 enum OrderKind {
   Sell = 0,
   Buy = 1,
@@ -52,6 +91,37 @@ export type Bridge = {
   protocolData: string; // Hex string
 };
 
+export type ExternalDeltaOrder = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the external handler contract */
+  handler: string;
+  /** @description The address of the src token */
+  srcToken: string;
+  /** @description The address of the dest token */
+  destToken: string;
+  /** @description The amount of src token to swap */
+  srcAmount: string;
+  /** @description The minimum amount of dest token to receive */
+  destAmount: string;
+  /** @description The expected amount of token to receive */
+  expectedAmount: string;
+  /** @description The kind of the order */
+  kind: OrderKind;
+  /** @description Metadata for the order, hex string */
+  metadata: string;
+  /** @description The deadline for the order */
+  deadline: number;
+  /** @description The nonce of the order */
+  nonce: string;
+  /** @description Optional permit signature for the src token */
+  permit: string;
+  /** @description Encoded partner address, fee bps, and flags for the order */
+  partnerAndFee: string;
+  /** @description Protocol-specific encoded bytes for the external handler */
+  data: string;
+};
+
 export type DeltaAuctionStatus =
   | 'NOT_STARTED'
   | 'AWAITING_PRE_SIGNATURE'
@@ -92,13 +162,16 @@ type DeltaAuctionTransaction = {
   auctionId: string;
 };
 
-export type DeltaAuction = {
+export type OnChainOrderMap = {
+  Order: DeltaAuctionOrder;
+  ExternalOrder: ExternalDeltaOrder;
+};
+
+type DeltaAuctionBase = {
   id: string;
   deltaVersion: string; // 1.0 or 2.0 currently
   user: string;
-  signature: string;
   status: DeltaAuctionStatus;
-  order: DeltaAuctionOrder;
   orderHash: string | null; // not available on old Orders only
   transactions: DeltaAuctionTransaction[];
   chainId: number;
@@ -115,13 +188,17 @@ export type DeltaAuction = {
   bridgeMetadata: BridgeMetadata | null;
   bridgeStatus: BridgeStatus | null;
 
-  // @TODO only returned after POST Order so far
-  // orderVersion: string; // "2.0.0"
-  // deltaGasOverhead: number;
-
-  type: 'MARKET' | 'LIMIT'; // @TODO when available in API for individual /order/:hash|:id
+  type: 'MARKET' | 'LIMIT';
 };
 
+export type DeltaAuction<T extends OnChainOrderType = OnChainOrderType> =
+  T extends T
+    ? DeltaAuctionBase & {
+        onChainOrderType: T;
+        order: OnChainOrderMap[T];
+      }
+    : never;
+
 export type BridgeMetadata = {
   /** @description The amount that user should expect to get */
   outputAmount: string;
@@ -138,6 +215,8 @@ export type BridgeMetadata = {
 //                                                             refunded is basically failed
 export type BridgeStatus = 'pending' | 'filled' | 'expired' | 'refunded';
 
+export type OnChainOrderType = 'Order' | 'ExternalOrder';
+
 //// available on BridgePrice ////
 
 type BridgeQuoteFee = {

package/src/methods/delta/index.ts

@@ -1,4 +1,5 @@
 import type { ConstructProviderFetchInput } from '../../types';
+import type { DeltaAuction } from './helpers/types';
 import {
   BuildDeltaOrderDataParams,
   BuildDeltaOrderFunctions,
@@ -6,7 +7,6 @@ import {
 } from './buildDeltaOrder';
 import {
   constructPostDeltaOrder,
-  DeltaOrderApiResponse,
   DeltaOrderToPost,
   PostDeltaOrderFunctions,
 } from './postDeltaOrder';
@@ -54,17 +54,35 @@ import {
   DeltaTokenModuleFunctions,
   constructDeltaTokenModule,
 } from './deltaTokenModule';
+import {
+  BuildExternalDeltaOrderParams,
+  BuildExternalDeltaOrderFunctions,
+  constructBuildExternalDeltaOrder,
+} from './buildExternalDeltaOrder';
+import {
+  constructSignExternalDeltaOrder,
+  SignExternalDeltaOrderFunctions,
+} from './signExternalDeltaOrder';
+import {
+  constructPostExternalDeltaOrder,
+  PostExternalDeltaOrderFunctions,
+} from './postExternalDeltaOrder';
+import {
+  constructPreSignExternalDeltaOrder,
+  PreSignExternalDeltaOrderFunctions,
+} from './preSignExternalDeltaOrder';
 
 export type SubmitDeltaOrderParams = BuildDeltaOrderDataParams & {
   /** @description designates the Order as being able to be partially filled, as opposed to fill-or-kill */
   partiallyFillable?: boolean;
   /** @description Referrer address */
   referrerAddress?: string;
+  degenMode?: boolean;
 } & Pick<DeltaOrderToPost, 'type' | 'includeAgents' | 'excludeAgents'>;
 
 type SubmitDeltaOrder = (
   orderParams: SubmitDeltaOrderParams
-) => Promise<DeltaOrderApiResponse>;
+) => Promise<DeltaAuction<'Order'>>;
 
 export type SubmitDeltaOrderFuncs = {
   submitDeltaOrder: SubmitDeltaOrder;
@@ -91,6 +109,7 @@ export const constructSubmitDeltaOrder = (
       type: orderParams.type,
       includeAgents: orderParams.includeAgents,
       excludeAgents: orderParams.excludeAgents,
+      degenMode: orderParams.degenMode,
     });
 
     return response;
@@ -99,6 +118,51 @@ export const constructSubmitDeltaOrder = (
   return { submitDeltaOrder };
 };
 
+export type SubmitExternalDeltaOrderParams = BuildExternalDeltaOrderParams & {
+  /** @description designates the Order as being able to be partially filled, as opposed to fill-or-kill */
+  partiallyFillable?: boolean;
+  /** @description Referrer address */
+  referrerAddress?: string;
+} & Pick<DeltaOrderToPost, 'type' | 'includeAgents' | 'excludeAgents'>;
+
+type SubmitExternalDeltaOrder = (
+  orderParams: SubmitExternalDeltaOrderParams
+) => Promise<DeltaAuction<'ExternalOrder'>>;
+
+export type SubmitExternalDeltaOrderFuncs = {
+  submitExternalDeltaOrder: SubmitExternalDeltaOrder;
+};
+
+export const constructSubmitExternalDeltaOrder = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitExternalDeltaOrderFuncs => {
+  const { buildExternalDeltaOrder } = constructBuildExternalDeltaOrder(options);
+  const { signExternalDeltaOrder } = constructSignExternalDeltaOrder(options);
+  const { postExternalDeltaOrder } = constructPostExternalDeltaOrder(options);
+
+  const submitExternalDeltaOrder: SubmitExternalDeltaOrder = async (
+    orderParams
+  ) => {
+    const orderData = await buildExternalDeltaOrder(orderParams);
+    const signature = await signExternalDeltaOrder(orderData);
+
+    const response = await postExternalDeltaOrder({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.data,
+      partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
+    });
+
+    return response;
+  };
+
+  return { submitExternalDeltaOrder };
+};
+
 export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   ApproveTokenForDeltaFunctions<T> &
   BuildDeltaOrderFunctions &
@@ -112,7 +176,12 @@ export type DeltaOrderHandlers<T> = SubmitDeltaOrderFuncs &
   SignDeltaOrderFunctions &
   PreSignDeltaOrderFunctions<T> &
   CancelDeltaOrderFunctions &
-  DeltaTokenModuleFunctions<T>;
+  DeltaTokenModuleFunctions<T> &
+  SubmitExternalDeltaOrderFuncs &
+  BuildExternalDeltaOrderFunctions &
+  SignExternalDeltaOrderFunctions &
+  PostExternalDeltaOrderFunctions &
+  PreSignExternalDeltaOrderFunctions<T>;
 
 /** @description construct SDK with every Delta Order-related method, fetching from API and Order signing */
 export const constructAllDeltaOrdersHandlers = <TxResponse>(
@@ -142,6 +211,13 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
 
   const deltaTokenModule = constructDeltaTokenModule(options);
 
+  const externalDeltaOrdersSubmit = constructSubmitExternalDeltaOrder(options);
+  const externalDeltaOrdersBuild = constructBuildExternalDeltaOrder(options);
+  const externalDeltaOrdersSign = constructSignExternalDeltaOrder(options);
+  const externalDeltaOrdersPost = constructPostExternalDeltaOrder(options);
+  const externalDeltaOrdersPreSign =
+    constructPreSignExternalDeltaOrder(options);
+
   return {
     ...deltaOrdersGetters,
     ...deltaOrdersContractGetter,
@@ -157,5 +233,10 @@ export const constructAllDeltaOrdersHandlers = <TxResponse>(
     ...deltaOrdersPost,
     ...deltaOrdersCancel,
     ...deltaTokenModule,
+    ...externalDeltaOrdersSubmit,
+    ...externalDeltaOrdersBuild,
+    ...externalDeltaOrdersSign,
+    ...externalDeltaOrdersPost,
+    ...externalDeltaOrdersPreSign,
   };
 };

package/src/methods/delta/postDeltaOrder.ts

@@ -1,13 +1,18 @@
 import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
 import type { ConstructFetchInput, RequestParameters } from '../../types';
-import { DeltaAuctionOrder, DeltaAuction } from './helpers/types';
+import type {
+  DeltaAuction,
+  OnChainOrderMap,
+  OnChainOrderType,
+} from './helpers/types';
 
-export type DeltaOrderToPost = {
+export type DeltaOrderToPost<T extends OnChainOrderType = 'Order'> = {
   /** @description Partner string */
   partner?: string;
   /** @description Referrer address */
   referrerAddress?: string;
-  order: DeltaAuctionOrder;
+  order: OnChainOrderMap[T];
   /** @description Signature of the order from order.owner address. EOA signatures must be submitted in ERC-2098 Compact Representation. */
   signature: string;
   chainId: number;
@@ -21,18 +26,14 @@ export type DeltaOrderToPost = {
   excludeAgents?: string[];
 };
 
-export type PostDeltaOrderParams = Omit<DeltaOrderToPost, 'chainId'>;
-
-export type DeltaOrderApiResponse = Omit<DeltaAuction, 'transactions'> & {
-  orderVersion: string; // "2.0.0"
-  deltaGasOverhead: number; // @TODO may be removed
-  type: 'MARKET' | 'LIMIT';
+export type PostDeltaOrderParams = Omit<DeltaOrderToPost, 'chainId'> & {
+  degenMode?: boolean;
 };
 
 type PostDeltaOrder = (
   postData: PostDeltaOrderParams,
   requestParams?: RequestParameters
-) => Promise<DeltaOrderApiResponse>;
+) => Promise<DeltaAuction<'Order'>>;
 
 export type PostDeltaOrderFunctions = {
   postDeltaOrder: PostDeltaOrder;
@@ -45,11 +46,17 @@ export const constructPostDeltaOrder = ({
 }: ConstructFetchInput): PostDeltaOrderFunctions => {
   const postOrderUrl = `${apiURL}/delta/orders` as const;
 
-  const postDeltaOrder: PostDeltaOrder = (postData, requestParams) => {
+  const postDeltaOrder: PostDeltaOrder = (_postData, requestParams) => {
+    const { degenMode, ...postData } = _postData;
     const deltaOrderToPost: DeltaOrderToPost = { ...postData, chainId };
 
-    return fetcher<DeltaOrderApiResponse>({
-      url: postOrderUrl,
+    const search = constructSearchString<{ degenMode?: boolean }>({
+      degenMode,
+    });
+    const fetchURL = `${postOrderUrl}/${search}` as const;
+
+    return fetcher<DeltaAuction<'Order'>>({
+      url: fetchURL,
       method: 'POST',
       data: deltaOrderToPost,
       requestParams,

package/src/methods/delta/postExternalDeltaOrder.ts

@@ -0,0 +1,45 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { DeltaAuction } from './helpers/types';
+import type { DeltaOrderToPost } from './postDeltaOrder';
+
+export type PostExternalDeltaOrderParams = Omit<
+  DeltaOrderToPost<'ExternalOrder'>,
+  'chainId'
+>;
+
+type PostExternalDeltaOrder = (
+  postData: PostExternalDeltaOrderParams,
+  requestParams?: RequestParameters
+) => Promise<DeltaAuction<'ExternalOrder'>>;
+
+export type PostExternalDeltaOrderFunctions = {
+  postExternalDeltaOrder: PostExternalDeltaOrder;
+};
+
+export const constructPostExternalDeltaOrder = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): PostExternalDeltaOrderFunctions => {
+  const postOrderUrl = `${apiURL}/delta/orders` as const;
+
+  const postExternalDeltaOrder: PostExternalDeltaOrder = (
+    postData,
+    requestParams
+  ) => {
+    const deltaOrderToPost: DeltaOrderToPost<'ExternalOrder'> = {
+      ...postData,
+      chainId,
+    };
+
+    return fetcher<DeltaAuction<'ExternalOrder'>>({
+      url: postOrderUrl,
+      method: 'POST',
+      data: deltaOrderToPost,
+      requestParams,
+    });
+  };
+
+  return { postExternalDeltaOrder };
+};

package/src/methods/delta/preSignDeltaOrder.ts

@@ -9,6 +9,7 @@ import {
   SignableDeltaOrderData,
 } from './helpers/buildDeltaOrderData';
 import { sanitizeDeltaOrderData } from './helpers/misc';
+import { PreSignatureModuleAbi } from './helpers/abi';
 import type { ExtractAbiMethodNames } from '../../helpers/misc';
 import { findPrimaryType } from '../../helpers/providers/helpers';
 import { constructGetDeltaContract } from './getDeltaContract';
@@ -42,27 +43,6 @@ export type PreSignDeltaOrderFunctions<T> = {
   preSignDeltaOrder: PreSignDeltaOrder<T>;
 };
 
-const PreSignatureModuleAbi = [
-  {
-    inputs: [
-      {
-        internalType: 'bytes32',
-        name: 'orderHash',
-        type: 'bytes32',
-      },
-      {
-        internalType: 'bool',
-        name: 'preSigned',
-        type: 'bool',
-      },
-    ],
-    name: 'setPreSignature',
-    outputs: [],
-    stateMutability: 'nonpayable',
-    type: 'function',
-  },
-] as const;
-
 type AvailableMethods = ExtractAbiMethodNames<typeof PreSignatureModuleAbi>;
 
 // returns whatever `contractCaller` returns

package/src/methods/delta/preSignExternalDeltaOrder.ts

@@ -0,0 +1,141 @@
+import { hashTypedData } from 'viem/utils';
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import {
+  produceExternalOrderTypedData,
+  SignableExternalOrderData,
+} from './helpers/buildExternalOrderData';
+import { sanitizeExternalOrderData } from './helpers/misc';
+import { PreSignatureModuleAbi } from './helpers/abi';
+import type { ExtractAbiMethodNames } from '../../helpers/misc';
+import { findPrimaryType } from '../../helpers/providers/helpers';
+import { constructGetDeltaContract } from './getDeltaContract';
+import type { ExternalDeltaOrder } from './helpers/types';
+
+type HashExternalDeltaOrderTypedData = (
+  signableOrderData: SignableExternalOrderData
+) => string;
+
+type HashExternalDeltaOrder = (
+  orderData: ExternalDeltaOrder,
+  requestParams?: RequestParameters
+) => Promise<string>;
+
+export type SetExternalDeltaOrderPreSignature<T> = (
+  orderHash: string,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignExternalDeltaOrder<T> = (
+  signableOrderData: SignableExternalOrderData,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignExternalDeltaOrderFunctions<T> = {
+  hashExternalDeltaOrderTypedData: HashExternalDeltaOrderTypedData;
+  hashExternalDeltaOrder: HashExternalDeltaOrder;
+  setExternalDeltaOrderPreSignature: SetExternalDeltaOrderPreSignature<T>;
+  preSignExternalDeltaOrder: PreSignExternalDeltaOrder<T>;
+};
+
+type AvailableMethods = ExtractAbiMethodNames<typeof PreSignatureModuleAbi>;
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructPreSignExternalDeltaOrder = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): PreSignExternalDeltaOrderFunctions<T> => {
+  const hashExternalDeltaOrderTypedData: HashExternalDeltaOrderTypedData = (
+    typedData
+  ) => {
+    // types allow to pass OrderData & extra_stuff, but tx will break like that
+    const typedDataOnly: SignableExternalOrderData = {
+      ...typedData,
+      data: sanitizeExternalOrderData(typedData.data),
+    };
+
+    const orderHash = produceExternalOrderHash(typedDataOnly);
+
+    return orderHash;
+  };
+  // cached internally
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const hashExternalDeltaOrder: HashExternalDeltaOrder = async (
+    orderData,
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    const typedData = produceExternalOrderTypedData({
+      orderInput: orderData,
+      chainId: options.chainId,
+      paraswapDeltaAddress: ParaswapDelta,
+    });
+    return hashExternalDeltaOrderTypedData(typedData);
+  };
+
+  const setExternalDeltaOrderPreSignature: SetExternalDeltaOrderPreSignature<
+    T
+  > = async (orderHash, overrides = {}, requestParams) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    const res = await options.contractCaller.transactCall<AvailableMethods>({
+      address: ParaswapDelta,
+      abi: PreSignatureModuleAbi,
+      contractMethod: 'setPreSignature',
+      args: [orderHash, true],
+      overrides,
+    });
+
+    return res;
+  };
+
+  const preSignExternalDeltaOrder: PreSignExternalDeltaOrder<T> = async (
+    signableOrderData,
+    overrides = {},
+    requestParams
+  ) => {
+    const orderHash = hashExternalDeltaOrderTypedData(signableOrderData);
+    const res = await setExternalDeltaOrderPreSignature(
+      orderHash,
+      overrides,
+      requestParams
+    );
+    return res;
+  };
+
+  return {
+    hashExternalDeltaOrderTypedData,
+    hashExternalDeltaOrder,
+    setExternalDeltaOrderPreSignature,
+    preSignExternalDeltaOrder,
+  };
+};
+
+export function produceExternalOrderHash(
+  typedData: SignableExternalOrderData
+): string {
+  return hashTypedData({
+    domain: {
+      name: typedData.domain.name,
+      version: typedData.domain.version,
+      chainId: typedData.domain.chainId,
+      verifyingContract: typedData.domain.verifyingContract as `0x${string}`,
+    },
+    types: typedData.types,
+    primaryType: findPrimaryType(typedData.types),
+    message: typedData.data,
+  });
+}

package/src/methods/delta/signExternalDeltaOrder.ts

@@ -0,0 +1,35 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import { SignableExternalOrderData } from './helpers/buildExternalOrderData';
+import { sanitizeExternalOrderData } from './helpers/misc';
+
+type SignExternalDeltaOrder = (
+  signableOrderData: SignableExternalOrderData
+) => Promise<string>;
+
+export type SignExternalDeltaOrderFunctions = {
+  signExternalDeltaOrder: SignExternalDeltaOrder;
+};
+
+// returns whatever `contractCaller` returns
+// to allow for better versatility
+export const constructSignExternalDeltaOrder = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller'
+  >
+): SignExternalDeltaOrderFunctions => {
+  const signExternalDeltaOrder: SignExternalDeltaOrder = async (typedData) => {
+    // types allow to pass OrderData & extra_stuff, but tx will break like that
+    const typedDataOnly: SignableExternalOrderData = {
+      ...typedData,
+      data: sanitizeExternalOrderData(typedData.data),
+    };
+    const signature = await options.contractCaller.signTypedDataCall(
+      typedDataOnly
+    );
+
+    return signature;
+  };
+
+  return { signExternalDeltaOrder };
+};

package/src/methods/limitOrders/approveForOrder.ts

@@ -3,6 +3,7 @@ import { ApproveToken, approveTokenMethodFactory } from '../../helpers/approve';
 import { constructApproveToken } from '../swap/approve';
 import { constructGetSpender } from '../swap/spender';
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type ApproveTokenForLimitOrderFunctions<T> = {
   /** @description approving AugustusRFQ as spender for makerAsset */
   approveMakerTokenForLimitOrder: ApproveToken<T>;
@@ -14,6 +15,7 @@ export type ApproveTokenForLimitOrderFunctions<T> = {
 
 // returns whatever `contractCaller` returns
 // to allow for better versatility
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export const constructApproveTokenForLimitOrder = <T>(
   options: ConstructProviderFetchInput<T, 'transactCall'>
 ): ApproveTokenForLimitOrderFunctions<T> => {

package/src/methods/limitOrders/buildOrder.ts

@@ -8,6 +8,7 @@ import {
 } from './helpers/buildOrderData';
 export * from './helpers/buildOrderData';
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type BuildLimitOrderInput = Omit<
   BuildOrderDataInput,
   'chainId' | 'verifyingContract' | 'AugustusAddress' | 'AppVersion'
@@ -18,11 +19,13 @@ type BuildLimitOrder = (
   requestParams?: RequestParameters
 ) => Promise<SignableOrderData>;
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type BuildLimitOrderFunctions = {
   /** @description Build Orders that will be excuted through AugustusSwapper */
   buildLimitOrder: BuildLimitOrder;
 };
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export const constructBuildLimitOrder = (
   options: ConstructFetchInput
 ): BuildLimitOrderFunctions => {

package/src/methods/limitOrders/cancelOrder.ts

@@ -18,6 +18,7 @@ export type CancelOrderBulk<T> = (
   requestParams?: RequestParameters
 ) => Promise<T>;
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type CancelLimitOrderFunctions<T> = {
   cancelLimitOrder: CancelOrder<T>;
   cancelLimitOrderBulk: CancelOrderBulk<T>;
@@ -57,6 +58,7 @@ type AvailableMethods = ExtractAbiMethodNames<typeof MinAugustusRFQAbi>;
 
 // returns whatever `contractCaller` returns
 // to allow for better versatility
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export const constructCancelLimitOrder = <T>(
   options: ConstructProviderFetchInput<T, 'transactCall'>
 ): CancelLimitOrderFunctions<T> => {

package/src/methods/limitOrders/fillOrderDirectly.ts

@@ -12,6 +12,7 @@ import {
   encodeEIP_2612PermitFunctionInput,
 } from '../common/orders/encoding';
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type FillOrderDirectlyFunctions<T> = {
   fillOrderDirectly: FillOrderDirectly<T>;
 };
@@ -204,6 +205,7 @@ type FillOrderMethods = ExtractAbiMethodNames<typeof MinAugustusRFQAbi>;
 
 // returns whatever `contractCaller` returns
 // to allow for better versatility
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export function constructFillOrderDirectly<T>(
   options: ConstructProviderFetchInput<T, 'transactCall'>
 ): FillOrderDirectlyFunctions<T> {