@velora-dex/sdk 9.3.6 → 9.4.1-dev.1

package/src/methods/delta/preSignTWAPDeltaOrder.ts

@@ -0,0 +1,168 @@
+import { hashTypedData } from 'viem/utils';
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+  TxSendOverrides,
+} from '../../types';
+import {
+  produceTWAPOrderTypedData,
+  SignableTWAPOrderData,
+} from './helpers/buildTWAPOrderData';
+import { sanitizeTWAPOrderData } 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 { TWAPDeltaOrder, TWAPBuyDeltaOrder } from './helpers/types';
+import { TypedDataField } from 'ethersV5';
+
+type HashTWAPDeltaOrderTypedData = (
+  signableOrderData: SignableTWAPOrderData
+) => string;
+
+type HashTWAPDeltaOrder = {
+  (
+    orderData: TWAPDeltaOrder,
+    onChainOrderType: 'TWAPOrder',
+    requestParams?: RequestParameters
+  ): Promise<string>;
+
+  (
+    orderData: TWAPBuyDeltaOrder,
+    onChainOrderType: 'TWAPBuyOrder',
+    requestParams?: RequestParameters
+  ): Promise<string>;
+};
+
+export type SetTWAPDeltaOrderPreSignature<T> = (
+  orderHash: string,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignTWAPDeltaOrder<T> = (
+  signableOrderData: SignableTWAPOrderData,
+  overrides?: TxSendOverrides,
+  requestParams?: RequestParameters
+) => Promise<T>;
+
+export type PreSignTWAPDeltaOrderFunctions<T> = {
+  hashTWAPDeltaOrderTypedData: HashTWAPDeltaOrderTypedData;
+  hashTWAPDeltaOrder: HashTWAPDeltaOrder;
+  setTWAPDeltaOrderPreSignature: SetTWAPDeltaOrderPreSignature<T>;
+  preSignTWAPDeltaOrder: PreSignTWAPDeltaOrder<T>;
+};
+
+type AvailableMethods = ExtractAbiMethodNames<typeof PreSignatureModuleAbi>;
+
+export const constructPreSignTWAPDeltaOrder = <T>(
+  options: ConstructProviderFetchInput<T, 'transactCall'>
+): PreSignTWAPDeltaOrderFunctions<T> => {
+  const hashTWAPDeltaOrderTypedData: HashTWAPDeltaOrderTypedData = (
+    typedData
+  ) => {
+    const typedDataOnly = {
+      ...typedData,
+      data: sanitizeTWAPOrderData(typedData.data),
+    } as SignableTWAPOrderData;
+
+    const orderHash = produceTWAPOrderHash(typedDataOnly);
+
+    return orderHash;
+  };
+
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const hashTWAPDeltaOrder: HashTWAPDeltaOrder = async (
+    orderData,
+    onChainOrderType,
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    if (onChainOrderType === 'TWAPOrder' && 'totalSrcAmount' in orderData) {
+      const typedData = produceTWAPOrderTypedData({
+        orderInput: orderData,
+        chainId: options.chainId,
+        paraswapDeltaAddress: ParaswapDelta,
+        onChainOrderType,
+      });
+      return hashTWAPDeltaOrderTypedData(typedData);
+    }
+
+    if (onChainOrderType === 'TWAPBuyOrder' && 'maxSrcAmount' in orderData) {
+      const typedData = produceTWAPOrderTypedData({
+        orderInput: orderData,
+        chainId: options.chainId,
+        paraswapDeltaAddress: ParaswapDelta,
+        onChainOrderType,
+      });
+      return hashTWAPDeltaOrderTypedData(typedData);
+    }
+
+    throw new Error(
+      `Invalid order data for onChainOrderType ${onChainOrderType}`
+    );
+  };
+
+  const setTWAPDeltaOrderPreSignature: SetTWAPDeltaOrderPreSignature<
+    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 preSignTWAPDeltaOrder: PreSignTWAPDeltaOrder<T> = async (
+    signableOrderData,
+    overrides = {},
+    requestParams
+  ) => {
+    const orderHash = hashTWAPDeltaOrderTypedData(signableOrderData);
+    const res = await setTWAPDeltaOrderPreSignature(
+      orderHash,
+      overrides,
+      requestParams
+    );
+    return res;
+  };
+
+  return {
+    hashTWAPDeltaOrderTypedData,
+    hashTWAPDeltaOrder,
+    setTWAPDeltaOrderPreSignature,
+    preSignTWAPDeltaOrder,
+  };
+};
+
+export function produceTWAPOrderHash(typedData: SignableTWAPOrderData): string {
+  const types = typedData.types as Record<
+    'TWAPOrder' | 'TWAPBuyOrder' | 'Bridge',
+    TypedDataField[]
+  >;
+  return hashTypedData({
+    domain: {
+      name: typedData.domain.name,
+      version: typedData.domain.version,
+      chainId: typedData.domain.chainId,
+      verifyingContract: typedData.domain.verifyingContract as `0x${string}`,
+    },
+    types,
+    primaryType: findPrimaryType(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/delta/signTWAPDeltaOrder.ts

@@ -0,0 +1,32 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import { SignableTWAPOrderData } from './helpers/buildTWAPOrderData';
+import { sanitizeTWAPOrderData } from './helpers/misc';
+
+type SignTWAPDeltaOrder = (
+  signableOrderData: SignableTWAPOrderData
+) => Promise<string>;
+
+export type SignTWAPDeltaOrderFunctions = {
+  signTWAPDeltaOrder: SignTWAPDeltaOrder;
+};
+
+export const constructSignTWAPDeltaOrder = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller'
+  >
+): SignTWAPDeltaOrderFunctions => {
+  const signTWAPDeltaOrder: SignTWAPDeltaOrder = async (typedData) => {
+    const typedDataOnly = {
+      ...typedData,
+      data: sanitizeTWAPOrderData(typedData.data),
+    } as SignableTWAPOrderData;
+    const signature = await options.contractCaller.signTypedDataCall(
+      typedDataOnly
+    );
+
+    return signature;
+  };
+
+  return { signTWAPDeltaOrder };
+};

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> {

package/src/methods/limitOrders/getOrders.ts

@@ -52,6 +52,7 @@ type GetRequiredBalance = (
   requestParams?: RequestParameters
 ) => Promise<Record<string, string>>;
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type GetLimitOrdersFunctions = {
   getLimitOrders: GetLimitOrders;
   getLimitOrderByHash: GetLimitOrderByHash;
@@ -67,6 +68,7 @@ export type GetLimitOrdersFunctions = {
   getRequiredBalance: GetRequiredBalance;
 };
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export const constructGetLimitOrders = ({
   apiURL = API_URL,
   chainId,

package/src/methods/limitOrders/getOrdersContract.ts

@@ -1,11 +1,13 @@
 import type { ConstructFetchInput } from '../../types';
 import { constructGetSpender, GetSpender } from '../swap/spender';
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type GetLimitOrdersContractFunctions = {
   getLimitOrdersContract: GetSpender;
   getTokenTransferProxy: GetSpender;
 };
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export const constructGetLimitOrdersContract = (
   options: ConstructFetchInput
 ): GetLimitOrdersContractFunctions => {

package/src/methods/limitOrders/index.ts

@@ -45,11 +45,13 @@ type SubmitP2POrder = (
   requestParams?: RequestParameters
 ) => Promise<LimitOrderFromApi>;
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type SubmitLimitOrderFuncs = {
   submitLimitOrder: SubmitLimitOrder;
   submitP2POrder: SubmitP2POrder;
 };
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export const constructSubmitLimitOrder = (
   options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
 ): SubmitLimitOrderFuncs => {
@@ -106,6 +108,7 @@ export const constructSubmitLimitOrder = (
   return { submitLimitOrder, submitP2POrder };
 };
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type LimitOrderHandlers<T> = SubmitLimitOrderFuncs &
   BuildLimitOrderFunctions &
   SignLimitOrderFunctions &
@@ -117,7 +120,10 @@ export type LimitOrderHandlers<T> = SubmitLimitOrderFuncs &
   ApproveTokenForLimitOrderFunctions<T> &
   FillOrderDirectlyFunctions<T>;
 
-/** @description construct SDK with every LimitOrders-related method, fetching from API and contract calls */
+/**
+ * @description construct SDK with every LimitOrders-related method, fetching from API and contract calls
+ * @deprecated Limit Orders are deprecated and will be removed in a future version.
+ */
 export const constructAllLimitOrdersHandlers = <TxResponse>(
   options: ConstructProviderFetchInput<
     TxResponse,

package/src/methods/limitOrders/postOrder.ts

@@ -13,11 +13,13 @@ type PostLimitOrder = (
   requestParams?: RequestParameters
 ) => Promise<LimitOrderFromApi>;
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type PostLimitOrderFunctions = {
   postLimitOrder: PostLimitOrder;
   postP2POrder: PostLimitOrder;
 };
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export const constructPostLimitOrder = ({
   apiURL = API_URL,
   chainId,

package/src/methods/limitOrders/signOrder.ts

@@ -2,12 +2,14 @@ import type { ConstructProviderFetchInput } from '../../types';
 import type { SignableOrderData } from './buildOrder';
 import { sanitizeOrderData } from './helpers/misc';
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type SignLimitOrderFunctions = {
   signLimitOrder: (signableOrderData: SignableOrderData) => Promise<string>;
 };
 
 // returns whatever `contractCaller` returns
 // to allow for better versatility
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export const constructSignLimitOrder = (
   options: Pick<
     ConstructProviderFetchInput<any, 'signTypedDataCall'>,

package/src/methods/limitOrders/transaction.ts

@@ -44,6 +44,7 @@ type BuildLimitOrdersTx = (
   requestParams?: RequestParameters
 ) => Promise<TransactionParams>;
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type BuildLimitOrdersTxFunctions = {
   getLimitOrdersRate: GetLimitOrdersRate;
   buildLimitOrderTx: BuildLimitOrdersTx;
@@ -57,6 +58,7 @@ type GetLimitOrdersRate = (
   requestParams?: RequestParameters
 ) => Promise<OptimalRate>;
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export const constructBuildLimitOrderTx = ({
   apiURL = API_URL,
   version = DEFAULT_VERSION,

package/src/methods/nftOrders/approveForOrder.ts

@@ -15,6 +15,7 @@ type ApproveNFT<T> = (
   requestParams?: RequestParameters
 ) => Promise<T>;
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type ApproveTokenForNFTOrderFunctions<T> = {
   /** @description approving AugustusSwapper as spender for takerAsset (ERC20) for Limit Orders that will be executed through it */
   approveERC20ForNFTOrder: ApproveToken<T>;
@@ -47,6 +48,7 @@ type ApprovalMethods = ExtractAbiMethodNames<typeof MinNFTAbi>;
 
 // returns whatever `contractCaller` returns
 // to allow for better versatility
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const constructApproveTokenForNFTOrder = <T>(
   options: ConstructProviderFetchInput<T, 'transactCall'>
 ): ApproveTokenForNFTOrderFunctions<T> => {

package/src/methods/nftOrders/buildOrder.ts

@@ -7,6 +7,7 @@ import {
 } from './helpers/buildOrderData';
 export * from './helpers/buildOrderData';
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type BuildNFTOrderInput = Omit<
   BuildNFTOrderDataInput,
   'chainId' | 'verifyingContract' | 'AugustusAddress'
@@ -17,11 +18,13 @@ type BuildNFTOrder = (
   requestParams?: RequestParameters
 ) => Promise<SignableNFTOrderData>;
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type BuildNFTOrderFunctions = {
   /** @description Build Orders that will be excuted through AugustusSwapper */
   buildNFTOrder: BuildNFTOrder;
 };
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const constructBuildNFTOrder = (
   options: ConstructFetchInput
 ): BuildNFTOrderFunctions => {

package/src/methods/nftOrders/cancelOrder.ts

@@ -5,12 +5,14 @@ import {
   constructCancelLimitOrder,
 } from '../limitOrders/cancelOrder';
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type CancelNFTOrderFunctions<T> = {
   cancelNFTOrder: CancelOrder<T>;
   cancelNFTOrderBulk: CancelOrderBulk<T>;
 };
 
 // should work the same as for LimitOrders
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const constructCancelNFTOrder = <T>(
   options: ConstructProviderFetchInput<T, 'transactCall'>
 ): CancelNFTOrderFunctions<T> => {

package/src/methods/nftOrders/getOrders.ts

@@ -28,11 +28,13 @@ type GetNFTOrders = (
   requestParams?: RequestParameters
 ) => Promise<NFTOrdersApiResponse>;
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type GetNFTOrdersFunctions = {
   getNFTOrders: GetNFTOrders;
   getNFTOrderByHash: GetNFTOrderByHash;
 };
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const constructGetNFTOrders = ({
   apiURL = API_URL,
   chainId,

package/src/methods/nftOrders/getOrdersContract.ts

@@ -1,12 +1,14 @@
 import type { ConstructFetchInput } from '../../types';
 import { constructGetSpender, GetSpender } from '../swap/spender';
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type GetNFTOrdersContractFunctions = {
   getNFTOrdersContract: GetSpender;
   getTokenTransferProxy: GetSpender;
 };
 
 // should work the same as LimitOrders
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const constructGetNFTOrdersContract = (
   options: ConstructFetchInput
 ): GetNFTOrdersContractFunctions => {

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

@@ -18,6 +18,7 @@ import {
 //   ERC721 = 2,
 // }
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const AssetType = {
   ERC20: 0,
   ERC1155: 1,

package/src/methods/nftOrders/index.ts

@@ -34,11 +34,13 @@ type SubmitNFTOrder = (
   requestParams?: RequestParameters
 ) => Promise<NFTOrderFromAPI>;
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type SubmitNFTOrderFuncs = {
   submitNFTOrder: SubmitNFTOrder;
   submitP2POrder: SubmitNFTOrder;
 };
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const constructSubmitNFTOrder = (
   options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
 ): SubmitNFTOrderFuncs => {
@@ -95,6 +97,7 @@ export const constructSubmitNFTOrder = (
   return { submitNFTOrder, submitP2POrder };
 };
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type NFTOrderHandlers<T> = SubmitNFTOrderFuncs &
   BuildNFTOrderFunctions &
   SignNFTOrderFunctions &
@@ -105,7 +108,10 @@ export type NFTOrderHandlers<T> = SubmitNFTOrderFuncs &
   CancelNFTOrderFunctions<T> &
   ApproveTokenForNFTOrderFunctions<T>;
 
-/** @description construct SDK with every NFTOrders-related method, fetching from API and contract calls */
+/**
+ * @description construct SDK with every NFTOrders-related method, fetching from API and contract calls
+ * @deprecated NFT Orders are deprecated and will be removed in a future version.
+ */
 export const constructAllNFTOrdersHandlers = <TxResponse>(
   options: ConstructProviderFetchInput<
     TxResponse,

package/src/methods/nftOrders/postOrder.ts

@@ -13,11 +13,13 @@ type PostNFTOrder = (
   requestParams?: RequestParameters
 ) => Promise<NFTOrderFromAPI>;
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type PostNFTOrderFunctions = {
   postNFTLimitOrder: PostNFTOrder;
   postNFTP2POrder: PostNFTOrder;
 };
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const constructPostNFTOrder = ({
   apiURL = API_URL,
   chainId,

package/src/methods/nftOrders/signOrder.ts

@@ -2,12 +2,14 @@ import type { ConstructProviderFetchInput } from '../../types';
 import type { SignableNFTOrderData } from './buildOrder';
 import { sanitizeOrderData } from './helpers/misc';
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type SignNFTOrderFunctions = {
   signNFTOrder: (signableOrderData: SignableNFTOrderData) => Promise<string>;
 };
 
 // returns whatever `contractCaller` returns
 // to allow for better versatility
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const constructSignNFTOrder = (
   options: Pick<
     ConstructProviderFetchInput<any, 'signTypedDataCall'>,

package/src/methods/nftOrders/transaction.ts

@@ -43,6 +43,7 @@ type BuildNFTOrdersTx = (
   requestParams?: RequestParameters
 ) => Promise<TransactionParams>;
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type BuildNFTOrdersTxFunctions = {
   getNFTOrdersRate: GetNFTOrdersRate;
   buildNFTOrderTx: BuildNFTOrdersTx;
@@ -56,6 +57,7 @@ type GetNFTOrdersRate = (
   requestParams?: RequestParameters
 ) => Promise<OptimalRate>;
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export const constructBuildNFTOrderTx = ({
   apiURL = API_URL,
   version = DEFAULT_VERSION,

package/src/sdk/full.ts

@@ -21,7 +21,9 @@ import { API_URL, DEFAULT_VERSION } from '../constants';
 
 export type AllSDKMethods<TxResponse> = {
   swap: SwapSDKMethods<TxResponse>;
+  /** @deprecated Limit Orders are deprecated and will be removed in a future version. */
   limitOrders: LimitOrderHandlers<TxResponse>;
+  /** @deprecated NFT Orders are deprecated and will be removed in a future version. */
   nftOrders: NFTOrderHandlers<TxResponse>;
   delta: DeltaOrderHandlers<TxResponse>;
   quote: GetQuoteFunctions;

package/src/sdk/partial.ts

@@ -13,7 +13,9 @@ import type { ApproveTokenForNFTOrderFunctions } from '../methods/nftOrders/appr
 import type { FillOrderDirectlyFunctions } from '../methods/limitOrders/fillOrderDirectly';
 import type { ApproveTokenForDeltaFunctions } from '../methods/delta/approveForDelta';
 import type { PreSignDeltaOrderFunctions } from '../methods/delta/preSignDeltaOrder';
+import type { PreSignExternalDeltaOrderFunctions } from '../methods/delta/preSignExternalDeltaOrder';
 import type { DeltaTokenModuleFunctions } from '../methods/delta/deltaTokenModule';
+import type { PreSignTWAPDeltaOrderFunctions } from '../methods/delta/preSignTWAPDeltaOrder';
 import { API_URL, DEFAULT_VERSION } from '../constants';
 
 export type SDKConfig<TxResponse = any> = ConstructProviderFetchInput<
@@ -54,7 +56,9 @@ type InferWithTxResponse<
           ApproveTokenForNFTOrderFunctions<TxResponse>,
           ApproveTokenForDeltaFunctions<TxResponse>,
           PreSignDeltaOrderFunctions<TxResponse>,
-          DeltaTokenModuleFunctions<TxResponse>
+          PreSignExternalDeltaOrderFunctions<TxResponse>,
+          DeltaTokenModuleFunctions<TxResponse>,
+          PreSignTWAPDeltaOrderFunctions<TxResponse>
         ]
         // then merge IntersectionOfReturns<Funcs> with them recursively
       >

package/src/sdk/simple.ts

@@ -145,12 +145,14 @@ export type SwapFetchMethods = GetBalancesFunctions &
   GetRateFunctions &
   GetSwapTxFunctions;
 
+/** @deprecated Limit Orders are deprecated and will be removed in a future version. */
 export type LimitOrdersFetchMethods = GetLimitOrdersContractFunctions &
   GetLimitOrdersFunctions &
   BuildLimitOrderFunctions &
   PostLimitOrderFunctions &
   BuildLimitOrdersTxFunctions;
 
+/** @deprecated NFT Orders are deprecated and will be removed in a future version. */
 export type NFTOrdersFetchMethods = GetNFTOrdersContractFunctions &
   GetNFTOrdersFunctions &
   BuildNFTOrderFunctions &
@@ -168,7 +170,9 @@ export type DeltaFetchMethods = BuildDeltaOrderFunctions &
 
 export type SimpleFetchSDK = {
   swap: SwapFetchMethods;
+  /** @deprecated Limit Orders are deprecated and will be removed in a future version. */
   limitOrders: LimitOrdersFetchMethods;
+  /** @deprecated NFT Orders are deprecated and will be removed in a future version. */
   nftOrders: NFTOrdersFetchMethods;
   delta: DeltaFetchMethods;
   quote: QuoteFetchMethods;
@@ -178,7 +182,9 @@ export type QuoteFetchMethods = GetQuoteFunctions;
 
 export type SimpleSDK = {
   swap: SwapSDKMethods<TxHash>;
+  /** @deprecated Limit Orders are deprecated and will be removed in a future version. */
   limitOrders: LimitOrderHandlers<TxHash>;
+  /** @deprecated NFT Orders are deprecated and will be removed in a future version. */
   nftOrders: NFTOrderHandlers<TxHash>;
   delta: DeltaOrderHandlers<TxHash>;
   quote: QuoteFetchMethods;