@velora-dex/sdk 9.5.3-dev.1 → 9.5.4-dev.0

package/src/methods/delta/getDeltaOrders.ts

@@ -8,7 +8,8 @@ import type {
 import type {
   DeltaAuction,
   DeltaAuctionStatus,
-  OnChainOrderType,
+  DeltaOrderType,
+  OnChainOrderMap,
 } from './helpers/types';
 
 /** @deprecated Use DeltaAuction directly */
@@ -32,7 +33,7 @@ type GetDeltaOrderByHash = (
   requestParams?: RequestParameters
 ) => Promise<DeltaAuction>;
 
-type OrdersFilter<T extends OnChainOrderType = OnChainOrderType> = {
+type OrdersFilter<T extends keyof OnChainOrderMap = keyof OnChainOrderMap> = {
   /** @description Order.owner to fetch Delta Order for */
   userAddress: Address;
   /** @description Pagination option, page. Default 1 */
@@ -52,7 +53,7 @@ type OrdersFilter<T extends OnChainOrderType = OnChainOrderType> = {
    */
   status?: DeltaOrderFilterByStatus[];
   /** @description Filter by type. MARKET, LIMIT. Orders with both types are returned if not specified */
-  type?: 'MARKET' | 'LIMIT';
+  type?: DeltaOrderType;
   /** @description Filter by on-chain order type. Order, ExternalOrder. Orders of all types are returned if not specified */
   onChainOrderType?: T;
 };
@@ -62,7 +63,7 @@ type OrderFiltersQuery = Omit<OrdersFilter, 'chainId' | 'status'> & {
 };
 
 type GetDeltaOrders = {
-  <T extends OnChainOrderType>(
+  <T extends keyof OnChainOrderMap>(
     options: OrdersFilter<T> & { onChainOrderType: T },
     requestParams?: RequestParameters
   ): Promise<DeltaAuction<T>[]>;
@@ -126,7 +127,7 @@ export const constructGetDeltaOrders = ({
   };
 
   const getDeltaOrders: GetDeltaOrders = async <
-    T extends OnChainOrderType = OnChainOrderType
+    T extends keyof OnChainOrderMap = keyof OnChainOrderMap
   >(
     options: OrdersFilter<T>,
     requestParams?: RequestParameters

package/src/methods/delta/getDeltaPrice.ts

@@ -12,7 +12,7 @@ import { BridgePriceInfo } from './helpers/types';
 type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
 
 export type DeltaPriceParams = {
-  /** @description Source Token Address. Not Native Token */
+  /** @description Source Token Address */
   srcToken: string;
   /** @description Destination Token Address */
   destToken: string;

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

@@ -7,7 +7,6 @@ import {
   DeltaAuctionTransaction,
   DeltaAuctionTWAP,
   DeltaAuctionTWAPBuy,
-  DeltaAuctionUnion,
   DeltaOrderUnion,
   ExternalDeltaOrder,
   OnChainOrderType,
@@ -359,6 +358,7 @@ function getAuctionAmounts(auction: DeltaAuction) {
 
   let expected = {
     srcAmount: auction.order.srcAmount,
+    // defensive fallback in case Order shape changes or legacy Orders don't have all fields
     destAmount: auction.order.expectedAmount || auction.order.destAmount,
   };
 
@@ -402,7 +402,7 @@ function isOrderCrosschain<T extends { bridge?: Bridge } | object>(
 function scaleByFactor(amount: bigint, scalingFactor: number): bigint {
   if (!amount) return 0n;
 
-  if (scalingFactor === undefined) return amount;
+  if (scalingFactor === 0) return amount;
 
   const base = 10n;
 
@@ -538,111 +538,19 @@ function isPartiallyExecutedAuction<
 function getFilledPercent(
   auction: Pick<DeltaAuction, 'order' | 'transactions'>
 ): number {
-  const transaction = !isOrderCrosschain(auction.order)
+  const completeTransactions = !isOrderCrosschain(auction.order)
     ? auction.transactions
     : auction.transactions.filter(
         (transaction) => transaction.bridgeStatus === 'filled'
       );
 
-  const filledPercentBps = transaction.reduce((acc, { filledPercent }) => {
-    return acc + filledPercent;
-  }, 0);
+  const filledPercentBps = completeTransactions.reduce(
+    (acc, { filledPercent }) => {
+      return acc + filledPercent;
+    },
+    0
+  );
 
   const filledPercent = filledPercentBps / 100;
   return filledPercent;
 }
-
-///// TESTS //////
-// @TODO remove
-
-const auction = {} as DeltaAuctionUnion;
-const minAuction = {
-  onChainOrderType: 'TWAPOrder' as OnChainOrderType,
-  gas: 6,
-};
-if (isTWAPAuction(minAuction)) {
-  console.log('🚀 ~ auction:', minAuction);
-  /**
-   * {
-    onChainOrderType: OnChainOrderType;
-    gas: number;
-    } & {
-        onChainOrderType: "TWAPOrder" | "TWAPBuyOrder";
-    }
-   */
-}
-if (isTWAPAuction(auction)) {
-  console.log('🚀 ~ auction:', auction);
-  /**
-   (DeltaAuctionBase & {
-      onChainOrderType: "TWAPOrder";
-      order: TWAPDeltaOrder;
-    }) | (DeltaAuctionBase & {
-        onChainOrderType: "TWAPBuyOrder";
-        order: TWAPBuyDeltaOrder;
-    })
-   */
-}
-if (isTWAPSellAuction(auction)) {
-  console.log('🚀 ~ auction:', auction);
-  /**
-   * DeltaAuctionBase & {
-      onChainOrderType: "TWAPOrder";
-      order: TWAPDeltaOrder;
-    }
-   */
-}
-if (isTWAPBuyAuction(auction)) {
-  console.log('🚀 ~ auction:', auction);
-  /**
-   * DeltaAuctionBase & {
-      onChainOrderType: "TWAPBuyOrder";
-      order: TWAPBuyDeltaOrder;
-    }
-   */
-}
-if (isDeltaAuction(auction)) {
-  console.log('🚀 ~ auction:', auction);
-  /**
-   * DeltaAuctionBase & {
-      onChainOrderType: "Order";
-      order: DeltaAuctionOrder;
-    }
-   */
-}
-
-if (isExternalAuction(auction)) {
-  console.log('🚀 ~ auction:', auction);
-  /**
-   * DeltaAuctionBase & {
-      onChainOrderType: "ExternalOrder";
-      order: ExternalDeltaOrder;
-    }
-   */
-}
-// ------------------------------------------------------------ //
-
-const orderAny = {} as DeltaOrderUnion;
-if (isOrderCrosschain(orderAny)) {
-  console.log('🚀 ~ order:', orderAny);
-  /**
-    DeltaAuctionOrder | TWAPDeltaOrder | TWAPBuyDeltaOrder
-   */
-}
-const orderExternal = {} as ExternalDeltaOrder;
-if (isOrderCrosschain(orderExternal)) {
-  console.log('🚀 ~ order:', orderExternal);
-  /**
-    never
-   */
-}
-const orderLike = {} as { bridge?: Bridge; a: 2 };
-if (isOrderCrosschain(orderLike)) {
-  console.log('🚀 ~ order:', orderLike);
-  /**
-   * {
-      bridge: Bridge;
-      a: 2;
-    }
-   */
-}

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

@@ -204,7 +204,7 @@ export type DeltaAuctionTransaction = {
   agent: string;
   auctionId: string;
 
-  // bridge* fileds = null for single-chain orders and all TWAP orders
+  // transactgion.bridge* fields = null for single-chain orders
   bridgeMetadata: BridgeMetadata | null;
   bridgeStatus: BridgeStatus | null;
   bridgeProtocol: string | null;
@@ -248,21 +248,23 @@ type DeltaAuctionBase = {
   excludeAgents: string[] | null;
   includeAgents: string[] | null;
 
+  // bridge* fields = null for single-chain orders and all TWAP orders
   bridgeMetadata: BridgeMetadata | null;
   bridgeStatus: BridgeStatus | null;
 
-  type: 'MARKET' | 'LIMIT';
+  type: DeltaOrderType;
 };
 
-export type DeltaAuction<T extends OnChainOrderType = OnChainOrderType> =
-  T extends T
-    ? Prettify<
-        DeltaAuctionBase & {
-          onChainOrderType: T;
-          order: OnChainOrderMap[T];
-        } & BridgeAuctionFiledsMap[T]
-      >
-    : never;
+export type DeltaAuction<
+  T extends keyof OnChainOrderMap = keyof OnChainOrderMap
+> = T extends T
+  ? Prettify<
+      DeltaAuctionBase & {
+        onChainOrderType: T;
+        order: OnChainOrderMap[T];
+      } & BridgeAuctionFiledsMap[T]
+    >
+  : never;
 
 export type DeltaAuctionDelta = DeltaAuction<'Order'>;
 export type DeltaAuctionExternal = DeltaAuction<'ExternalOrder'>;
@@ -278,8 +280,13 @@ export type DeltaAuctionUnion =
 export type DeltaOrderUnion = OnChainOrderMap[keyof OnChainOrderMap];
 
 export type BridgeMetadata = {
-  /** @description The amount that user should expect to get */
+  /** @description Actual amount received on the destination chain. */
   outputAmount: string;
+  /** @description Field is present iff: order was built via POST /v2/orders/build,
+   * the route is cross-chain (route.bridge !== null and not an external handler),
+   * and the order is posted before the per-order cache entry expires.
+   */
+  expectedOutputAmount?: string;
   /** @description The cross-chain deadline. If deadline passes, the bridgeStatus would be expired */
   fillDeadline?: number; // available for Across protocol
   /** @description The deposit id */
@@ -297,10 +304,14 @@ export type OnChainOrderType =
   | 'Order'
   | 'ExternalOrder'
   | 'TWAPOrder'
-  | 'TWAPBuyOrder';
+  | 'TWAPBuyOrder'
+  | 'ProductiveOrder';
 
 export type TWAPOnChainOrderType = 'TWAPOrder' | 'TWAPBuyOrder';
 
+/** @description Order kind: MARKET (immediate) vs LIMIT (rate-pegged). */
+export type DeltaOrderType = 'MARKET' | 'LIMIT';
+
 //// available on BridgePrice ////
 
 type BridgeQuoteFee = {

package/src/methods/delta/postDeltaOrder.ts

@@ -3,11 +3,11 @@ import { constructSearchString } from '../../helpers/misc';
 import type { ConstructFetchInput, RequestParameters } from '../../types';
 import type {
   DeltaAuction,
+  DeltaOrderType,
   OnChainOrderMap,
-  OnChainOrderType,
 } from './helpers/types';
 
-export type DeltaOrderToPost<T extends OnChainOrderType = 'Order'> = {
+export type DeltaOrderToPost<T extends keyof OnChainOrderMap = 'Order'> = {
   /** @description Partner string */
   partner?: string;
   /** @description Referrer address */
@@ -20,7 +20,7 @@ export type DeltaOrderToPost<T extends OnChainOrderType = 'Order'> = {
   partiallyFillable?: boolean;
 
   /** @description Type of the order. MARKET or LIMIT. Default is MARKET */
-  type?: 'MARKET' | 'LIMIT';
+  type?: DeltaOrderType;
 
   includeAgents?: string[];
   excludeAgents?: string[];
@@ -53,7 +53,7 @@ export const constructPostDeltaOrder = ({
     const search = constructSearchString<{ degenMode?: boolean }>({
       degenMode,
     });
-    const fetchURL = `${postOrderUrl}/${search}` as const;
+    const fetchURL = `${postOrderUrl}${search}` as const;
 
     return fetcher<DeltaAuction<'Order'>>({
       url: fetchURL,

package/src/methods/delta/postTWAPDeltaOrder.ts

@@ -43,7 +43,7 @@ export const constructPostTWAPDeltaOrder = ({
       degenMode,
     });
 
-    const fetchURL = `${postOrderUrl}/${search}` as const;
+    const fetchURL = `${postOrderUrl}${search}` as const;
 
     return fetcher<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>({
       url: fetchURL,

package/src/methods/deltaV2/buildDeltaOrderV2.ts

@@ -0,0 +1,86 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { BuiltDeltaOrderV2, DeltaRoute } from './types';
+export type { BuiltDeltaOrderV2 } from './types';
+
+export type BuildDeltaOrderV2Params = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the order beneficiary. Defaults to owner. */
+  beneficiary?: string;
+  /** @description The deadline for the order (unix seconds) */
+  deadline?: number;
+  /** @description The nonce of the order. Random if omitted. */
+  nonce?: string;
+  /** @description Optional permit signature for the src token. Defaults to "0x". */
+  permit?: string;
+  /** @description Partner string. Passed to the server to resolve partner fee details. */
+  partner?: string;
+  /** @description Partner fee in basis points (bps), 50bps=0.5% */
+  partnerFeeBps?: number;
+  /** @description Partner address */
+  partnerAddress?: string;
+  /** @description Take surplus flag */
+  partnerTakesSurplus?: boolean;
+  /** @description Whether the surplus should be capped. True by default. */
+  capSurplus?: boolean;
+  /** @description Metadata for the order, hex string */
+  metadata?: string;
+  /** @description Designates the Order as partially fillable instead of fill-or-kill. Default false. */
+  partiallyFillable?: boolean;
+
+  /** @description DeltaRoute from getDeltaPriceV2 — either priceV2.route or any priceV2.alternatives[i] */
+  route: DeltaRoute;
+  /** @description Order side. SELL or BUY. */
+  side: 'SELL' | 'BUY';
+  /** @description Slippage in basis points (bps). 10000 = 100%, 50 = 0.5%. Default 0. */
+  slippage?: number;
+  /** @description If passed, the server will use this as SELL destAmount (as BUY srcAmount) and expectedAmount */
+  limitAmount?: string;
+};
+
+type BuildDeltaOrderV2 = (
+  buildOrderParams: BuildDeltaOrderV2Params,
+  requestParams?: RequestParameters
+) => Promise<BuiltDeltaOrderV2>;
+
+export type BuildDeltaOrderV2Functions = {
+  /** @description Build a Delta v2 order from a DeltaRoute via the server endpoint, ready to sign and post. */
+  buildDeltaOrderV2: BuildDeltaOrderV2;
+};
+
+export const constructBuildDeltaOrderV2 = (
+  options: ConstructFetchInput
+): BuildDeltaOrderV2Functions => {
+  const { apiURL = API_URL, chainId, fetcher } = options;
+  const buildUrl = `${apiURL}/delta/v2/orders/build` as const;
+
+  const buildDeltaOrderV2: BuildDeltaOrderV2 = async (params, requestParams) =>
+    fetcher<BuiltDeltaOrderV2>({
+      url: buildUrl,
+      method: 'POST',
+      data: {
+        chainId,
+        side: params.side,
+        route: params.route,
+        owner: params.owner,
+        beneficiary: params.beneficiary,
+        deadline: params.deadline,
+        nonce: params.nonce,
+        permit: params.permit,
+        slippage: params.slippage,
+        limitAmount: params.limitAmount,
+        metadata: params.metadata,
+        partiallyFillable: params.partiallyFillable,
+        partner: params.partner,
+        partnerAddress: params.partnerAddress,
+        partnerFeeBps: params.partnerFeeBps,
+        partnerTakesSurplus: params.partnerTakesSurplus,
+        capSurplus: params.capSurplus,
+        orderType: 'Order',
+      },
+      requestParams,
+    });
+
+  return { buildDeltaOrderV2 };
+};

package/src/methods/deltaV2/buildExternalDeltaOrderV2.ts

@@ -0,0 +1,95 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { BuiltDeltaOrderV2, DeltaRoute } from './types';
+export type { BuiltDeltaOrderV2 } from './types';
+
+export type BuildExternalDeltaOrderV2Params = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the external handler contract */
+  handler: string;
+  /** @description Protocol-specific encoded bytes for the external handler */
+  data: string;
+  /** @description The address of the order beneficiary. Defaults to owner. */
+  beneficiary?: string;
+  /** @description The deadline for the order (unix seconds) */
+  deadline?: number;
+  /** @description The nonce of the order. Random if omitted. */
+  nonce?: string;
+  /** @description Optional permit signature for the src token. Defaults to "0x". */
+  permit?: string;
+  /** @description Partner string. Passed to the server to resolve partner fee details. */
+  partner?: string;
+  /** @description Partner fee in basis points (bps), 50bps=0.5% */
+  partnerFeeBps?: number;
+  /** @description Partner address */
+  partnerAddress?: string;
+  /** @description Take surplus flag */
+  partnerTakesSurplus?: boolean;
+  /** @description Whether the surplus should be capped. True by default. */
+  capSurplus?: boolean;
+  /** @description Metadata for the order, hex string */
+  metadata?: string;
+  /** @description Designates the Order as partially fillable. Default false. */
+  partiallyFillable?: boolean;
+
+  /** @description DeltaRoute from getDeltaPriceV2 */
+  route: DeltaRoute;
+  /** @description Order side. SELL or BUY. */
+  side: 'SELL' | 'BUY';
+  /** @description Slippage in basis points (bps). Default 0. */
+  slippage?: number;
+  /** @description If passed, the server will use this as SELL destAmount (as BUY srcAmount) and expectedAmount */
+  limitAmount?: string;
+};
+
+type BuildExternalDeltaOrderV2 = (
+  buildOrderParams: BuildExternalDeltaOrderV2Params,
+  requestParams?: RequestParameters
+) => Promise<BuiltDeltaOrderV2>;
+
+export type BuildExternalDeltaOrderV2Functions = {
+  /** @description Build a Delta v2 External Order from a DeltaRoute via the server endpoint, ready to sign and post. */
+  buildExternalDeltaOrderV2: BuildExternalDeltaOrderV2;
+};
+
+export const constructBuildExternalDeltaOrderV2 = (
+  options: ConstructFetchInput
+): BuildExternalDeltaOrderV2Functions => {
+  const { apiURL = API_URL, chainId, fetcher } = options;
+  const buildUrl = `${apiURL}/delta/v2/orders/build` as const;
+
+  const buildExternalDeltaOrderV2: BuildExternalDeltaOrderV2 = async (
+    params,
+    requestParams
+  ) =>
+    fetcher<BuiltDeltaOrderV2>({
+      url: buildUrl,
+      method: 'POST',
+      data: {
+        chainId,
+        side: params.side,
+        route: params.route,
+        owner: params.owner,
+        handler: params.handler,
+        data: params.data,
+        beneficiary: params.beneficiary,
+        deadline: params.deadline,
+        nonce: params.nonce,
+        permit: params.permit,
+        slippage: params.slippage,
+        limitAmount: params.limitAmount,
+        metadata: params.metadata,
+        partiallyFillable: params.partiallyFillable,
+        partner: params.partner,
+        partnerAddress: params.partnerAddress,
+        partnerFeeBps: params.partnerFeeBps,
+        partnerTakesSurplus: params.partnerTakesSurplus,
+        capSurplus: params.capSurplus,
+        orderType: 'ExternalOrder',
+      },
+      requestParams,
+    });
+
+  return { buildExternalDeltaOrderV2 };
+};

package/src/methods/deltaV2/buildTWAPDeltaOrderV2.ts

@@ -0,0 +1,131 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { BuiltDeltaOrderV2, DeltaRoute } from './types';
+export type { BuiltDeltaOrderV2 } from './types';
+
+type BuildTWAPDeltaOrderV2Base = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the order beneficiary. Defaults to owner. */
+  beneficiary?: string;
+  /** @description The deadline for the order (unix seconds) */
+  deadline?: number;
+  /** @description The nonce of the order. Random if omitted. */
+  nonce?: string;
+  /** @description Optional permit signature for the src token. Defaults to "0x". */
+  permit?: string;
+  /** @description Partner string. Passed to the server to resolve partner fee details. */
+  partner?: string;
+  /** @description Seconds between slice executions (min 60) */
+  interval: number;
+  /** @description Number of slices (min 2) */
+  numSlices: number;
+  /** @description Slippage in basis points (bps). 10000 = 100%, 50 = 0.5%. Default 0. */
+  slippage?: number;
+  /** @description DeltaRoute from getDeltaPriceV2 for a single slice */
+  route: DeltaRoute;
+  /** @description Partner fee in basis points (bps) */
+  partnerFeeBps?: number;
+  /** @description Partner address */
+  partnerAddress?: string;
+  /** @description Take surplus flag */
+  partnerTakesSurplus?: boolean;
+  /** @description Whether the surplus should be capped. True by default. */
+  capSurplus?: boolean;
+  /** @description Metadata for the order, hex string */
+  metadata?: string;
+  /** @description Designates the Order as partially fillable. Default false. */
+  partiallyFillable?: boolean;
+  /** @description If passed, the server will use this as SELL destAmount (as BUY srcAmount) and expectedAmount for each slice */
+  limitAmount?: string;
+};
+
+export type BuildTWAPSellDeltaOrderV2Params = BuildTWAPDeltaOrderV2Base & {
+  onChainOrderType: 'TWAPOrder';
+  /** @description Total source token amount across all slices. route.origin.input.amount must equal floor(totalSrcAmount / numSlices). */
+  totalSrcAmount: string;
+};
+
+export type BuildTWAPBuyDeltaOrderV2Params = BuildTWAPDeltaOrderV2Base & {
+  onChainOrderType: 'TWAPBuyOrder';
+  /** @description Total destination token amount to buy across all slices. route.origin.output.amount must equal floor(totalDestAmount / numSlices). */
+  totalDestAmount: string;
+  /** @description Maximum source token amount willing to spend across all slices. */
+  maxSrcAmount: string;
+};
+
+export type BuildTWAPDeltaOrderV2Params =
+  | BuildTWAPSellDeltaOrderV2Params
+  | BuildTWAPBuyDeltaOrderV2Params;
+
+type BuildTWAPDeltaOrderV2 = (
+  buildOrderParams: BuildTWAPDeltaOrderV2Params,
+  requestParams?: RequestParameters
+) => Promise<BuiltDeltaOrderV2>;
+
+export type BuildTWAPDeltaOrderV2Functions = {
+  /** @description Build a Delta v2 TWAP Order (sell or buy) from a DeltaRoute via the server endpoint, ready to sign and post. */
+  buildTWAPDeltaOrderV2: BuildTWAPDeltaOrderV2;
+};
+
+export const constructBuildTWAPDeltaOrderV2 = (
+  options: ConstructFetchInput
+): BuildTWAPDeltaOrderV2Functions => {
+  const { apiURL = API_URL, chainId, fetcher } = options;
+  const buildUrl = `${apiURL}/delta/v2/orders/build` as const;
+
+  const buildTWAPDeltaOrderV2: BuildTWAPDeltaOrderV2 = async (
+    params,
+    requestParams
+  ) => {
+    const commonBody = {
+      chainId,
+      route: params.route,
+      owner: params.owner,
+      beneficiary: params.beneficiary,
+      deadline: params.deadline,
+      nonce: params.nonce,
+      permit: params.permit,
+      slippage: params.slippage,
+      limitAmount: params.limitAmount,
+      metadata: params.metadata,
+      partiallyFillable: params.partiallyFillable,
+      partner: params.partner,
+      partnerAddress: params.partnerAddress,
+      partnerFeeBps: params.partnerFeeBps,
+      partnerTakesSurplus: params.partnerTakesSurplus,
+      capSurplus: params.capSurplus,
+      interval: params.interval,
+      numSlices: params.numSlices,
+    };
+
+    if (params.onChainOrderType === 'TWAPOrder') {
+      return fetcher<BuiltDeltaOrderV2>({
+        url: buildUrl,
+        method: 'POST',
+        data: {
+          ...commonBody,
+          side: 'SELL',
+          orderType: 'TWAPOrder',
+          totalSrcAmount: params.totalSrcAmount,
+        },
+        requestParams,
+      });
+    }
+
+    return fetcher<BuiltDeltaOrderV2>({
+      url: buildUrl,
+      method: 'POST',
+      data: {
+        ...commonBody,
+        side: 'BUY',
+        orderType: 'TWAPBuyOrder',
+        totalDestAmount: params.totalDestAmount,
+        maxSrcAmount: params.maxSrcAmount,
+      },
+      requestParams,
+    });
+  };
+
+  return { buildTWAPDeltaOrderV2 };
+};