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

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 };
+};

package/src/methods/deltaV2/cancelDeltaOrderV2.ts

@@ -0,0 +1,103 @@
+import { API_URL } from '../../constants';
+import type {
+  ConstructProviderFetchInput,
+  RequestParameters,
+} from '../../types';
+import { constructGetDeltaContract } from '../delta/getDeltaContract';
+import {
+  buildCancelDeltaOrderSignableData,
+  type CancelDeltaOrderData,
+} from '../delta/helpers/buildCancelDeltaOrderData';
+
+type SuccessResponse = { success: true };
+
+type CancelDeltaOrderRequestParams = {
+  orderIds: string[];
+  signature: string;
+};
+
+export type SignCancelDeltaOrderRequestV2 = (
+  params: CancelDeltaOrderData,
+  requestParams?: RequestParameters
+) => Promise<string>;
+
+export type PostCancelDeltaOrderRequestV2 = (
+  params: CancelDeltaOrderRequestParams,
+  requestParams?: RequestParameters
+) => Promise<SuccessResponse>;
+
+export type CancelDeltaOrderV2 = (
+  params: CancelDeltaOrderData,
+  requestParams?: RequestParameters
+) => Promise<SuccessResponse>;
+
+export type CancelDeltaOrderV2Functions = {
+  signCancelDeltaOrderRequestV2: SignCancelDeltaOrderRequestV2;
+  postCancelDeltaOrderRequestV2: PostCancelDeltaOrderRequestV2;
+  /** @description Cancel one or more Delta orders via the v2 endpoint */
+  cancelDeltaOrdersV2: CancelDeltaOrderV2;
+};
+
+export const constructCancelDeltaOrderV2 = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller' | 'fetcher' | 'apiURL' | 'chainId'
+  >
+): CancelDeltaOrderV2Functions => {
+  const apiURL = options.apiURL ?? API_URL;
+
+  const { getDeltaContract } = constructGetDeltaContract(options);
+
+  const signCancelDeltaOrderRequestV2: SignCancelDeltaOrderRequestV2 = async (
+    params,
+    requestParams
+  ) => {
+    const ParaswapDelta = await getDeltaContract(requestParams);
+    if (!ParaswapDelta) {
+      throw new Error(`Delta is not available on chain ${options.chainId}`);
+    }
+
+    const typedData = buildCancelDeltaOrderSignableData({
+      orderInput: params,
+      paraswapDeltaAddress: ParaswapDelta,
+      chainId: options.chainId,
+    });
+
+    return options.contractCaller.signTypedDataCall(typedData);
+  };
+
+  const postCancelDeltaOrderRequestV2: PostCancelDeltaOrderRequestV2 = async (
+    params,
+    requestParams
+  ) => {
+    const cancelUrl = `${apiURL}/delta/v2/orders/cancel` as const;
+
+    return options.fetcher<SuccessResponse>({
+      url: cancelUrl,
+      method: 'POST',
+      data: params,
+      requestParams,
+    });
+  };
+
+  const cancelDeltaOrdersV2: CancelDeltaOrderV2 = async (
+    { orderIds },
+    requestParams
+  ) => {
+    const signature = await signCancelDeltaOrderRequestV2(
+      { orderIds },
+      requestParams
+    );
+
+    return postCancelDeltaOrderRequestV2(
+      { orderIds, signature },
+      requestParams
+    );
+  };
+
+  return {
+    signCancelDeltaOrderRequestV2,
+    postCancelDeltaOrderRequestV2,
+    cancelDeltaOrdersV2,
+  };
+};

package/src/methods/deltaV2/getAgentsListV2.ts

@@ -0,0 +1,34 @@
+import { API_URL } from '../../constants';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+
+export type AgentList = string[];
+
+type AgentsListV2Response = AgentList;
+
+type GetAgentsListV2 = (
+  requestParams?: RequestParameters
+) => Promise<AgentList>;
+
+export type GetAgentsListV2Functions = {
+  /** @description List agents available on the current chain. */
+  getAgentsListV2: GetAgentsListV2;
+};
+
+export const constructGetAgentsListV2 = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): GetAgentsListV2Functions => {
+  const baseUrl = `${apiURL}/delta/v2/agents/list/${chainId}` as const;
+
+  const getAgentsListV2: GetAgentsListV2 = async (requestParams) => {
+    const data = await fetcher<AgentsListV2Response>({
+      url: baseUrl,
+      method: 'GET',
+      requestParams,
+    });
+    return data;
+  };
+
+  return { getAgentsListV2 };
+};

package/src/methods/deltaV2/getBridgeRoutes.ts

@@ -0,0 +1,82 @@
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { BridgeProtocolResponse } from '../delta/getBridgeInfo';
+import type { BridgeRoute } from './types';
+
+type GetBridgeRoutesParams = {
+  /** @description Include tokens that can be swapped on destChain after bridge. Default is true. */
+  allowBridgeAndSwap?: boolean;
+  /** @description Include only the specified bridges. Default is all bridges. */
+  bridges?: string[];
+};
+
+type BridgeRoutesQuery = {
+  allowBridgeAndSwap?: boolean;
+  bridges?: string;
+};
+
+type BridgeRoutesResponse = { routes: BridgeRoute[] };
+
+type GetBridgeRoutes = (
+  params?: GetBridgeRoutesParams,
+  requestParams?: RequestParameters
+) => Promise<BridgeRoute[]>;
+
+type GetBridgeProtocolsV2 = (
+  requestParams?: RequestParameters
+) => Promise<BridgeProtocolResponse[]>;
+
+type BridgeProtocolsV2Response = {
+  bridgeProtocols: BridgeProtocolResponse[];
+};
+
+export type GetBridgeRoutesFunctions = {
+  /** @description Fetch supported bridge routes as a flat array (v2 replacement for bridge-info). */
+  getBridgeRoutes: GetBridgeRoutes;
+  /** @description Fetch supported bridge protocols (falls through to v1 controller on the v2 path). */
+  getBridgeProtocolsV2: GetBridgeProtocolsV2;
+};
+
+export const constructGetBridgeRoutes = ({
+  apiURL = API_URL,
+  fetcher,
+}: ConstructFetchInput): GetBridgeRoutesFunctions => {
+  const deltaPricesUrl = `${apiURL}/delta/v2/prices` as const;
+
+  const getBridgeRoutes: GetBridgeRoutes = async (
+    params = {},
+    requestParams
+  ) => {
+    const { allowBridgeAndSwap, bridges } = params;
+
+    const search = constructSearchString<BridgeRoutesQuery>({
+      allowBridgeAndSwap,
+      bridges: bridges?.join(','),
+    });
+
+    const fetchURL = `${deltaPricesUrl}/bridge-routes${search}` as const;
+
+    const data = await fetcher<BridgeRoutesResponse>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data.routes;
+  };
+
+  const getBridgeProtocolsV2: GetBridgeProtocolsV2 = async (requestParams) => {
+    const fetchURL = `${deltaPricesUrl}/bridge-protocols` as const;
+
+    const data = await fetcher<BridgeProtocolsV2Response>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data.bridgeProtocols;
+  };
+
+  return { getBridgeRoutes, getBridgeProtocolsV2 };
+};

package/src/methods/deltaV2/getDeltaOrdersV2.ts

@@ -0,0 +1,119 @@
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type {
+  Address,
+  ConstructFetchInput,
+  PaginatedResponse,
+  RequestParameters,
+} from '../../types';
+import type {
+  DeltaOrderType,
+  OnChainOrderType,
+} from '../delta/helpers/types';
+import type { DeltaOrderStatusV2, DeltaOrderV2Response } from './types';
+
+type GetDeltaOrderByIdV2 = (
+  orderId: string,
+  requestParams?: RequestParameters
+) => Promise<DeltaOrderV2Response>;
+
+type GetDeltaOrderByHashV2 = (
+  orderHash: string,
+  requestParams?: RequestParameters
+) => Promise<DeltaOrderV2Response>;
+
+type OrdersV2Filter = {
+  /** @description `order.owner` to fetch Delta Orders for. */
+  userAddress: Address;
+  /** @description Pagination option. Default 1. */
+  page?: number;
+  /** @description Pagination option. Default 100, max 1000. */
+  limit?: number;
+  /** @description Filter by chainId. Omitted = orders across all chains. */
+  chainId?: number[];
+  /** @description Filter by integrator-facing status. */
+  status?: DeltaOrderStatusV2[];
+  /** @description Filter by order type. MARKET or LIMIT. */
+  type?: DeltaOrderType;
+  /** @description Filter by on-chain order type. */
+  onChainOrderType?: OnChainOrderType;
+};
+
+type OrderFiltersV2Query = Omit<OrdersV2Filter, 'chainId' | 'status'> & {
+  chainId?: string;
+  status?: string;
+};
+
+type GetDeltaOrdersV2 = (
+  options: OrdersV2Filter,
+  requestParams?: RequestParameters
+) => Promise<PaginatedResponse<DeltaOrderV2Response>>;
+
+export type GetDeltaOrdersV2Functions = {
+  /** @description Fetch a single order by its UUID. */
+  getDeltaOrderByIdV2: GetDeltaOrderByIdV2;
+  /** @description Fetch a single order by its EIP-712 order hash. */
+  getDeltaOrderByHashV2: GetDeltaOrderByHashV2;
+  /** @description List Delta orders with the v2 pagination envelope. */
+  getDeltaOrdersV2: GetDeltaOrdersV2;
+};
+
+export const constructGetDeltaOrdersV2 = ({
+  apiURL = API_URL,
+  fetcher,
+}: ConstructFetchInput): GetDeltaOrdersV2Functions => {
+  const baseUrl = `${apiURL}/delta/v2/orders` as const;
+
+  const getDeltaOrderByIdV2: GetDeltaOrderByIdV2 = async (
+    orderId,
+    requestParams
+  ) => {
+    const fetchURL = `${baseUrl}/${orderId}` as const;
+    return fetcher<DeltaOrderV2Response>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+  };
+
+  const getDeltaOrderByHashV2: GetDeltaOrderByHashV2 = async (
+    orderHash,
+    requestParams
+  ) => {
+    const fetchURL = `${baseUrl}/hash/${orderHash}` as const;
+    return fetcher<DeltaOrderV2Response>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+  };
+
+  const getDeltaOrdersV2: GetDeltaOrdersV2 = async (options, requestParams) => {
+    const chainIdString = options.chainId?.join(',');
+    const statusString = options.status?.join(',');
+
+    const search = constructSearchString<OrderFiltersV2Query>({
+      userAddress: options.userAddress,
+      page: options.page,
+      limit: options.limit,
+      type: options.type,
+      onChainOrderType: options.onChainOrderType,
+      chainId: chainIdString,
+      status: statusString,
+    });
+
+    const fetchURL = `${baseUrl}${search}` as const;
+
+    return fetcher<PaginatedResponse<DeltaOrderV2Response>>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+  };
+
+  return {
+    getDeltaOrderByIdV2,
+    getDeltaOrderByHashV2,
+    getDeltaOrdersV2,
+  };
+};