@velora-dex/sdk 9.5.4-dev.1 → 9.5.4-dev.2

package/src/methods/deltaV2/index.ts

@@ -1,5 +1,5 @@
 import type { ConstructProviderFetchInput } from '../../types';
-import type { DeltaAuction, OnChainOrderMap } from '../delta/helpers/types';
+import type { DeltaAuction } from './types';
 
 // reused v1 modules
 import {
@@ -33,115 +33,131 @@ import {
 
 // new v2 modules
 import {
-  BuildDeltaOrderV2Functions,
-  BuildDeltaOrderV2Params,
-  BuiltDeltaOrderV2,
-  constructBuildDeltaOrderV2,
-} from './buildDeltaOrderV2';
+  BuildDeltaOrderFunctions,
+  BuildDeltaOrderParams,
+  BuiltDeltaOrder,
+  constructBuildDeltaOrder,
+} from './buildDeltaOrder';
 import {
-  BuildExternalDeltaOrderV2Functions,
-  BuildExternalDeltaOrderV2Params,
-  constructBuildExternalDeltaOrderV2,
-} from './buildExternalDeltaOrderV2';
+  BuildExternalDeltaOrderFunctions,
+  BuildExternalDeltaOrderParams,
+  constructBuildExternalDeltaOrder,
+} from './buildExternalDeltaOrder';
 import {
-  BuildTWAPDeltaOrderV2Functions,
-  BuildTWAPDeltaOrderV2Params,
-  constructBuildTWAPDeltaOrderV2,
-} from './buildTWAPDeltaOrderV2';
+  BuildTWAPDeltaOrderFunctions,
+  BuildTWAPDeltaOrderParams,
+  constructBuildTWAPDeltaOrder,
+} from './buildTWAPDeltaOrder';
 import {
-  constructPostDeltaOrderV2,
-  DeltaOrderToPostV2,
-  PostDeltaOrderV2Functions,
-} from './postDeltaOrderV2';
+  constructPostDeltaOrder,
+  DeltaOrderToPost,
+  PostDeltaOrderFunctions,
+} from './postDeltaOrder';
 import {
-  constructPostExternalDeltaOrderV2,
-  PostExternalDeltaOrderV2Functions,
-} from './postExternalDeltaOrderV2';
+  constructPostExternalDeltaOrder,
+  PostExternalDeltaOrderFunctions,
+} from './postExternalDeltaOrder';
 import {
-  constructPostTWAPDeltaOrderV2,
-  PostTWAPDeltaOrderV2Functions,
-} from './postTWAPDeltaOrderV2';
+  constructPostTWAPDeltaOrder,
+  PostTWAPDeltaOrderFunctions,
+} from './postTWAPDeltaOrder';
 import {
-  constructGetDeltaPriceV2,
-  GetDeltaPriceV2Functions,
-} from './getDeltaPriceV2';
+  constructGetDeltaPrice,
+  GetDeltaPriceFunctions,
+} from './getDeltaPrice';
 import {
-  constructGetDeltaOrdersV2,
-  GetDeltaOrdersV2Functions,
-} from './getDeltaOrdersV2';
+  constructGetDeltaOrders,
+  GetDeltaOrdersFunctions,
+} from './getDeltaOrders';
 import {
   constructGetBridgeRoutes,
   GetBridgeRoutesFunctions,
 } from './getBridgeRoutes';
 import {
-  constructIsTokenSupportedInDeltaV2,
-  IsTokenSupportedInDeltaV2Functions,
-} from './isTokenSupportedInDeltaV2';
+  constructIsTokenSupportedInDelta,
+  IsTokenSupportedInDeltaFunctions,
+} from './isTokenSupportedInDelta';
 import {
-  CancelDeltaOrderV2Functions,
-  constructCancelDeltaOrderV2,
-} from './cancelDeltaOrderV2';
+  CancelDeltaOrderFunctions,
+  constructCancelDeltaOrder,
+} from './cancelDeltaOrder';
 import {
-  constructGetAgentsListV2,
-  GetAgentsListV2Functions,
-} from './getAgentsListV2';
+  constructGetAgentsList,
+  GetAgentsListFunctions,
+} from './getAgentsList';
+
+// Re-export public surface so `import * as DeltaV2` carries everything.
+export * from './types';
+export * from './buildDeltaOrder';
+export * from './buildExternalDeltaOrder';
+export * from './buildTWAPDeltaOrder';
+export * from './postDeltaOrder';
+export * from './postExternalDeltaOrder';
+export * from './postTWAPDeltaOrder';
+export * from './getDeltaPrice';
+export * from './getDeltaOrders';
+export * from './getBridgeRoutes';
+export * from './isTokenSupportedInDelta';
+export * from './cancelDeltaOrder';
+export * from './getAgentsList';
+export { OrderHelpers } from './helpers/orders';
 
 // ── Sign v2 ─────────────────────────────────────────────────────────────────
 
-type SignDeltaOrderV2 = (builtOrder: BuiltDeltaOrderV2) => Promise<string>;
+type SignDeltaOrder = (builtOrder: BuiltDeltaOrder) => Promise<string>;
 
-export type SignDeltaOrderV2Functions = {
-  /** @description Sign a BuiltDeltaOrderV2 (any order type) using EIP-712 typed data. */
-  signDeltaOrderV2: SignDeltaOrderV2;
+export type SignDeltaOrderFunctions = {
+  /** @description Sign a BuiltDeltaOrder (any order type) using EIP-712 typed data. */
+  signDeltaOrder: SignDeltaOrder;
 };
 
-export const constructSignDeltaOrderV2 = (
+export const constructSignDeltaOrder = (
   options: Pick<
     ConstructProviderFetchInput<any, 'signTypedDataCall'>,
     'contractCaller'
   >
-): SignDeltaOrderV2Functions => {
-  const signDeltaOrderV2: SignDeltaOrderV2 = async (builtOrder) => {
+): SignDeltaOrderFunctions => {
+  const signDeltaOrder: SignDeltaOrder = async (builtOrder) => {
     return options.contractCaller.signTypedDataCall({
       types: builtOrder.toSign.types,
       domain: builtOrder.toSign.domain,
       data: builtOrder.toSign.value,
     });
   };
-  return { signDeltaOrderV2 };
+  return { signDeltaOrder };
 };
 
 // ── Submit orchestrators ─────────────────────────────────────────────────────
 
-export type SubmitDeltaOrderV2Params = BuildDeltaOrderV2Params & {
+export type SubmitDeltaOrderParams = BuildDeltaOrderParams & {
   /** @description Referrer address */
   referrerAddress?: string;
   degenMode?: boolean;
-} & Pick<DeltaOrderToPostV2, 'type' | 'includeAgents' | 'excludeAgents'>;
+} & Pick<DeltaOrderToPost, 'type' | 'includeAgents' | 'excludeAgents'>;
 
-type SubmitDeltaOrderV2 = (
-  orderParams: SubmitDeltaOrderV2Params
+type SubmitDeltaOrder = (
+  orderParams: SubmitDeltaOrderParams
 ) => Promise<DeltaAuction<'Order'>>;
 
-export type SubmitDeltaOrderV2Funcs = {
-  submitDeltaOrderV2: SubmitDeltaOrderV2;
+export type SubmitDeltaOrderFuncs = {
+  submitDeltaOrder: SubmitDeltaOrder;
 };
 
-export const constructSubmitDeltaOrderV2 = (
+export const constructSubmitDeltaOrder = (
   options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
-): SubmitDeltaOrderV2Funcs => {
-  const { buildDeltaOrderV2 } = constructBuildDeltaOrderV2(options);
-  const { signDeltaOrderV2 } = constructSignDeltaOrderV2(options);
-  const { postDeltaOrderV2 } = constructPostDeltaOrderV2(options);
+): SubmitDeltaOrderFuncs => {
+  const { buildDeltaOrder } = constructBuildDeltaOrder(options);
+  const { signDeltaOrder } = constructSignDeltaOrder(options);
+  const { postDeltaOrder } = constructPostDeltaOrder(options);
 
-  const submitDeltaOrderV2: SubmitDeltaOrderV2 = async (orderParams) => {
-    const orderData = await buildDeltaOrderV2(orderParams);
-    const signature = await signDeltaOrderV2(orderData);
+  const submitDeltaOrder: SubmitDeltaOrder = async (orderParams) => {
+    const orderData = await buildDeltaOrder(orderParams);
+    const signature = await signDeltaOrder(orderData);
 
-    return postDeltaOrderV2({
+    return postDeltaOrder({
       signature,
       partner: orderParams.partner,
-      order: orderData.toSign.value as OnChainOrderMap['Order'],
+      order: orderData.toSign.value,
       partiallyFillable: orderParams.partiallyFillable,
       referrerAddress: orderParams.referrerAddress,
       type: orderParams.type,
@@ -151,41 +167,38 @@ export const constructSubmitDeltaOrderV2 = (
     });
   };
 
-  return { submitDeltaOrderV2 };
+  return { submitDeltaOrder };
 };
 
-export type SubmitExternalDeltaOrderV2Params =
-  BuildExternalDeltaOrderV2Params & {
-    referrerAddress?: string;
-  } & Pick<DeltaOrderToPostV2, 'type' | 'includeAgents' | 'excludeAgents'>;
+export type SubmitExternalDeltaOrderParams = BuildExternalDeltaOrderParams & {
+  referrerAddress?: string;
+} & Pick<DeltaOrderToPost, 'type' | 'includeAgents' | 'excludeAgents'>;
 
-type SubmitExternalDeltaOrderV2 = (
-  orderParams: SubmitExternalDeltaOrderV2Params
+type SubmitExternalDeltaOrder = (
+  orderParams: SubmitExternalDeltaOrderParams
 ) => Promise<DeltaAuction<'ExternalOrder'>>;
 
-export type SubmitExternalDeltaOrderV2Funcs = {
-  submitExternalDeltaOrderV2: SubmitExternalDeltaOrderV2;
+export type SubmitExternalDeltaOrderFuncs = {
+  submitExternalDeltaOrder: SubmitExternalDeltaOrder;
 };
 
-export const constructSubmitExternalDeltaOrderV2 = (
+export const constructSubmitExternalDeltaOrder = (
   options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
-): SubmitExternalDeltaOrderV2Funcs => {
-  const { buildExternalDeltaOrderV2 } =
-    constructBuildExternalDeltaOrderV2(options);
-  const { signDeltaOrderV2 } = constructSignDeltaOrderV2(options);
-  const { postExternalDeltaOrderV2 } =
-    constructPostExternalDeltaOrderV2(options);
-
-  const submitExternalDeltaOrderV2: SubmitExternalDeltaOrderV2 = async (
+): SubmitExternalDeltaOrderFuncs => {
+  const { buildExternalDeltaOrder } = constructBuildExternalDeltaOrder(options);
+  const { signDeltaOrder } = constructSignDeltaOrder(options);
+  const { postExternalDeltaOrder } = constructPostExternalDeltaOrder(options);
+
+  const submitExternalDeltaOrder: SubmitExternalDeltaOrder = async (
     orderParams
   ) => {
-    const orderData = await buildExternalDeltaOrderV2(orderParams);
-    const signature = await signDeltaOrderV2(orderData);
+    const orderData = await buildExternalDeltaOrder(orderParams);
+    const signature = await signDeltaOrder(orderData);
 
-    return postExternalDeltaOrderV2({
+    return postExternalDeltaOrder({
       signature,
       partner: orderParams.partner,
-      order: orderData.toSign.value as OnChainOrderMap['ExternalOrder'],
+      order: orderData.toSign.value,
       partiallyFillable: orderParams.partiallyFillable,
       referrerAddress: orderParams.referrerAddress,
       type: orderParams.type,
@@ -194,41 +207,37 @@ export const constructSubmitExternalDeltaOrderV2 = (
     });
   };
 
-  return { submitExternalDeltaOrderV2 };
+  return { submitExternalDeltaOrder };
 };
 
-export type SubmitTWAPDeltaOrderV2Params = BuildTWAPDeltaOrderV2Params & {
+export type SubmitTWAPDeltaOrderParams = BuildTWAPDeltaOrderParams & {
   referrerAddress?: string;
   degenMode?: boolean;
-} & Pick<DeltaOrderToPostV2, 'type' | 'includeAgents' | 'excludeAgents'>;
+} & Pick<DeltaOrderToPost, 'type' | 'includeAgents' | 'excludeAgents'>;
 
-type SubmitTWAPDeltaOrderV2 = (
-  orderParams: SubmitTWAPDeltaOrderV2Params
+type SubmitTWAPDeltaOrder = (
+  orderParams: SubmitTWAPDeltaOrderParams
 ) => Promise<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>;
 
-export type SubmitTWAPDeltaOrderV2Funcs = {
-  submitTWAPDeltaOrderV2: SubmitTWAPDeltaOrderV2;
+export type SubmitTWAPDeltaOrderFuncs = {
+  submitTWAPDeltaOrder: SubmitTWAPDeltaOrder;
 };
 
-export const constructSubmitTWAPDeltaOrderV2 = (
+export const constructSubmitTWAPDeltaOrder = (
   options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
-): SubmitTWAPDeltaOrderV2Funcs => {
-  const { buildTWAPDeltaOrderV2 } = constructBuildTWAPDeltaOrderV2(options);
-  const { signDeltaOrderV2 } = constructSignDeltaOrderV2(options);
-  const { postTWAPDeltaOrderV2 } = constructPostTWAPDeltaOrderV2(options);
+): SubmitTWAPDeltaOrderFuncs => {
+  const { buildTWAPDeltaOrder } = constructBuildTWAPDeltaOrder(options);
+  const { signDeltaOrder } = constructSignDeltaOrder(options);
+  const { postTWAPDeltaOrder } = constructPostTWAPDeltaOrder(options);
 
-  const submitTWAPDeltaOrderV2: SubmitTWAPDeltaOrderV2 = async (
-    orderParams
-  ) => {
-    const orderData = await buildTWAPDeltaOrderV2(orderParams);
-    const signature = await signDeltaOrderV2(orderData);
+  const submitTWAPDeltaOrder: SubmitTWAPDeltaOrder = async (orderParams) => {
+    const orderData = await buildTWAPDeltaOrder(orderParams);
+    const signature = await signDeltaOrder(orderData);
 
-    return postTWAPDeltaOrderV2({
+    return postTWAPDeltaOrder({
       signature,
       partner: orderParams.partner,
-      order: orderData.toSign.value as
-        | OnChainOrderMap['TWAPOrder']
-        | OnChainOrderMap['TWAPBuyOrder'],
+      order: orderData.toSign.value,
       onChainOrderType: orderParams.onChainOrderType,
       partiallyFillable: orderParams.partiallyFillable,
       referrerAddress: orderParams.referrerAddress,
@@ -239,65 +248,65 @@ export const constructSubmitTWAPDeltaOrderV2 = (
     });
   };
 
-  return { submitTWAPDeltaOrderV2 };
+  return { submitTWAPDeltaOrder };
 };
 
 // ── Handler bundle ───────────────────────────────────────────────────────────
 
-export type DeltaV2OrderHandlers<TxResponse> = SubmitDeltaOrderV2Funcs &
-  SubmitExternalDeltaOrderV2Funcs &
-  SubmitTWAPDeltaOrderV2Funcs &
-  BuildDeltaOrderV2Functions &
-  BuildExternalDeltaOrderV2Functions &
-  BuildTWAPDeltaOrderV2Functions &
-  PostDeltaOrderV2Functions &
-  PostExternalDeltaOrderV2Functions &
-  PostTWAPDeltaOrderV2Functions &
-  SignDeltaOrderV2Functions &
+export type DeltaOrderHandlers<TxResponse> = SubmitDeltaOrderFuncs &
+  SubmitExternalDeltaOrderFuncs &
+  SubmitTWAPDeltaOrderFuncs &
+  BuildDeltaOrderFunctions &
+  BuildExternalDeltaOrderFunctions &
+  BuildTWAPDeltaOrderFunctions &
+  PostDeltaOrderFunctions &
+  PostExternalDeltaOrderFunctions &
+  PostTWAPDeltaOrderFunctions &
+  SignDeltaOrderFunctions &
   PreSignDeltaOrderFunctions<TxResponse> &
   PreSignExternalDeltaOrderFunctions<TxResponse> &
   PreSignTWAPDeltaOrderFunctions<TxResponse> &
-  GetDeltaPriceV2Functions &
-  GetDeltaOrdersV2Functions &
+  GetDeltaPriceFunctions &
+  GetDeltaOrdersFunctions &
   GetBridgeRoutesFunctions &
-  IsTokenSupportedInDeltaV2Functions &
-  GetAgentsListV2Functions &
+  IsTokenSupportedInDeltaFunctions &
+  GetAgentsListFunctions &
   GetDeltaContractFunctions &
   GetPartnerFeeFunctions &
   ApproveTokenForDeltaFunctions<TxResponse> &
   DeltaTokenModuleFunctions<TxResponse> &
-  CancelDeltaOrderV2Functions;
+  CancelDeltaOrderFunctions;
 
 /** @description Construct an SDK bundle exposing every Delta v2 method (queries, build/sign/post, on-chain helpers). */
-export const constructAllDeltaV2OrdersHandlers = <TxResponse>(
+export const constructAllDeltaOrdersHandlers = <TxResponse>(
   options: ConstructProviderFetchInput<
     TxResponse,
     'signTypedDataCall' | 'transactCall'
   >
-): DeltaV2OrderHandlers<TxResponse> => {
+): DeltaOrderHandlers<TxResponse> => {
   return {
-    ...constructSubmitDeltaOrderV2(options),
-    ...constructSubmitExternalDeltaOrderV2(options),
-    ...constructSubmitTWAPDeltaOrderV2(options),
-    ...constructBuildDeltaOrderV2(options),
-    ...constructBuildExternalDeltaOrderV2(options),
-    ...constructBuildTWAPDeltaOrderV2(options),
-    ...constructPostDeltaOrderV2(options),
-    ...constructPostExternalDeltaOrderV2(options),
-    ...constructPostTWAPDeltaOrderV2(options),
-    ...constructSignDeltaOrderV2(options),
+    ...constructSubmitDeltaOrder(options),
+    ...constructSubmitExternalDeltaOrder(options),
+    ...constructSubmitTWAPDeltaOrder(options),
+    ...constructBuildDeltaOrder(options),
+    ...constructBuildExternalDeltaOrder(options),
+    ...constructBuildTWAPDeltaOrder(options),
+    ...constructPostDeltaOrder(options),
+    ...constructPostExternalDeltaOrder(options),
+    ...constructPostTWAPDeltaOrder(options),
+    ...constructSignDeltaOrder(options),
     ...constructPreSignDeltaOrder(options),
     ...constructPreSignExternalDeltaOrder(options),
     ...constructPreSignTWAPDeltaOrder(options),
-    ...constructGetDeltaPriceV2(options),
-    ...constructGetDeltaOrdersV2(options),
+    ...constructGetDeltaPrice(options),
+    ...constructGetDeltaOrders(options),
     ...constructGetBridgeRoutes(options),
-    ...constructIsTokenSupportedInDeltaV2(options),
-    ...constructGetAgentsListV2(options),
+    ...constructIsTokenSupportedInDelta(options),
+    ...constructGetAgentsList(options),
     ...constructGetDeltaContract(options),
     ...constructGetPartnerFee(options),
     ...constructApproveTokenForDelta(options),
     ...constructDeltaTokenModule(options),
-    ...constructCancelDeltaOrderV2(options),
+    ...constructCancelDeltaOrder(options),
   };
 };

package/src/methods/deltaV2/{isTokenSupportedInDeltaV2.ts → isTokenSupportedInDelta.ts}

@@ -12,23 +12,23 @@ type IsTokenSupportedQuery = {
   chainId: number;
 };
 
-type IsTokenSupportedInDeltaV2 = (
+type IsTokenSupportedInDelta = (
   token: Address,
   requestParams?: RequestParameters
 ) => Promise<boolean>;
 
-export type IsTokenSupportedInDeltaV2Functions = {
-  isTokenSupportedInDeltaV2: IsTokenSupportedInDeltaV2;
+export type IsTokenSupportedInDeltaFunctions = {
+  isTokenSupportedInDelta: IsTokenSupportedInDelta;
 };
 
-export const constructIsTokenSupportedInDeltaV2 = ({
+export const constructIsTokenSupportedInDelta = ({
   apiURL = API_URL,
   chainId,
   fetcher,
-}: ConstructFetchInput): IsTokenSupportedInDeltaV2Functions => {
+}: ConstructFetchInput): IsTokenSupportedInDeltaFunctions => {
   const baseUrl = `${apiURL}/delta/v2/prices/is-token-supported` as const;
 
-  const isTokenSupportedInDeltaV2: IsTokenSupportedInDeltaV2 = async (
+  const isTokenSupportedInDelta: IsTokenSupportedInDelta = async (
     token,
     requestParams
   ) => {
@@ -48,5 +48,5 @@ export const constructIsTokenSupportedInDeltaV2 = ({
     return data.supported;
   };
 
-  return { isTokenSupportedInDeltaV2 };
+  return { isTokenSupportedInDelta };
 };

package/src/methods/deltaV2/{postDeltaOrderV2.ts → postDeltaOrder.ts}

@@ -1,13 +1,10 @@
 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';
+import type { DeltaOrderType, OnChainOrderMap } from '../delta/helpers/types';
+import type { DeltaAuction } from './types';
 
-export type DeltaOrderToPostV2<T extends keyof OnChainOrderMap = 'Order'> = {
+export type DeltaOrderToPost<T extends keyof OnChainOrderMap = 'Order'> = {
   /** @description Partner string */
   partner?: string;
   /** @description Referrer address */
@@ -24,29 +21,29 @@ export type DeltaOrderToPostV2<T extends keyof OnChainOrderMap = 'Order'> = {
   excludeAgents?: string[];
 };
 
-export type PostDeltaOrderV2Params = Omit<DeltaOrderToPostV2, 'chainId'> & {
+export type PostDeltaOrderParams = Omit<DeltaOrderToPost, 'chainId'> & {
   degenMode?: boolean;
 };
 
-type PostDeltaOrderV2 = (
-  postData: PostDeltaOrderV2Params,
+type PostDeltaOrder = (
+  postData: PostDeltaOrderParams,
   requestParams?: RequestParameters
 ) => Promise<DeltaAuction<'Order'>>;
 
-export type PostDeltaOrderV2Functions = {
-  postDeltaOrderV2: PostDeltaOrderV2;
+export type PostDeltaOrderFunctions = {
+  postDeltaOrder: PostDeltaOrder;
 };
 
-export const constructPostDeltaOrderV2 = ({
+export const constructPostDeltaOrder = ({
   apiURL = API_URL,
   chainId,
   fetcher,
-}: ConstructFetchInput): PostDeltaOrderV2Functions => {
+}: ConstructFetchInput): PostDeltaOrderFunctions => {
   const postOrderUrl = `${apiURL}/delta/v2/orders` as const;
 
-  const postDeltaOrderV2: PostDeltaOrderV2 = (_postData, requestParams) => {
+  const postDeltaOrder: PostDeltaOrder = (_postData, requestParams) => {
     const { degenMode, ...postData } = _postData;
-    const deltaOrderToPost: DeltaOrderToPostV2 = { ...postData, chainId };
+    const deltaOrderToPost: DeltaOrderToPost = { ...postData, chainId };
 
     const search = constructSearchString<{ degenMode?: boolean }>({
       degenMode,
@@ -61,5 +58,5 @@ export const constructPostDeltaOrderV2 = ({
     });
   };
 
-  return { postDeltaOrderV2 };
+  return { postDeltaOrder };
 };

package/src/methods/deltaV2/postExternalDeltaOrder.ts

@@ -0,0 +1,45 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { DeltaOrderToPost } from './postDeltaOrder';
+import type { DeltaAuction } from './types';
+
+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/v2/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/deltaV2/{postTWAPDeltaOrderV2.ts → postTWAPDeltaOrder.ts}

@@ -2,15 +2,13 @@ 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';
+import type { TWAPOnChainOrderType } from '../delta/helpers/types';
+import type { DeltaOrderToPost } from './postDeltaOrder';
+import type { DeltaAuction } from './types';
 
-export type PostTWAPDeltaOrderV2Params = Prettify<
+export type PostTWAPDeltaOrderParams = Prettify<
   Omit<
-    DeltaOrderToPostV2<'TWAPOrder'> | DeltaOrderToPostV2<'TWAPBuyOrder'>,
+    DeltaOrderToPost<'TWAPOrder'> | DeltaOrderToPost<'TWAPBuyOrder'>,
     'chainId'
   > & {
     /** @description Must be "TWAPOrder" or "TWAPBuyOrder" */
@@ -19,28 +17,25 @@ export type PostTWAPDeltaOrderV2Params = Prettify<
   }
 >;
 
-type PostTWAPDeltaOrderV2 = (
-  postData: PostTWAPDeltaOrderV2Params,
+type PostTWAPDeltaOrder = (
+  postData: PostTWAPDeltaOrderParams,
   requestParams?: RequestParameters
 ) => Promise<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>;
 
-export type PostTWAPDeltaOrderV2Functions = {
-  postTWAPDeltaOrderV2: PostTWAPDeltaOrderV2;
+export type PostTWAPDeltaOrderFunctions = {
+  postTWAPDeltaOrder: PostTWAPDeltaOrder;
 };
 
-export const constructPostTWAPDeltaOrderV2 = ({
+export const constructPostTWAPDeltaOrder = ({
   apiURL = API_URL,
   chainId,
   fetcher,
-}: ConstructFetchInput): PostTWAPDeltaOrderV2Functions => {
+}: ConstructFetchInput): PostTWAPDeltaOrderFunctions => {
   const postOrderUrl = `${apiURL}/delta/v2/orders` as const;
 
-  const postTWAPDeltaOrderV2: PostTWAPDeltaOrderV2 = (
-    _postData,
-    requestParams
-  ) => {
+  const postTWAPDeltaOrder: PostTWAPDeltaOrder = (_postData, requestParams) => {
     const { degenMode, ...postData } = _postData;
-    const deltaOrderToPost: DeltaOrderToPostV2<'TWAPOrder' | 'TWAPBuyOrder'> = {
+    const deltaOrderToPost: DeltaOrderToPost<'TWAPOrder' | 'TWAPBuyOrder'> = {
       ...postData,
       chainId,
     };
@@ -59,5 +54,5 @@ export const constructPostTWAPDeltaOrderV2 = ({
     });
   };
 
-  return { postTWAPDeltaOrderV2 };
+  return { postTWAPDeltaOrder };
 };