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

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;
@@ -216,6 +251,7 @@ export type OnChainOrderMap = {
   ExternalOrder: ExternalDeltaOrder;
   TWAPOrder: TWAPDeltaOrder;
   TWAPBuyOrder: TWAPBuyDeltaOrder;
+  ProductiveOrder: ProductiveDeltaOrder;
 };
 
 type BaseBridgeAuctionFields = Pick<
@@ -228,6 +264,7 @@ type BridgeAuctionFiledsMap = {
   ExternalOrder: BaseBridgeAuctionFields;
   TWAPOrder: Record<keyof BaseBridgeAuctionFields, null>;
   TWAPBuyOrder: Record<keyof BaseBridgeAuctionFields, null>;
+  ProductiveOrder: BaseBridgeAuctionFields;
 };
 
 type DeltaAuctionBase = {
@@ -252,35 +289,43 @@ type DeltaAuctionBase = {
   bridgeMetadata: BridgeMetadata | null;
   bridgeStatus: BridgeStatus | null;
 
-  type: 'MARKET' | 'LIMIT';
+  type: DeltaOrderType;
 };
 
-export type DeltaAuction<T extends OnChainOrderType = OnChainOrderType> =
-  T extends T
-    ? Prettify<
-        DeltaAuctionBase & {
-          onChainOrderType: T;
-          order: OnChainOrderMap[T];
-        } & BridgeAuctionFiledsMap[T]
-      >
-    : never;
+export type DeltaAuction<
+  T extends keyof OnChainOrderMap = keyof OnChainOrderMap,
+> = T extends T
+  ? Prettify<
+      DeltaAuctionBase & {
+        onChainOrderType: T;
+        order: OnChainOrderMap[T];
+      } & BridgeAuctionFiledsMap[T]
+    >
+  : never;
 
 export type DeltaAuctionDelta = DeltaAuction<'Order'>;
 export type DeltaAuctionExternal = DeltaAuction<'ExternalOrder'>;
 export type DeltaAuctionTWAP = DeltaAuction<'TWAPOrder'>;
 export type DeltaAuctionTWAPBuy = DeltaAuction<'TWAPBuyOrder'>;
+export type DeltaAuctionProductive = DeltaAuction<'ProductiveOrder'>;
 
 export type DeltaAuctionUnion =
   | DeltaAuctionDelta
   | DeltaAuctionExternal
   | DeltaAuctionTWAP
-  | DeltaAuctionTWAPBuy;
+  | DeltaAuctionTWAPBuy
+  | DeltaAuctionProductive;
 
 export type DeltaOrderUnion = OnChainOrderMap[keyof OnChainOrderMap];
 
 export type BridgeMetadata = {
-  /** @description The amount that user should expect to get */
+  /** @description Actual amount received on the destination chain. */
   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.
+   */
+  expectedOutputAmount?: string;
   /** @description The cross-chain deadline. If deadline passes, the bridgeStatus would be expired */
   fillDeadline?: number; // available for Across protocol
   /** @description The deposit id */
@@ -298,10 +343,14 @@ export type OnChainOrderType =
   | 'Order'
   | 'ExternalOrder'
   | 'TWAPOrder'
-  | 'TWAPBuyOrder';
+  | 'TWAPBuyOrder'
+  | 'ProductiveOrder';
 
 export type TWAPOnChainOrderType = 'TWAPOrder' | 'TWAPBuyOrder';
 
+/** @description Order kind: MARKET (immediate) vs LIMIT (rate-pegged). */
+export type DeltaOrderType = 'MARKET' | 'LIMIT';
+
 //// available on BridgePrice ////
 
 type BridgeQuoteFee = {

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