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

package/src/methods/deltaV2/getDeltaPriceV2.ts

@@ -0,0 +1,108 @@
+import { API_URL, SwapSide } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type {
+  ConstructFetchInput,
+  EnumerateLiteral,
+  RequestParameters,
+} from '../../types';
+import type { DeltaPriceV2 } from './types';
+
+type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
+
+export type DeltaPriceV2Params = {
+  /** @description Source Token Address */
+  srcToken: string;
+  /** @description Destination Token Address. For Crosschain Orders, the destination token on the destination chain */
+  destToken: string;
+  /** @description srcToken amount in wei */
+  amount: string;
+  /** @description Source Token Decimals */
+  srcDecimals: number;
+  /** @description Destination Token Decimals */
+  destDecimals: number;
+  /** @description User's Wallet Address */
+  userAddress?: string;
+  /** @description Beneficiary Address */
+  beneficiary?: string;
+  /** @description Partner string. */
+  partner?: string;
+  /** @description Partner fee in basis points (bps), 50bps=0.5% */
+  partnerFeeBps?: number;
+  /** @description Destination Chain ID for Crosschain Orders */
+  destChainId?: number;
+  /** @description SELL or BUY, default is SELL */
+  side?: SwapSideUnion;
+  /** @description In %. Bypasses the API price impact check (default = 15%) */
+  maxImpact?: number;
+  maxUSDImpact?: number;
+
+  includeAgents?: string[];
+  excludeAgents?: string[];
+  includeBridges?: string[];
+  excludeBridges?: string[];
+
+  /** @description Allow swap on destChain after bridge. Default is true. */
+  allowBridgeAndSwap?: boolean;
+  degenMode?: boolean;
+};
+
+type DeltaPriceV2QueryOptions = Omit<
+  DeltaPriceV2Params,
+  'includeAgents' | 'excludeAgents' | 'includeBridges' | 'excludeBridges'
+> & {
+  chainId: number;
+  includeAgents?: string;
+  excludeAgents?: string;
+  includeBridges?: string;
+  excludeBridges?: string;
+};
+
+type GetDeltaPriceV2 = (
+  options: DeltaPriceV2Params,
+  requestParams?: RequestParameters
+) => Promise<DeltaPriceV2>;
+
+export type GetDeltaPriceV2Functions = {
+  /** @description Fetch a v2 price quote (route-based response). */
+  getDeltaPriceV2: GetDeltaPriceV2;
+};
+
+export const constructGetDeltaPriceV2 = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): GetDeltaPriceV2Functions => {
+  const pricesUrl = `${apiURL}/delta/v2/prices` as const;
+
+  const getDeltaPriceV2: GetDeltaPriceV2 = async (options, requestParams) => {
+    const {
+      includeAgents,
+      excludeAgents,
+      includeBridges,
+      excludeBridges,
+      ...rest
+    } = options;
+
+    const search = constructSearchString<DeltaPriceV2QueryOptions>({
+      ...rest,
+      chainId,
+      side: options.side ?? SwapSide.SELL,
+      includeAgents: includeAgents?.join(','),
+      excludeAgents: excludeAgents?.join(','),
+      includeBridges: includeBridges?.join(','),
+      excludeBridges: excludeBridges?.join(','),
+    });
+
+    const fetchURL = `${pricesUrl}${search}` as const;
+
+    const data = await fetcher<DeltaPriceV2>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data;
+  };
+
+  return { getDeltaPriceV2 };
+};

package/src/methods/deltaV2/index.ts

@@ -0,0 +1,303 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import type { DeltaAuction, OnChainOrderMap } from '../delta/helpers/types';
+
+// reused v1 modules
+import {
+  GetDeltaContractFunctions,
+  constructGetDeltaContract,
+} from '../delta/getDeltaContract';
+import {
+  constructGetPartnerFee,
+  GetPartnerFeeFunctions,
+} from '../delta/getPartnerFee';
+import {
+  ApproveTokenForDeltaFunctions,
+  constructApproveTokenForDelta,
+} from '../delta/approveForDelta';
+import {
+  constructPreSignDeltaOrder,
+  PreSignDeltaOrderFunctions,
+} from '../delta/preSignDeltaOrder';
+import {
+  constructPreSignExternalDeltaOrder,
+  PreSignExternalDeltaOrderFunctions,
+} from '../delta/preSignExternalDeltaOrder';
+import {
+  constructPreSignTWAPDeltaOrder,
+  PreSignTWAPDeltaOrderFunctions,
+} from '../delta/preSignTWAPDeltaOrder';
+import {
+  DeltaTokenModuleFunctions,
+  constructDeltaTokenModule,
+} from '../delta/deltaTokenModule';
+
+// new v2 modules
+import {
+  BuildDeltaOrderV2Functions,
+  BuildDeltaOrderV2Params,
+  BuiltDeltaOrderV2,
+  constructBuildDeltaOrderV2,
+} from './buildDeltaOrderV2';
+import {
+  BuildExternalDeltaOrderV2Functions,
+  BuildExternalDeltaOrderV2Params,
+  constructBuildExternalDeltaOrderV2,
+} from './buildExternalDeltaOrderV2';
+import {
+  BuildTWAPDeltaOrderV2Functions,
+  BuildTWAPDeltaOrderV2Params,
+  constructBuildTWAPDeltaOrderV2,
+} from './buildTWAPDeltaOrderV2';
+import {
+  constructPostDeltaOrderV2,
+  DeltaOrderToPostV2,
+  PostDeltaOrderV2Functions,
+} from './postDeltaOrderV2';
+import {
+  constructPostExternalDeltaOrderV2,
+  PostExternalDeltaOrderV2Functions,
+} from './postExternalDeltaOrderV2';
+import {
+  constructPostTWAPDeltaOrderV2,
+  PostTWAPDeltaOrderV2Functions,
+} from './postTWAPDeltaOrderV2';
+import {
+  constructGetDeltaPriceV2,
+  GetDeltaPriceV2Functions,
+} from './getDeltaPriceV2';
+import {
+  constructGetDeltaOrdersV2,
+  GetDeltaOrdersV2Functions,
+} from './getDeltaOrdersV2';
+import {
+  constructGetBridgeRoutes,
+  GetBridgeRoutesFunctions,
+} from './getBridgeRoutes';
+import {
+  constructIsTokenSupportedInDeltaV2,
+  IsTokenSupportedInDeltaV2Functions,
+} from './isTokenSupportedInDeltaV2';
+import {
+  CancelDeltaOrderV2Functions,
+  constructCancelDeltaOrderV2,
+} from './cancelDeltaOrderV2';
+import {
+  constructGetAgentsListV2,
+  GetAgentsListV2Functions,
+} from './getAgentsListV2';
+
+// ── Sign v2 ─────────────────────────────────────────────────────────────────
+
+type SignDeltaOrderV2 = (builtOrder: BuiltDeltaOrderV2) => Promise<string>;
+
+export type SignDeltaOrderV2Functions = {
+  /** @description Sign a BuiltDeltaOrderV2 (any order type) using EIP-712 typed data. */
+  signDeltaOrderV2: SignDeltaOrderV2;
+};
+
+export const constructSignDeltaOrderV2 = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller'
+  >
+): SignDeltaOrderV2Functions => {
+  const signDeltaOrderV2: SignDeltaOrderV2 = async (builtOrder) => {
+    return options.contractCaller.signTypedDataCall({
+      types: builtOrder.toSign.types,
+      domain: builtOrder.toSign.domain,
+      data: builtOrder.toSign.value,
+    });
+  };
+  return { signDeltaOrderV2 };
+};
+
+// ── Submit orchestrators ─────────────────────────────────────────────────────
+
+export type SubmitDeltaOrderV2Params = BuildDeltaOrderV2Params & {
+  /** @description Referrer address */
+  referrerAddress?: string;
+  degenMode?: boolean;
+} & Pick<DeltaOrderToPostV2, 'type' | 'includeAgents' | 'excludeAgents'>;
+
+type SubmitDeltaOrderV2 = (
+  orderParams: SubmitDeltaOrderV2Params
+) => Promise<DeltaAuction<'Order'>>;
+
+export type SubmitDeltaOrderV2Funcs = {
+  submitDeltaOrderV2: SubmitDeltaOrderV2;
+};
+
+export const constructSubmitDeltaOrderV2 = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitDeltaOrderV2Funcs => {
+  const { buildDeltaOrderV2 } = constructBuildDeltaOrderV2(options);
+  const { signDeltaOrderV2 } = constructSignDeltaOrderV2(options);
+  const { postDeltaOrderV2 } = constructPostDeltaOrderV2(options);
+
+  const submitDeltaOrderV2: SubmitDeltaOrderV2 = async (orderParams) => {
+    const orderData = await buildDeltaOrderV2(orderParams);
+    const signature = await signDeltaOrderV2(orderData);
+
+    return postDeltaOrderV2({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.toSign.value as OnChainOrderMap['Order'],
+      partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
+      degenMode: orderParams.degenMode,
+    });
+  };
+
+  return { submitDeltaOrderV2 };
+};
+
+export type SubmitExternalDeltaOrderV2Params =
+  BuildExternalDeltaOrderV2Params & {
+    referrerAddress?: string;
+  } & Pick<DeltaOrderToPostV2, 'type' | 'includeAgents' | 'excludeAgents'>;
+
+type SubmitExternalDeltaOrderV2 = (
+  orderParams: SubmitExternalDeltaOrderV2Params
+) => Promise<DeltaAuction<'ExternalOrder'>>;
+
+export type SubmitExternalDeltaOrderV2Funcs = {
+  submitExternalDeltaOrderV2: SubmitExternalDeltaOrderV2;
+};
+
+export const constructSubmitExternalDeltaOrderV2 = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitExternalDeltaOrderV2Funcs => {
+  const { buildExternalDeltaOrderV2 } =
+    constructBuildExternalDeltaOrderV2(options);
+  const { signDeltaOrderV2 } = constructSignDeltaOrderV2(options);
+  const { postExternalDeltaOrderV2 } =
+    constructPostExternalDeltaOrderV2(options);
+
+  const submitExternalDeltaOrderV2: SubmitExternalDeltaOrderV2 = async (
+    orderParams
+  ) => {
+    const orderData = await buildExternalDeltaOrderV2(orderParams);
+    const signature = await signDeltaOrderV2(orderData);
+
+    return postExternalDeltaOrderV2({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.toSign.value as OnChainOrderMap['ExternalOrder'],
+      partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
+    });
+  };
+
+  return { submitExternalDeltaOrderV2 };
+};
+
+export type SubmitTWAPDeltaOrderV2Params = BuildTWAPDeltaOrderV2Params & {
+  referrerAddress?: string;
+  degenMode?: boolean;
+} & Pick<DeltaOrderToPostV2, 'type' | 'includeAgents' | 'excludeAgents'>;
+
+type SubmitTWAPDeltaOrderV2 = (
+  orderParams: SubmitTWAPDeltaOrderV2Params
+) => Promise<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>;
+
+export type SubmitTWAPDeltaOrderV2Funcs = {
+  submitTWAPDeltaOrderV2: SubmitTWAPDeltaOrderV2;
+};
+
+export const constructSubmitTWAPDeltaOrderV2 = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitTWAPDeltaOrderV2Funcs => {
+  const { buildTWAPDeltaOrderV2 } = constructBuildTWAPDeltaOrderV2(options);
+  const { signDeltaOrderV2 } = constructSignDeltaOrderV2(options);
+  const { postTWAPDeltaOrderV2 } = constructPostTWAPDeltaOrderV2(options);
+
+  const submitTWAPDeltaOrderV2: SubmitTWAPDeltaOrderV2 = async (
+    orderParams
+  ) => {
+    const orderData = await buildTWAPDeltaOrderV2(orderParams);
+    const signature = await signDeltaOrderV2(orderData);
+
+    return postTWAPDeltaOrderV2({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.toSign.value as
+        | OnChainOrderMap['TWAPOrder']
+        | OnChainOrderMap['TWAPBuyOrder'],
+      onChainOrderType: orderParams.onChainOrderType,
+      partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
+      degenMode: orderParams.degenMode,
+    });
+  };
+
+  return { submitTWAPDeltaOrderV2 };
+};
+
+// ── Handler bundle ───────────────────────────────────────────────────────────
+
+export type DeltaV2OrderHandlers<TxResponse> = SubmitDeltaOrderV2Funcs &
+  SubmitExternalDeltaOrderV2Funcs &
+  SubmitTWAPDeltaOrderV2Funcs &
+  BuildDeltaOrderV2Functions &
+  BuildExternalDeltaOrderV2Functions &
+  BuildTWAPDeltaOrderV2Functions &
+  PostDeltaOrderV2Functions &
+  PostExternalDeltaOrderV2Functions &
+  PostTWAPDeltaOrderV2Functions &
+  SignDeltaOrderV2Functions &
+  PreSignDeltaOrderFunctions<TxResponse> &
+  PreSignExternalDeltaOrderFunctions<TxResponse> &
+  PreSignTWAPDeltaOrderFunctions<TxResponse> &
+  GetDeltaPriceV2Functions &
+  GetDeltaOrdersV2Functions &
+  GetBridgeRoutesFunctions &
+  IsTokenSupportedInDeltaV2Functions &
+  GetAgentsListV2Functions &
+  GetDeltaContractFunctions &
+  GetPartnerFeeFunctions &
+  ApproveTokenForDeltaFunctions<TxResponse> &
+  DeltaTokenModuleFunctions<TxResponse> &
+  CancelDeltaOrderV2Functions;
+
+/** @description Construct an SDK bundle exposing every Delta v2 method (queries, build/sign/post, on-chain helpers). */
+export const constructAllDeltaV2OrdersHandlers = <TxResponse>(
+  options: ConstructProviderFetchInput<
+    TxResponse,
+    'signTypedDataCall' | 'transactCall'
+  >
+): DeltaV2OrderHandlers<TxResponse> => {
+  return {
+    ...constructSubmitDeltaOrderV2(options),
+    ...constructSubmitExternalDeltaOrderV2(options),
+    ...constructSubmitTWAPDeltaOrderV2(options),
+    ...constructBuildDeltaOrderV2(options),
+    ...constructBuildExternalDeltaOrderV2(options),
+    ...constructBuildTWAPDeltaOrderV2(options),
+    ...constructPostDeltaOrderV2(options),
+    ...constructPostExternalDeltaOrderV2(options),
+    ...constructPostTWAPDeltaOrderV2(options),
+    ...constructSignDeltaOrderV2(options),
+    ...constructPreSignDeltaOrder(options),
+    ...constructPreSignExternalDeltaOrder(options),
+    ...constructPreSignTWAPDeltaOrder(options),
+    ...constructGetDeltaPriceV2(options),
+    ...constructGetDeltaOrdersV2(options),
+    ...constructGetBridgeRoutes(options),
+    ...constructIsTokenSupportedInDeltaV2(options),
+    ...constructGetAgentsListV2(options),
+    ...constructGetDeltaContract(options),
+    ...constructGetPartnerFee(options),
+    ...constructApproveTokenForDelta(options),
+    ...constructDeltaTokenModule(options),
+    ...constructCancelDeltaOrderV2(options),
+  };
+};

package/src/methods/deltaV2/isTokenSupportedInDeltaV2.ts

@@ -0,0 +1,52 @@
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type {
+  Address,
+  ConstructFetchInput,
+  RequestParameters,
+} from '../../types';
+
+type TokenSupportedResponse = { supported: boolean };
+type IsTokenSupportedQuery = {
+  token: Address;
+  chainId: number;
+};
+
+type IsTokenSupportedInDeltaV2 = (
+  token: Address,
+  requestParams?: RequestParameters
+) => Promise<boolean>;
+
+export type IsTokenSupportedInDeltaV2Functions = {
+  isTokenSupportedInDeltaV2: IsTokenSupportedInDeltaV2;
+};
+
+export const constructIsTokenSupportedInDeltaV2 = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): IsTokenSupportedInDeltaV2Functions => {
+  const baseUrl = `${apiURL}/delta/v2/prices/is-token-supported` as const;
+
+  const isTokenSupportedInDeltaV2: IsTokenSupportedInDeltaV2 = async (
+    token,
+    requestParams
+  ) => {
+    const search = constructSearchString<IsTokenSupportedQuery>({
+      token,
+      chainId,
+    });
+
+    const fetchURL = `${baseUrl}/${search}` as const;
+
+    const data = await fetcher<TokenSupportedResponse>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data.supported;
+  };
+
+  return { isTokenSupportedInDeltaV2 };
+};

package/src/methods/deltaV2/postDeltaOrderV2.ts

@@ -0,0 +1,65 @@
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type {
+  DeltaAuction,
+  DeltaOrderType,
+  OnChainOrderMap,
+} from '../delta/helpers/types';
+
+export type DeltaOrderToPostV2<T extends keyof OnChainOrderMap = 'Order'> = {
+  /** @description Partner string */
+  partner?: string;
+  /** @description Referrer address */
+  referrerAddress?: string;
+  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;
+  /** @description Designates the Order as being able to be partially filled, as opposed to fill-or-kill */
+  partiallyFillable?: boolean;
+  /** @description Type of the order. MARKET or LIMIT. Default is MARKET */
+  type?: DeltaOrderType;
+  includeAgents?: string[];
+  excludeAgents?: string[];
+};
+
+export type PostDeltaOrderV2Params = Omit<DeltaOrderToPostV2, 'chainId'> & {
+  degenMode?: boolean;
+};
+
+type PostDeltaOrderV2 = (
+  postData: PostDeltaOrderV2Params,
+  requestParams?: RequestParameters
+) => Promise<DeltaAuction<'Order'>>;
+
+export type PostDeltaOrderV2Functions = {
+  postDeltaOrderV2: PostDeltaOrderV2;
+};
+
+export const constructPostDeltaOrderV2 = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): PostDeltaOrderV2Functions => {
+  const postOrderUrl = `${apiURL}/delta/v2/orders` as const;
+
+  const postDeltaOrderV2: PostDeltaOrderV2 = (_postData, requestParams) => {
+    const { degenMode, ...postData } = _postData;
+    const deltaOrderToPost: DeltaOrderToPostV2 = { ...postData, chainId };
+
+    const search = constructSearchString<{ degenMode?: boolean }>({
+      degenMode,
+    });
+    const fetchURL = `${postOrderUrl}${search}` as const;
+
+    return fetcher<DeltaAuction<'Order'>>({
+      url: fetchURL,
+      method: 'POST',
+      data: deltaOrderToPost,
+      requestParams,
+    });
+  };
+
+  return { postDeltaOrderV2 };
+};

package/src/methods/deltaV2/postExternalDeltaOrderV2.ts

@@ -0,0 +1,45 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { DeltaAuction } from '../delta/helpers/types';
+import type { DeltaOrderToPostV2 } from './postDeltaOrderV2';
+
+export type PostExternalDeltaOrderV2Params = Omit<
+  DeltaOrderToPostV2<'ExternalOrder'>,
+  'chainId'
+>;
+
+type PostExternalDeltaOrderV2 = (
+  postData: PostExternalDeltaOrderV2Params,
+  requestParams?: RequestParameters
+) => Promise<DeltaAuction<'ExternalOrder'>>;
+
+export type PostExternalDeltaOrderV2Functions = {
+  postExternalDeltaOrderV2: PostExternalDeltaOrderV2;
+};
+
+export const constructPostExternalDeltaOrderV2 = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): PostExternalDeltaOrderV2Functions => {
+  const postOrderUrl = `${apiURL}/delta/v2/orders` as const;
+
+  const postExternalDeltaOrderV2: PostExternalDeltaOrderV2 = (
+    postData,
+    requestParams
+  ) => {
+    const deltaOrderToPost: DeltaOrderToPostV2<'ExternalOrder'> = {
+      ...postData,
+      chainId,
+    };
+
+    return fetcher<DeltaAuction<'ExternalOrder'>>({
+      url: postOrderUrl,
+      method: 'POST',
+      data: deltaOrderToPost,
+      requestParams,
+    });
+  };
+
+  return { postExternalDeltaOrderV2 };
+};

package/src/methods/deltaV2/postTWAPDeltaOrderV2.ts

@@ -0,0 +1,63 @@
+import type { Prettify } from 'ts-essentials';
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type {
+  DeltaAuction,
+  TWAPOnChainOrderType,
+} from '../delta/helpers/types';
+import type { DeltaOrderToPostV2 } from './postDeltaOrderV2';
+
+export type PostTWAPDeltaOrderV2Params = Prettify<
+  Omit<
+    DeltaOrderToPostV2<'TWAPOrder'> | DeltaOrderToPostV2<'TWAPBuyOrder'>,
+    'chainId'
+  > & {
+    /** @description Must be "TWAPOrder" or "TWAPBuyOrder" */
+    onChainOrderType: TWAPOnChainOrderType;
+    degenMode?: boolean;
+  }
+>;
+
+type PostTWAPDeltaOrderV2 = (
+  postData: PostTWAPDeltaOrderV2Params,
+  requestParams?: RequestParameters
+) => Promise<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>;
+
+export type PostTWAPDeltaOrderV2Functions = {
+  postTWAPDeltaOrderV2: PostTWAPDeltaOrderV2;
+};
+
+export const constructPostTWAPDeltaOrderV2 = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): PostTWAPDeltaOrderV2Functions => {
+  const postOrderUrl = `${apiURL}/delta/v2/orders` as const;
+
+  const postTWAPDeltaOrderV2: PostTWAPDeltaOrderV2 = (
+    _postData,
+    requestParams
+  ) => {
+    const { degenMode, ...postData } = _postData;
+    const deltaOrderToPost: DeltaOrderToPostV2<'TWAPOrder' | 'TWAPBuyOrder'> = {
+      ...postData,
+      chainId,
+    };
+
+    const search = constructSearchString<{ degenMode?: boolean }>({
+      degenMode,
+    });
+
+    const fetchURL = `${postOrderUrl}${search}` as const;
+
+    return fetcher<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>({
+      url: fetchURL,
+      method: 'POST',
+      data: deltaOrderToPost,
+      requestParams,
+    });
+  };
+
+  return { postTWAPDeltaOrderV2 };
+};