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

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

package/src/methods/deltaV2/types.ts

@@ -0,0 +1,189 @@
+import type { Address } from '../../types';
+import type { TypedDataField } from '../common/orders/buildOrderData';
+import type {
+  Bridge,
+  DeltaOrderType,
+  DeltaOrderUnion,
+  OnChainOrderType,
+} from '../delta/helpers/types';
+
+/** @description Response from POST /delta/v2/orders/build — EIP-712 typed data ready to sign. */
+export type BuiltDeltaOrderV2 = {
+  toSign: {
+    domain: {
+      name: string;
+      version: string;
+      chainId: number;
+      verifyingContract: string;
+    };
+    /** EIP-712 type definitions keyed by type name. */
+    types: Record<string, TypedDataField[]>;
+    /** The on-chain order struct value to sign. */
+    value: Record<string, unknown>;
+  };
+  /** EIP-712 order hash. */
+  orderHash: string;
+};
+
+/** @description Token identity used across v2 endpoints. */
+export type DeltaPriceToken = {
+  chainId: number;
+  address: Address;
+};
+
+/** @description A token amount with its USD value, used uniformly for inputs, outputs, and fees. */
+export type DeltaTokenAmount = {
+  token: DeltaPriceToken;
+  /** @description Amount in wei. */
+  amount: string;
+  /** @description USD value of the amount. */
+  amountUSD: string;
+};
+
+/** @description Bridge tag used to mark routes as recommended / fastest / best-return. */
+export type BridgeTag = 'recommended' | 'fastest' | 'best-return';
+
+/** @description Subset of the on-chain Bridge struct returned in v2 price responses.
+ *  (the full `route` object is passed to the server when building an order). */
+export type DeltaRouteBridgeContractParams = Omit<Bridge, 'destinationChainId'>;
+
+/** @description Bridge details on a route. Same-chain routes carry `null` for `route.bridge`. */
+export type DeltaRouteBridge = {
+  /** @description Bridge protocol identifier (e.g. "Across", "Relay", "Mayan"). */
+  protocol: string;
+  /** @description Estimated bridging time in milliseconds. */
+  estimatedTimeMs: number;
+  /** @description Tags for this route ("recommended", "fastest", "best-return"). May be empty. */
+  tags: BridgeTag[];
+  /** @description Bridge contract parameters as returned by the server. */
+  contractParams: DeltaRouteBridgeContractParams;
+};
+
+/** @description A single step of a route (origin chain or destination chain). */
+export type DeltaRouteStep = {
+  /** @description The token amount entering this step (before any per-step swap). */
+  input: DeltaTokenAmount;
+  /** @description The token amount exiting this step (after any per-step swap). */
+  output: DeltaTokenAmount;
+};
+
+/** @description A route describes how the swap flows from origin chain to destination chain. */
+export type DeltaRoute = {
+  /** @description Source-chain step. The on-chain Delta order's amounts come from `origin.input` and `origin.output`. */
+  origin: DeltaRouteStep;
+  /** @description Destination-chain step. For same-chain routes this mirrors `origin`. */
+  destination: DeltaRouteStep;
+  /** @description Bridge details. `null` for same-chain routes. */
+  bridge: DeltaRouteBridge | null;
+  /** @description Fee breakdown for this route. */
+  fees: {
+    /** @description Gas fee (single DeltaTokenAmount on the source chain). */
+    gas: DeltaTokenAmount;
+    /** @description Bridge fees (empty array for same-chain). */
+    bridge: DeltaTokenAmount[];
+  };
+};
+
+/** @description v2 price response: route-based, cross-chain first. */
+export type DeltaPriceV2 = {
+  /** @description Unique request ID for tracing. */
+  id: string;
+  /** @description Order side. */
+  side: 'SELL' | 'BUY';
+  /** @description Token the user trades (identity only — amounts live in route.origin.input). */
+  inputToken: DeltaPriceToken;
+  /** @description Token the user receives (identity only — amounts live in route.destination.output). */
+  outputToken: DeltaPriceToken;
+  /** @description Recommended route with full amounts and bridge details. */
+  route: DeltaRoute;
+  /** @description Partner info attached to this price. */
+  partner: {
+    name: string;
+    /** @description Partner fee in percent (e.g. 0.12 = 0.12%). */
+    feePercent: number;
+  };
+  /** @description Address to approve for spending the input token. */
+  spender: Address;
+  /** @description Alternative routes (other bridges). Each is a full DeltaRoute. */
+  alternatives: DeltaRoute[];
+};
+
+/** @description A flat bridge-routes entry returned by GET /delta/v2/prices/bridge-routes. */
+export type BridgeRoute = {
+  srcChainId: number;
+  destChainId: number;
+  /** @description Output tokens supported on the dest chain for this src→dest pair. */
+  tokens: Address[];
+};
+
+/* ------------------------------------------------------------------ */
+/* Orders v2 response shape (different from v1's DeltaAuction)         */
+/* ------------------------------------------------------------------ */
+
+/** @description Integrator-facing order status returned by v2 order endpoints. */
+const DeltaOrderStatusV2Map = {
+  Pending: 'PENDING',
+  AwaitingSignature: 'AWAITING_SIGNATURE',
+  Active: 'ACTIVE',
+  Suspended: 'SUSPENDED',
+  Cancelling: 'CANCELLING',
+  Bridging: 'BRIDGING',
+  Completed: 'COMPLETED',
+  Failed: 'FAILED',
+  Expired: 'EXPIRED',
+  Cancelled: 'CANCELLED',
+  Refunded: 'REFUNDED',
+} as const;
+
+export type DeltaOrderStatusV2 =
+  (typeof DeltaOrderStatusV2Map)[keyof typeof DeltaOrderStatusV2Map];
+
+/** @description `OnChainOrderType` plus the synthetic `FillableOrder` label, used when a Standard `Order` is `partiallyFillable`. */
+export type DeltaOnChainOrderTypeReported = OnChainOrderType | 'FillableOrder';
+
+/** @description Token side on an order. SELL provides an explicit `amount`; BUY provides expected/executed amounts. */
+export type DeltaTokenSide =
+  | {
+      chainId: number;
+      token: Address;
+      amount: string;
+    }
+  | {
+      chainId: number;
+      token: Address;
+      expectedAmount: string | null;
+      executedAmount: string | null;
+    };
+
+/** @description A single transaction entry on a v2 order. */
+export type DeltaTransactionV2 = {
+  originTx: string;
+  destinationTx: string | null;
+  /** @description Filled percent of the slice (0–100). */
+  filledPercent: number;
+  spentAmount: string | null;
+  receivedAmount: string | null;
+};
+
+/** @description Order shape returned by GET /v2/orders, /v2/orders/:id, /v2/orders/hash/:hash. */
+export type DeltaOrderV2Response = {
+  id: string;
+  status: DeltaOrderStatusV2;
+  side: 'SELL' | 'BUY';
+  type: DeltaOrderType;
+  onChainOrderType: DeltaOnChainOrderTypeReported | null;
+  input: DeltaTokenSide;
+  output: DeltaTokenSide;
+  owner: Address;
+  beneficiary: Address;
+  orderHash: string | null;
+  partner: string;
+  order: DeltaOrderUnion;
+  transactions: DeltaTransactionV2[];
+  /** @description ISO datetime string. */
+  createdAt: string | null;
+  /** @description ISO datetime string. */
+  updatedAt: string | null;
+  /** @description ISO datetime string. */
+  expiresAt: string | null;
+};

package/src/sdk/full.ts

@@ -12,6 +12,10 @@ import {
   constructAllDeltaOrdersHandlers,
   DeltaOrderHandlers,
 } from '../methods/delta';
+import {
+  constructAllDeltaV2OrdersHandlers,
+  DeltaV2OrderHandlers,
+} from '../methods/deltaV2';
 import {
   constructGetQuote,
   GetQuoteFunctions,
@@ -26,6 +30,7 @@ export type AllSDKMethods<TxResponse> = {
   /** @deprecated NFT Orders are deprecated and will be removed in a future version. */
   nftOrders: NFTOrderHandlers<TxResponse>;
   delta: DeltaOrderHandlers<TxResponse>;
+  deltaV2: DeltaV2OrderHandlers<TxResponse>;
   quote: GetQuoteFunctions;
 } & Required<ConstructBaseInput>;
 
@@ -41,6 +46,8 @@ export const constructFullSDK = <TxResponse = any>(
     constructAllNFTOrdersHandlers(config);
   const delta: DeltaOrderHandlers<TxResponse> =
     constructAllDeltaOrdersHandlers(config);
+  const deltaV2: DeltaV2OrderHandlers<TxResponse> =
+    constructAllDeltaV2OrdersHandlers(config);
   const quote = constructGetQuote(config);
 
   return {
@@ -48,6 +55,7 @@ export const constructFullSDK = <TxResponse = any>(
     limitOrders,
     nftOrders,
     delta,
+    deltaV2,
     quote,
     apiURL: config.apiURL ?? API_URL,
     chainId: config.chainId,

package/src/sdk/simple.ts

@@ -136,6 +136,34 @@ import {
   constructIsTokenSupportedInDelta,
   IsTokenSupportedInDeltaFunctions,
 } from '../methods/delta/isTokenSupportedInDelta';
+import {
+  constructAllDeltaV2OrdersHandlers,
+  DeltaV2OrderHandlers,
+} from '../methods/deltaV2';
+import {
+  BuildDeltaOrderV2Functions,
+  constructBuildDeltaOrderV2,
+} from '../methods/deltaV2/buildDeltaOrderV2';
+import {
+  constructPostDeltaOrderV2,
+  PostDeltaOrderV2Functions,
+} from '../methods/deltaV2/postDeltaOrderV2';
+import {
+  constructGetDeltaOrdersV2,
+  GetDeltaOrdersV2Functions,
+} from '../methods/deltaV2/getDeltaOrdersV2';
+import {
+  constructGetDeltaPriceV2,
+  GetDeltaPriceV2Functions,
+} from '../methods/deltaV2/getDeltaPriceV2';
+import {
+  constructGetBridgeRoutes,
+  GetBridgeRoutesFunctions,
+} from '../methods/deltaV2/getBridgeRoutes';
+import {
+  constructIsTokenSupportedInDeltaV2,
+  IsTokenSupportedInDeltaV2Functions,
+} from '../methods/deltaV2/isTokenSupportedInDeltaV2';
 
 export type SwapFetchMethods = GetBalancesFunctions &
   GetTokensFunctions &
@@ -168,6 +196,15 @@ export type DeltaFetchMethods = BuildDeltaOrderFunctions &
   IsTokenSupportedInDeltaFunctions &
   PostDeltaOrderFunctions;
 
+export type DeltaV2FetchMethods = BuildDeltaOrderV2Functions &
+  GetDeltaOrdersV2Functions &
+  GetDeltaPriceV2Functions &
+  GetDeltaContractFunctions &
+  GetPartnerFeeFunctions &
+  GetBridgeRoutesFunctions &
+  IsTokenSupportedInDeltaV2Functions &
+  PostDeltaOrderV2Functions;
+
 export type SimpleFetchSDK = {
   swap: SwapFetchMethods;
   /** @deprecated Limit Orders are deprecated and will be removed in a future version. */
@@ -175,6 +212,7 @@ export type SimpleFetchSDK = {
   /** @deprecated NFT Orders are deprecated and will be removed in a future version. */
   nftOrders: NFTOrdersFetchMethods;
   delta: DeltaFetchMethods;
+  deltaV2: DeltaV2FetchMethods;
   quote: QuoteFetchMethods;
 } & Required<ConstructBaseInput>;
 
@@ -187,6 +225,7 @@ export type SimpleSDK = {
   /** @deprecated NFT Orders are deprecated and will be removed in a future version. */
   nftOrders: NFTOrderHandlers<TxHash>;
   delta: DeltaOrderHandlers<TxHash>;
+  deltaV2: DeltaV2OrderHandlers<TxHash>;
   quote: QuoteFetchMethods;
 } & Required<ConstructBaseInput>;
 
@@ -298,6 +337,18 @@ export function constructSimpleSDK(
       constructIsTokenSupportedInDelta
     );
 
+    const deltaV2 = constructPartialSDK(
+      config,
+      constructBuildDeltaOrderV2,
+      constructPostDeltaOrderV2,
+      constructGetDeltaOrdersV2,
+      constructGetDeltaPriceV2,
+      constructGetDeltaContract,
+      constructGetPartnerFee,
+      constructGetBridgeRoutes,
+      constructIsTokenSupportedInDeltaV2
+    );
+
     const quote = constructPartialSDK(config, constructGetQuote);
 
     return {
@@ -305,6 +356,7 @@ export function constructSimpleSDK(
       limitOrders,
       nftOrders,
       delta,
+      deltaV2,
       quote,
       apiURL: options.apiURL ?? API_URL,
       chainId: options.chainId,
@@ -333,6 +385,9 @@ export function constructSimpleSDK(
   const delta: DeltaOrderHandlers<TxHash> =
     constructAllDeltaOrdersHandlers<TxHash>(config);
 
+  const deltaV2: DeltaV2OrderHandlers<TxHash> =
+    constructAllDeltaV2OrdersHandlers<TxHash>(config);
+
   const quote = constructGetQuote(config);
 
   return {
@@ -340,6 +395,7 @@ export function constructSimpleSDK(
     limitOrders,
     nftOrders,
     delta,
+    deltaV2,
     quote,
     apiURL: options.apiURL ?? API_URL,
     chainId: options.chainId,

package/src/types.ts

@@ -241,3 +241,12 @@ export interface JsonFragment {
    */
   readonly gas?: string;
 }
+
+/** @description Standard pagination envelope returned by paginated API endpoints. */
+export type PaginatedResponse<T> = {
+  data: T[];
+  total: number;
+  page: number;
+  limit: number;
+  hasMore: boolean;
+};