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

package/src/index.ts

@@ -159,6 +159,7 @@ import type {
   DeltaAmountsBuySlippage,
   DeltaAmountsExplicit,
   DeltaAuctionDelta,
+  DeltaAuctionFillable,
   DeltaAuctionTWAP,
   DeltaAuctionTWAPBuy,
   DeltaAuctionExternal,
@@ -291,84 +292,6 @@ import {
   SignableCancelDeltaOrderData,
 } from './methods/delta/helpers/buildCancelDeltaOrderData';
 
-// Delta v2 modules
-import {
-  BuildDeltaOrderV2Functions,
-  BuildDeltaOrderV2Params,
-  constructBuildDeltaOrderV2,
-} from './methods/deltaV2/buildDeltaOrderV2';
-import {
-  BuildExternalDeltaOrderV2Functions,
-  BuildExternalDeltaOrderV2Params,
-  constructBuildExternalDeltaOrderV2,
-} from './methods/deltaV2/buildExternalDeltaOrderV2';
-import {
-  BuildTWAPDeltaOrderV2Functions,
-  BuildTWAPDeltaOrderV2Params,
-  BuildTWAPSellDeltaOrderV2Params,
-  BuildTWAPBuyDeltaOrderV2Params,
-  constructBuildTWAPDeltaOrderV2,
-} from './methods/deltaV2/buildTWAPDeltaOrderV2';
-import {
-  constructPostDeltaOrderV2,
-  DeltaOrderToPostV2,
-  PostDeltaOrderV2Functions,
-  PostDeltaOrderV2Params,
-} from './methods/deltaV2/postDeltaOrderV2';
-import {
-  constructPostExternalDeltaOrderV2,
-  PostExternalDeltaOrderV2Functions,
-  PostExternalDeltaOrderV2Params,
-} from './methods/deltaV2/postExternalDeltaOrderV2';
-import {
-  constructPostTWAPDeltaOrderV2,
-  PostTWAPDeltaOrderV2Functions,
-  PostTWAPDeltaOrderV2Params,
-} from './methods/deltaV2/postTWAPDeltaOrderV2';
-import {
-  constructGetDeltaPriceV2,
-  DeltaPriceV2Params,
-  GetDeltaPriceV2Functions,
-} from './methods/deltaV2/getDeltaPriceV2';
-import {
-  constructGetDeltaOrdersV2,
-  GetDeltaOrdersV2Functions,
-} from './methods/deltaV2/getDeltaOrdersV2';
-import {
-  constructGetBridgeRoutes,
-  GetBridgeRoutesFunctions,
-} from './methods/deltaV2/getBridgeRoutes';
-import {
-  constructIsTokenSupportedInDeltaV2,
-  IsTokenSupportedInDeltaV2Functions,
-} from './methods/deltaV2/isTokenSupportedInDeltaV2';
-import {
-  CancelDeltaOrderV2Functions,
-  constructCancelDeltaOrderV2,
-} from './methods/deltaV2/cancelDeltaOrderV2';
-import {
-  AgentList,
-  constructGetAgentsListV2,
-  GetAgentsListV2Functions,
-} from './methods/deltaV2/getAgentsListV2';
-import type {
-  DeltaOrderStatusV2,
-  BuiltDeltaOrderV2,
-  DeltaPriceToken,
-  DeltaTokenAmount,
-  BridgeTag,
-  DeltaRouteBridge,
-  DeltaRouteBridgeContractParams,
-  DeltaRouteStep,
-  DeltaRoute,
-  DeltaPriceV2,
-  BridgeRoute,
-  DeltaOnChainOrderTypeReported,
-  DeltaTokenSide,
-  DeltaTransactionV2,
-  DeltaOrderV2Response,
-} from './methods/deltaV2/types';
-
 export { constructSwapSDK, SwapSDKMethods } from './methods/swap';
 
 export {
@@ -388,18 +311,31 @@ export {
   SubmitTWAPDeltaOrderParams,
 } from './methods/delta';
 
-export {
-  constructAllDeltaV2OrdersHandlers,
-  constructSubmitDeltaOrderV2,
-  constructSubmitExternalDeltaOrderV2,
-  constructSubmitTWAPDeltaOrderV2,
-  constructSignDeltaOrderV2,
-  DeltaV2OrderHandlers,
-  SubmitDeltaOrderV2Params,
-  SubmitExternalDeltaOrderV2Params,
-  SubmitTWAPDeltaOrderV2Params,
-  SignDeltaOrderV2Functions,
-} from './methods/deltaV2';
+// Delta v2 is exposed as a single namespace so it can ship alongside v1 without
+// colliding at the top level. v2 source uses unsuffixed names internally
+// (constructBuildDeltaOrder, BuiltDeltaOrder, DeltaPrice, ...); consumers reach
+// them via `DeltaV2.constructBuildDeltaOrder` etc.
+//
+// Migration plan when deprecating v1 (breaking change):
+//   1. Replace the bare `export { ... } from './methods/delta'` block above with
+//      `export * from './methods/deltaV2'` (or named re-exports of v2 symbols).
+//      Top-level `constructPostDeltaOrder` now resolves to v2.
+//   2. Move v1 behind its own namespace for backcompat:
+//      `export * as DeltaV1 from './methods/delta'`.
+//   3. Keep `export * as DeltaV2 from './methods/deltaV2'` as a redundant alias
+//      so code written against the v2 namespace today keeps compiling.
+//   4. Mirror this on the bundled SDKs in sdk/full.ts and sdk/simple.ts:
+//      `sdk.delta.*` flips to v2 (use `constructAllDeltaOrdersHandlers` from
+//      './methods/deltaV2'), and add `sdk.deltaV1.*` for backcompat.
+//
+// Migration plan when dropping v1 entirely:
+//   - Delete the `DeltaV1` namespace export and `sdk.deltaV1` field.
+//   - Delete `src/methods/delta/`.
+//   - Delete the `DeltaV2` re-export alias (consumers can move to bare names).
+//   - The `methods/deltaV2/` folder can be renamed to `methods/delta/` (and the
+//     `/delta/v2/` URL prefix in the leaf modules updated if the server has by
+//     then collapsed v1 and v2 endpoints).
+export * as DeltaV2 from './methods/deltaV2';
 
 export type {
   TransactionParams,
@@ -483,21 +419,6 @@ export {
   constructPreSignTWAPDeltaOrder,
   // Quote methods
   constructGetQuote,
-  // Delta v2 runtime values (const-object enums etc.)
-  DeltaOrderStatusV2,
-  // Delta V2 methods
-  constructBuildDeltaOrderV2,
-  constructBuildExternalDeltaOrderV2,
-  constructBuildTWAPDeltaOrderV2,
-  constructPostDeltaOrderV2,
-  constructPostExternalDeltaOrderV2,
-  constructPostTWAPDeltaOrderV2,
-  constructGetDeltaPriceV2,
-  constructGetDeltaOrdersV2,
-  constructGetBridgeRoutes,
-  constructIsTokenSupportedInDeltaV2,
-  constructCancelDeltaOrderV2,
-  constructGetAgentsListV2,
   // different helpers
   constructGetPartnerFee,
   constructGetBridgeInfo,
@@ -568,6 +489,7 @@ export type {
   DeltaAuctionOrder,
   DeltaAuction,
   DeltaAuctionDelta,
+  DeltaAuctionFillable,
   DeltaAuctionTWAP,
   DeltaAuctionTWAPBuy,
   DeltaAuctionExternal,
@@ -635,44 +557,6 @@ export type {
   PostTWAPDeltaOrderFunctions,
   PostTWAPDeltaOrderParams,
   PreSignTWAPDeltaOrderFunctions,
-  // Delta v2 types
-  BuiltDeltaOrderV2,
-  DeltaPriceToken,
-  DeltaTokenAmount,
-  BridgeTag,
-  DeltaRouteBridge,
-  DeltaRouteBridgeContractParams,
-  DeltaRouteStep,
-  DeltaRoute,
-  DeltaPriceV2,
-  BridgeRoute,
-  DeltaOnChainOrderTypeReported,
-  DeltaTokenSide,
-  DeltaTransactionV2,
-  DeltaOrderV2Response,
-  DeltaPriceV2Params,
-  GetDeltaPriceV2Functions,
-  GetDeltaOrdersV2Functions,
-  GetBridgeRoutesFunctions,
-  IsTokenSupportedInDeltaV2Functions,
-  BuildDeltaOrderV2Params,
-  BuildDeltaOrderV2Functions,
-  BuildExternalDeltaOrderV2Params,
-  BuildExternalDeltaOrderV2Functions,
-  BuildTWAPDeltaOrderV2Params,
-  BuildTWAPSellDeltaOrderV2Params,
-  BuildTWAPBuyDeltaOrderV2Params,
-  BuildTWAPDeltaOrderV2Functions,
-  DeltaOrderToPostV2,
-  PostDeltaOrderV2Params,
-  PostDeltaOrderV2Functions,
-  PostExternalDeltaOrderV2Params,
-  PostExternalDeltaOrderV2Functions,
-  PostTWAPDeltaOrderV2Params,
-  PostTWAPDeltaOrderV2Functions,
-  CancelDeltaOrderV2Functions,
-  AgentList as AgentInfo,
-  GetAgentsListV2Functions,
   // types for Quote methods
   GetQuoteFunctions,
   QuoteParams,

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

@@ -358,7 +358,11 @@ function getTransactionAmounts(transactions: DeltaAuctionTransaction[]) {
         srcAmount: acc.srcAmount + BigInt(spentAmount),
         destAmount:
           acc.destAmount +
-          BigInt(bridgeMetadata ? bridgeMetadata.outputAmount : receivedAmount),
+          BigInt(
+            bridgeMetadata?.outputAmount
+              ? bridgeMetadata.outputAmount
+              : receivedAmount
+          ),
       };
     },
     {

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

@@ -248,6 +248,7 @@ export type DeltaAuctionTransaction = {
 
 export type OnChainOrderMap = {
   Order: DeltaAuctionOrder;
+  FillableOrder: DeltaAuctionOrder;
   ExternalOrder: ExternalDeltaOrder;
   TWAPOrder: TWAPDeltaOrder;
   TWAPBuyOrder: TWAPBuyDeltaOrder;
@@ -261,6 +262,7 @@ type BaseBridgeAuctionFields = Pick<
 
 type BridgeAuctionFiledsMap = {
   Order: BaseBridgeAuctionFields;
+  FillableOrder: BaseBridgeAuctionFields;
   ExternalOrder: BaseBridgeAuctionFields;
   TWAPOrder: Record<keyof BaseBridgeAuctionFields, null>;
   TWAPBuyOrder: Record<keyof BaseBridgeAuctionFields, null>;
@@ -292,18 +294,18 @@ type DeltaAuctionBase = {
   type: DeltaOrderType;
 };
 
-export type DeltaAuction<
-  T extends keyof OnChainOrderMap = keyof OnChainOrderMap,
-> = T extends T
-  ? Prettify<
-      DeltaAuctionBase & {
-        onChainOrderType: T;
-        order: OnChainOrderMap[T];
-      } & BridgeAuctionFiledsMap[T]
-    >
-  : never;
+export type DeltaAuction<T extends OnChainOrderType = OnChainOrderType> =
+  T extends T
+    ? Prettify<
+        DeltaAuctionBase & {
+          onChainOrderType: T;
+          order: OnChainOrderMap[T];
+        } & BridgeAuctionFiledsMap[T]
+      >
+    : never;
 
 export type DeltaAuctionDelta = DeltaAuction<'Order'>;
+export type DeltaAuctionFillable = DeltaAuction<'FillableOrder'>;
 export type DeltaAuctionExternal = DeltaAuction<'ExternalOrder'>;
 export type DeltaAuctionTWAP = DeltaAuction<'TWAPOrder'>;
 export type DeltaAuctionTWAPBuy = DeltaAuction<'TWAPBuyOrder'>;
@@ -311,6 +313,7 @@ export type DeltaAuctionProductive = DeltaAuction<'ProductiveOrder'>;
 
 export type DeltaAuctionUnion =
   | DeltaAuctionDelta
+  | DeltaAuctionFillable
   | DeltaAuctionExternal
   | DeltaAuctionTWAP
   | DeltaAuctionTWAPBuy
@@ -319,8 +322,11 @@ export type DeltaAuctionUnion =
 export type DeltaOrderUnion = OnChainOrderMap[keyof OnChainOrderMap];
 
 export type BridgeMetadata = {
-  /** @description Actual amount received on the destination chain. */
-  outputAmount: string;
+  /** @description Field is present after bridge is executed.
+   * The actual amount received from the bridge, which may differ
+   * from the expectedOutputAmount due to bridge slippage or other factors.
+   * */
+  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.
@@ -339,12 +345,7 @@ export type BridgeMetadata = {
 //                                                             refunded is basically failed
 export type BridgeStatus = 'pending' | 'filled' | 'expired' | 'refunded';
 
-export type OnChainOrderType =
-  | 'Order'
-  | 'ExternalOrder'
-  | 'TWAPOrder'
-  | 'TWAPBuyOrder'
-  | 'ProductiveOrder';
+export type OnChainOrderType = keyof OnChainOrderMap;
 
 export type TWAPOnChainOrderType = 'TWAPOrder' | 'TWAPBuyOrder';
 

package/src/methods/deltaV2/{buildDeltaOrderV2.ts → buildDeltaOrder.ts}

@@ -1,9 +1,10 @@
 import { API_URL } from '../../constants';
 import type { ConstructFetchInput, RequestParameters } from '../../types';
-import type { BuiltDeltaOrderV2, DeltaRoute } from './types';
-export type { BuiltDeltaOrderV2 } from './types';
+import type { DeltaAuctionOrder } from '../delta/helpers/types';
+import type { BuiltDeltaOrder, DeltaRoute } from './types';
+export type { BuiltDeltaOrder } from './types';
 
-export type BuildDeltaOrderV2Params = {
+export type BuildDeltaOrderParams = {
   /** @description The address of the order owner */
   owner: string;
   /** @description The address of the order beneficiary. Defaults to owner. */
@@ -29,7 +30,7 @@ export type BuildDeltaOrderV2Params = {
   /** @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] */
+  /** @description DeltaRoute from getDeltaPrice — either price.route or any price.alternatives[i] */
   route: DeltaRoute;
   /** @description Order side. SELL or BUY. */
   side: 'SELL' | 'BUY';
@@ -39,28 +40,27 @@ export type BuildDeltaOrderV2Params = {
   limitAmount?: string;
 };
 
-type BuildDeltaOrderV2 = (
-  buildOrderParams: BuildDeltaOrderV2Params,
+type BuildDeltaOrder = (
+  buildOrderParams: BuildDeltaOrderParams,
   requestParams?: RequestParameters
-) => Promise<BuiltDeltaOrderV2>;
+) => Promise<BuiltDeltaOrder<DeltaAuctionOrder>>;
 
-export type BuildDeltaOrderV2Functions = {
+export type BuildDeltaOrderFunctions = {
   /** @description Build a Delta v2 order from a DeltaRoute via the server endpoint, ready to sign and post. */
-  buildDeltaOrderV2: BuildDeltaOrderV2;
+  buildDeltaOrder: BuildDeltaOrder;
 };
 
-export const constructBuildDeltaOrderV2 = (
+export const constructBuildDeltaOrder = (
   options: ConstructFetchInput
-): BuildDeltaOrderV2Functions => {
-  const { apiURL = API_URL, chainId, fetcher } = options;
+): BuildDeltaOrderFunctions => {
+  const { apiURL = API_URL, fetcher } = options;
   const buildUrl = `${apiURL}/delta/v2/orders/build` as const;
 
-  const buildDeltaOrderV2: BuildDeltaOrderV2 = async (params, requestParams) =>
-    fetcher<BuiltDeltaOrderV2>({
+  const buildDeltaOrder: BuildDeltaOrder = async (params, requestParams) =>
+    fetcher<BuiltDeltaOrder<DeltaAuctionOrder>>({
       url: buildUrl,
       method: 'POST',
       data: {
-        chainId,
         side: params.side,
         route: params.route,
         owner: params.owner,
@@ -82,5 +82,5 @@ export const constructBuildDeltaOrderV2 = (
       requestParams,
     });
 
-  return { buildDeltaOrderV2 };
+  return { buildDeltaOrder };
 };

package/src/methods/deltaV2/{buildExternalDeltaOrderV2.ts → buildExternalDeltaOrder.ts}

@@ -1,9 +1,10 @@
 import { API_URL } from '../../constants';
 import type { ConstructFetchInput, RequestParameters } from '../../types';
-import type { BuiltDeltaOrderV2, DeltaRoute } from './types';
-export type { BuiltDeltaOrderV2 } from './types';
+import type { ExternalDeltaOrder } from '../delta/helpers/types';
+import type { BuiltDeltaOrder, DeltaRoute } from './types';
+export type { BuiltDeltaOrder } from './types';
 
-export type BuildExternalDeltaOrderV2Params = {
+export type BuildExternalDeltaOrderParams = {
   /** @description The address of the order owner */
   owner: string;
   /** @description The address of the external handler contract */
@@ -33,7 +34,7 @@ export type BuildExternalDeltaOrderV2Params = {
   /** @description Designates the Order as partially fillable. Default false. */
   partiallyFillable?: boolean;
 
-  /** @description DeltaRoute from getDeltaPriceV2 */
+  /** @description DeltaRoute from getDeltaPrice */
   route: DeltaRoute;
   /** @description Order side. SELL or BUY. */
   side: 'SELL' | 'BUY';
@@ -43,31 +44,30 @@ export type BuildExternalDeltaOrderV2Params = {
   limitAmount?: string;
 };
 
-type BuildExternalDeltaOrderV2 = (
-  buildOrderParams: BuildExternalDeltaOrderV2Params,
+type BuildExternalDeltaOrder = (
+  buildOrderParams: BuildExternalDeltaOrderParams,
   requestParams?: RequestParameters
-) => Promise<BuiltDeltaOrderV2>;
+) => Promise<BuiltDeltaOrder<ExternalDeltaOrder>>;
 
-export type BuildExternalDeltaOrderV2Functions = {
+export type BuildExternalDeltaOrderFunctions = {
   /** @description Build a Delta v2 External Order from a DeltaRoute via the server endpoint, ready to sign and post. */
-  buildExternalDeltaOrderV2: BuildExternalDeltaOrderV2;
+  buildExternalDeltaOrder: BuildExternalDeltaOrder;
 };
 
-export const constructBuildExternalDeltaOrderV2 = (
+export const constructBuildExternalDeltaOrder = (
   options: ConstructFetchInput
-): BuildExternalDeltaOrderV2Functions => {
-  const { apiURL = API_URL, chainId, fetcher } = options;
+): BuildExternalDeltaOrderFunctions => {
+  const { apiURL = API_URL, fetcher } = options;
   const buildUrl = `${apiURL}/delta/v2/orders/build` as const;
 
-  const buildExternalDeltaOrderV2: BuildExternalDeltaOrderV2 = async (
+  const buildExternalDeltaOrder: BuildExternalDeltaOrder = async (
     params,
     requestParams
   ) =>
-    fetcher<BuiltDeltaOrderV2>({
+    fetcher<BuiltDeltaOrder<ExternalDeltaOrder>>({
       url: buildUrl,
       method: 'POST',
       data: {
-        chainId,
         side: params.side,
         route: params.route,
         owner: params.owner,
@@ -91,5 +91,5 @@ export const constructBuildExternalDeltaOrderV2 = (
       requestParams,
     });
 
-  return { buildExternalDeltaOrderV2 };
+  return { buildExternalDeltaOrder };
 };

package/src/methods/deltaV2/{buildTWAPDeltaOrderV2.ts → buildTWAPDeltaOrder.ts}

@@ -1,9 +1,10 @@
 import { API_URL } from '../../constants';
 import type { ConstructFetchInput, RequestParameters } from '../../types';
-import type { BuiltDeltaOrderV2, DeltaRoute } from './types';
-export type { BuiltDeltaOrderV2 } from './types';
+import type { TWAPBuyDeltaOrder, TWAPDeltaOrder } from '../delta/helpers/types';
+import type { BuiltDeltaOrder, DeltaRoute } from './types';
+export type { BuiltDeltaOrder } from './types';
 
-type BuildTWAPDeltaOrderV2Base = {
+type BuildTWAPDeltaOrderBase = {
   /** @description The address of the order owner */
   owner: string;
   /** @description The address of the order beneficiary. Defaults to owner. */
@@ -22,7 +23,7 @@ type BuildTWAPDeltaOrderV2Base = {
   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 */
+  /** @description DeltaRoute from getDeltaPrice for a single slice */
   route: DeltaRoute;
   /** @description Partner fee in basis points (bps) */
   partnerFeeBps?: number;
@@ -40,13 +41,13 @@ type BuildTWAPDeltaOrderV2Base = {
   limitAmount?: string;
 };
 
-export type BuildTWAPSellDeltaOrderV2Params = BuildTWAPDeltaOrderV2Base & {
+export type BuildTWAPSellDeltaOrderParams = BuildTWAPDeltaOrderBase & {
   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 & {
+export type BuildTWAPBuyDeltaOrderParams = BuildTWAPDeltaOrderBase & {
   onChainOrderType: 'TWAPBuyOrder';
   /** @description Total destination token amount to buy across all slices. route.origin.output.amount must equal floor(totalDestAmount / numSlices). */
   totalDestAmount: string;
@@ -54,32 +55,31 @@ export type BuildTWAPBuyDeltaOrderV2Params = BuildTWAPDeltaOrderV2Base & {
   maxSrcAmount: string;
 };
 
-export type BuildTWAPDeltaOrderV2Params =
-  | BuildTWAPSellDeltaOrderV2Params
-  | BuildTWAPBuyDeltaOrderV2Params;
+export type BuildTWAPDeltaOrderParams =
+  | BuildTWAPSellDeltaOrderParams
+  | BuildTWAPBuyDeltaOrderParams;
 
-type BuildTWAPDeltaOrderV2 = (
-  buildOrderParams: BuildTWAPDeltaOrderV2Params,
+type BuildTWAPDeltaOrder = (
+  buildOrderParams: BuildTWAPDeltaOrderParams,
   requestParams?: RequestParameters
-) => Promise<BuiltDeltaOrderV2>;
+) => Promise<BuiltDeltaOrder<TWAPDeltaOrder | TWAPBuyDeltaOrder>>;
 
-export type BuildTWAPDeltaOrderV2Functions = {
+export type BuildTWAPDeltaOrderFunctions = {
   /** @description Build a Delta v2 TWAP Order (sell or buy) from a DeltaRoute via the server endpoint, ready to sign and post. */
-  buildTWAPDeltaOrderV2: BuildTWAPDeltaOrderV2;
+  buildTWAPDeltaOrder: BuildTWAPDeltaOrder;
 };
 
-export const constructBuildTWAPDeltaOrderV2 = (
+export const constructBuildTWAPDeltaOrder = (
   options: ConstructFetchInput
-): BuildTWAPDeltaOrderV2Functions => {
-  const { apiURL = API_URL, chainId, fetcher } = options;
+): BuildTWAPDeltaOrderFunctions => {
+  const { apiURL = API_URL, fetcher } = options;
   const buildUrl = `${apiURL}/delta/v2/orders/build` as const;
 
-  const buildTWAPDeltaOrderV2: BuildTWAPDeltaOrderV2 = async (
+  const buildTWAPDeltaOrder: BuildTWAPDeltaOrder = async (
     params,
     requestParams
   ) => {
     const commonBody = {
-      chainId,
       route: params.route,
       owner: params.owner,
       beneficiary: params.beneficiary,
@@ -100,7 +100,7 @@ export const constructBuildTWAPDeltaOrderV2 = (
     };
 
     if (params.onChainOrderType === 'TWAPOrder') {
-      return fetcher<BuiltDeltaOrderV2>({
+      return fetcher<BuiltDeltaOrder<TWAPDeltaOrder>>({
         url: buildUrl,
         method: 'POST',
         data: {
@@ -113,7 +113,7 @@ export const constructBuildTWAPDeltaOrderV2 = (
       });
     }
 
-    return fetcher<BuiltDeltaOrderV2>({
+    return fetcher<BuiltDeltaOrder<TWAPBuyDeltaOrder>>({
       url: buildUrl,
       method: 'POST',
       data: {
@@ -127,5 +127,5 @@ export const constructBuildTWAPDeltaOrderV2 = (
     });
   };
 
-  return { buildTWAPDeltaOrderV2 };
+  return { buildTWAPDeltaOrder };
 };

package/src/methods/deltaV2/{cancelDeltaOrderV2.ts → cancelDeltaOrder.ts}

@@ -16,39 +16,39 @@ type CancelDeltaOrderRequestParams = {
   signature: string;
 };
 
-export type SignCancelDeltaOrderRequestV2 = (
+export type SignCancelDeltaOrderRequest = (
   params: CancelDeltaOrderData,
   requestParams?: RequestParameters
 ) => Promise<string>;
 
-export type PostCancelDeltaOrderRequestV2 = (
+export type PostCancelDeltaOrderRequest = (
   params: CancelDeltaOrderRequestParams,
   requestParams?: RequestParameters
 ) => Promise<SuccessResponse>;
 
-export type CancelDeltaOrderV2 = (
+export type CancelDeltaOrder = (
   params: CancelDeltaOrderData,
   requestParams?: RequestParameters
 ) => Promise<SuccessResponse>;
 
-export type CancelDeltaOrderV2Functions = {
-  signCancelDeltaOrderRequestV2: SignCancelDeltaOrderRequestV2;
-  postCancelDeltaOrderRequestV2: PostCancelDeltaOrderRequestV2;
+export type CancelDeltaOrderFunctions = {
+  signCancelDeltaOrderRequest: SignCancelDeltaOrderRequest;
+  postCancelDeltaOrderRequest: PostCancelDeltaOrderRequest;
   /** @description Cancel one or more Delta orders via the v2 endpoint */
-  cancelDeltaOrdersV2: CancelDeltaOrderV2;
+  cancelDeltaOrders: CancelDeltaOrder;
 };
 
-export const constructCancelDeltaOrderV2 = (
+export const constructCancelDeltaOrder = (
   options: Pick<
     ConstructProviderFetchInput<any, 'signTypedDataCall'>,
     'contractCaller' | 'fetcher' | 'apiURL' | 'chainId'
   >
-): CancelDeltaOrderV2Functions => {
+): CancelDeltaOrderFunctions => {
   const apiURL = options.apiURL ?? API_URL;
 
   const { getDeltaContract } = constructGetDeltaContract(options);
 
-  const signCancelDeltaOrderRequestV2: SignCancelDeltaOrderRequestV2 = async (
+  const signCancelDeltaOrderRequest: SignCancelDeltaOrderRequest = async (
     params,
     requestParams
   ) => {
@@ -66,7 +66,7 @@ export const constructCancelDeltaOrderV2 = (
     return options.contractCaller.signTypedDataCall(typedData);
   };
 
-  const postCancelDeltaOrderRequestV2: PostCancelDeltaOrderRequestV2 = async (
+  const postCancelDeltaOrderRequest: PostCancelDeltaOrderRequest = async (
     params,
     requestParams
   ) => {
@@ -80,24 +80,21 @@ export const constructCancelDeltaOrderV2 = (
     });
   };
 
-  const cancelDeltaOrdersV2: CancelDeltaOrderV2 = async (
+  const cancelDeltaOrders: CancelDeltaOrder = async (
     { orderIds },
     requestParams
   ) => {
-    const signature = await signCancelDeltaOrderRequestV2(
+    const signature = await signCancelDeltaOrderRequest(
       { orderIds },
       requestParams
     );
 
-    return postCancelDeltaOrderRequestV2(
-      { orderIds, signature },
-      requestParams
-    );
+    return postCancelDeltaOrderRequest({ orderIds, signature }, requestParams);
   };
 
   return {
-    signCancelDeltaOrderRequestV2,
-    postCancelDeltaOrderRequestV2,
-    cancelDeltaOrdersV2,
+    signCancelDeltaOrderRequest,
+    postCancelDeltaOrderRequest,
+    cancelDeltaOrders,
   };
 };

package/src/methods/deltaV2/getAgentsList.ts

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