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

package/src/index.ts

@@ -147,6 +147,7 @@ import type {
   BridgeStatus,
   Bridge,
   ExternalDeltaOrder,
+  ProductiveDeltaOrder,
   TWAPDeltaOrder,
   TWAPBuyDeltaOrder,
   TWAPOnChainOrderType,
@@ -158,9 +159,11 @@ import type {
   DeltaAmountsBuySlippage,
   DeltaAmountsExplicit,
   DeltaAuctionDelta,
+  DeltaAuctionFillable,
   DeltaAuctionTWAP,
   DeltaAuctionTWAPBuy,
   DeltaAuctionExternal,
+  DeltaAuctionProductive,
   DeltaOrderUnion,
   DeltaAuctionUnion,
   UnifiedDeltaOrderData,
@@ -289,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 {
@@ -386,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,
@@ -481,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,
@@ -566,9 +489,11 @@ export type {
   DeltaAuctionOrder,
   DeltaAuction,
   DeltaAuctionDelta,
+  DeltaAuctionFillable,
   DeltaAuctionTWAP,
   DeltaAuctionTWAPBuy,
   DeltaAuctionExternal,
+  DeltaAuctionProductive,
   DeltaOrderUnion,
   DeltaAuctionUnion,
   UnifiedDeltaOrderData,
@@ -604,6 +529,8 @@ export type {
   DepositNativeAndPreSignDeltaOrderParams,
   // External Delta types
   ExternalDeltaOrder,
+  // Productive Delta types
+  ProductiveDeltaOrder,
   TWAPDeltaOrder,
   TWAPBuyDeltaOrder,
   TWAPOnChainOrderType,
@@ -630,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

@@ -11,6 +11,7 @@ import {
   ExternalDeltaOrder,
   OnChainOrderType,
   OrderKind,
+  ProductiveDeltaOrder,
   SwapSideUnion,
   TWAPBuyDeltaOrder,
   TWAPDeltaOrder,
@@ -65,6 +66,16 @@ function isDeltaOrder(order: DeltaOrderUnion): order is DeltaAuctionOrder {
   );
 }
 
+/**
+ * @description Checks whether an order is a Productive Delta order
+ * (strategy-routed order without an explicit OrderKind).
+ */
+function isProductiveOrder(
+  order: DeltaOrderUnion
+): order is ProductiveDeltaOrder {
+  return 'strategy' in order && typeof order.strategy === 'string';
+}
+
 /**
  * @description Checks whether an auction is a TWAP auction.
  */
@@ -110,17 +121,28 @@ function isExternalAuction<T extends OnChainOrderType>(auction: {
   return auction.onChainOrderType === 'ExternalOrder';
 }
 
+/**
+ * @description Checks whether an auction is a Productive auction.
+ */
+function isProductiveAuction<T extends OnChainOrderType>(auction: {
+  onChainOrderType: T;
+}): auction is { onChainOrderType: 'ProductiveOrder' & T } {
+  return auction.onChainOrderType === 'ProductiveOrder';
+}
+
 const checks = {
   isTWAPOrder,
   isTWAPSellOrder,
   isTWAPBuyOrder,
   isExternalOrder,
   isDeltaOrder,
+  isProductiveOrder,
   isTWAPAuction,
   isTWAPSellAuction,
   isTWAPBuyAuction,
   isDeltaAuction,
   isExternalAuction,
+  isProductiveAuction,
   isOrderCrosschain,
   isExecutedAuction,
   isPartiallyExecutedAuction,
@@ -271,6 +293,10 @@ function getAuctionSwapSide(auction: DeltaAuction): SwapSideUnion {
     // TWAP orders have onChainOrderType instead of kind
     return getSwapSideFromTwapOrderType(auction.onChainOrderType);
   }
+  if (isProductiveAuction(auction)) {
+    // ProductiveOrders don't carry an explicit OrderKind; treated as SELL.
+    return 'SELL';
+  }
   return getSwapSideFromDeltaOrder(auction.order);
 }
 
@@ -332,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

@@ -123,6 +123,41 @@ export type ExternalDeltaOrder = {
   data: string;
 };
 
+export type ProductiveDeltaOrder = {
+  /** @description The address of the order owner */
+  owner: string;
+  /** @description The address of the order beneficiary */
+  beneficiary: string;
+  /** @description The address of the src token */
+  srcToken: string;
+  /** @description The address of the dest token */
+  destToken: string;
+  /** @description The amount of src token to swap */
+  srcAmount: string;
+  /** @description The minimum amount of dest token to receive */
+  destAmount: string;
+  /** @description The expected amount of token to receive */
+  expectedAmount: string;
+  /** @description The deadline for the order */
+  deadline: number;
+  /** @description The nonce of the order */
+  nonce: string;
+  /** @description Metadata for the order, hex string */
+  metadata: string;
+  /** @description Encoded partner address, fee bps, and flags for the order. partnerAndFee = (partner << 96) | (partnerTakesSurplus << 8) | fee in bps (max fee is 2%) */
+  partnerAndFee: string;
+  /** @description Optional permit signature for the src token */
+  permit: string;
+  /** @description The strategy address. */
+  strategy: string;
+  /** @description The number of shares to execute for this order. */
+  shares: string;
+  /** @description Whether the order uses shares or raw amounts. */
+  useShares: boolean;
+  /** @description The bridge input */
+  bridge: Bridge;
+};
+
 type TWAPDeltaOrderBase = {
   /** @description The address of the order owner */
   owner: string;
@@ -213,9 +248,11 @@ export type DeltaAuctionTransaction = {
 
 export type OnChainOrderMap = {
   Order: DeltaAuctionOrder;
+  FillableOrder: DeltaAuctionOrder;
   ExternalOrder: ExternalDeltaOrder;
   TWAPOrder: TWAPDeltaOrder;
   TWAPBuyOrder: TWAPBuyDeltaOrder;
+  ProductiveOrder: ProductiveDeltaOrder;
 };
 
 type BaseBridgeAuctionFields = Pick<
@@ -225,9 +262,11 @@ type BaseBridgeAuctionFields = Pick<
 
 type BridgeAuctionFiledsMap = {
   Order: BaseBridgeAuctionFields;
+  FillableOrder: BaseBridgeAuctionFields;
   ExternalOrder: BaseBridgeAuctionFields;
   TWAPOrder: Record<keyof BaseBridgeAuctionFields, null>;
   TWAPBuyOrder: Record<keyof BaseBridgeAuctionFields, null>;
+  ProductiveOrder: BaseBridgeAuctionFields;
 };
 
 type DeltaAuctionBase = {
@@ -255,33 +294,39 @@ 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'>;
+export type DeltaAuctionProductive = DeltaAuction<'ProductiveOrder'>;
 
 export type DeltaAuctionUnion =
   | DeltaAuctionDelta
+  | DeltaAuctionFillable
   | DeltaAuctionExternal
   | DeltaAuctionTWAP
-  | DeltaAuctionTWAPBuy;
+  | DeltaAuctionTWAPBuy
+  | DeltaAuctionProductive;
 
 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.
@@ -300,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 };
 };