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

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

package/src/methods/deltaV2/getBridgeRoutes.ts

@@ -23,19 +23,19 @@ type GetBridgeRoutes = (
   requestParams?: RequestParameters
 ) => Promise<BridgeRoute[]>;
 
-type GetBridgeProtocolsV2 = (
+type GetBridgeProtocols = (
   requestParams?: RequestParameters
 ) => Promise<BridgeProtocolResponse[]>;
 
-type BridgeProtocolsV2Response = {
+type BridgeProtocolsResponse = {
   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;
+  /** @description Fetch supported bridge protocols (unchanged from v1). */
+  getBridgeProtocols: GetBridgeProtocols;
 };
 
 export const constructGetBridgeRoutes = ({
@@ -66,10 +66,10 @@ export const constructGetBridgeRoutes = ({
     return data.routes;
   };
 
-  const getBridgeProtocolsV2: GetBridgeProtocolsV2 = async (requestParams) => {
+  const getBridgeProtocols: GetBridgeProtocols = async (requestParams) => {
     const fetchURL = `${deltaPricesUrl}/bridge-protocols` as const;
 
-    const data = await fetcher<BridgeProtocolsV2Response>({
+    const data = await fetcher<BridgeProtocolsResponse>({
       url: fetchURL,
       method: 'GET',
       requestParams,
@@ -78,5 +78,5 @@ export const constructGetBridgeRoutes = ({
     return data.bridgeProtocols;
   };
 
-  return { getBridgeRoutes, getBridgeProtocolsV2 };
+  return { getBridgeRoutes, getBridgeProtocols };
 };

package/src/methods/deltaV2/getDeltaOrders.ts

@@ -0,0 +1,149 @@
+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 { DeltaOrderStatus, DeltaAuction } from './types';
+
+type GetDeltaOrderById = (
+  orderId: string,
+  requestParams?: RequestParameters
+) => Promise<DeltaAuction>;
+
+type GetDeltaOrderByHash = (
+  orderHash: string,
+  requestParams?: RequestParameters
+) => Promise<DeltaAuction>;
+
+type OrdersFilter = {
+  /** @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?: DeltaOrderStatus[];
+  /** @description Filter by order type. MARKET or LIMIT. */
+  type?: DeltaOrderType;
+  /** @description Filter by on-chain order type. */
+  onChainOrderType?: OnChainOrderType;
+};
+
+type OrderFiltersQuery = Omit<OrdersFilter, 'chainId' | 'status'> & {
+  chainId?: string;
+  status?: string;
+};
+
+type GetDeltaOrders = (
+  options: OrdersFilter,
+  requestParams?: RequestParameters
+) => Promise<PaginatedResponse<DeltaAuction>>;
+
+type GetRequiredBalanceParams = {
+  userAddress: Address;
+  tokenAddress?: Address;
+};
+
+type GetRequiredBalance = (
+  userParams: GetRequiredBalanceParams,
+  requestParams?: RequestParameters
+) => Promise<Record<string, string>>; // token -> required balance across open Delta orders
+
+export type GetDeltaOrdersFunctions = {
+  /** @description Fetch a single order by its UUID. */
+  getDeltaOrderById: GetDeltaOrderById;
+  /** @description Fetch a single order by its EIP-712 order hash. */
+  getDeltaOrderByHash: GetDeltaOrderByHash;
+  /** @description List Delta orders with the v2 pagination envelope. */
+  getDeltaOrders: GetDeltaOrders;
+  /** @description Required balance per token across the user's open Delta v2 orders. Pass `tokenAddress` to narrow the result to a single token. */
+  getRequiredBalanceForDeltaOrders: GetRequiredBalance;
+};
+
+export const constructGetDeltaOrders = ({
+  apiURL = API_URL,
+  fetcher,
+  chainId,
+}: ConstructFetchInput): GetDeltaOrdersFunctions => {
+  const baseUrl = `${apiURL}/delta/v2/orders` as const;
+
+  const getDeltaOrderById: GetDeltaOrderById = async (
+    orderId,
+    requestParams
+  ) => {
+    const fetchURL = `${baseUrl}/${orderId}` as const;
+    return fetcher<DeltaAuction>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+  };
+
+  const getDeltaOrderByHash: GetDeltaOrderByHash = async (
+    orderHash,
+    requestParams
+  ) => {
+    const fetchURL = `${baseUrl}/hash/${orderHash}` as const;
+    return fetcher<DeltaAuction>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+  };
+
+  const getDeltaOrders: GetDeltaOrders = async (options, requestParams) => {
+    const chainIdString = options.chainId?.join(',');
+    const statusString = options.status?.join(',');
+
+    const search = constructSearchString<OrderFiltersQuery>({
+      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<DeltaAuction>>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+  };
+
+  const getRequiredBalanceForDeltaOrders: GetRequiredBalance = async (
+    userParams,
+    requestParams
+  ) => {
+    const userURL =
+      `${baseUrl}/fillablebalance/${chainId}/${userParams.userAddress}` as const;
+    const fetchURL = userParams.tokenAddress
+      ? (`${userURL}/${userParams.tokenAddress}` as const)
+      : userURL;
+
+    const response = await fetcher<Record<string, string>>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return response;
+  };
+
+  return {
+    getDeltaOrderById,
+    getDeltaOrderByHash,
+    getDeltaOrders,
+    getRequiredBalanceForDeltaOrders,
+  };
+};

package/src/methods/deltaV2/{getDeltaPriceV2.ts → getDeltaPrice.ts}

@@ -5,11 +5,11 @@ import type {
   EnumerateLiteral,
   RequestParameters,
 } from '../../types';
-import type { DeltaPriceV2 } from './types';
+import type { DeltaPrice } from './types';
 
 type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
 
-export type DeltaPriceV2Params = {
+export type DeltaPriceParams = {
   /** @description Source Token Address */
   srcToken: string;
   /** @description Destination Token Address. For Crosschain Orders, the destination token on the destination chain */
@@ -46,8 +46,8 @@ export type DeltaPriceV2Params = {
   degenMode?: boolean;
 };
 
-type DeltaPriceV2QueryOptions = Omit<
-  DeltaPriceV2Params,
+type DeltaPriceQueryOptions = Omit<
+  DeltaPriceParams,
   'includeAgents' | 'excludeAgents' | 'includeBridges' | 'excludeBridges'
 > & {
   chainId: number;
@@ -57,24 +57,24 @@ type DeltaPriceV2QueryOptions = Omit<
   excludeBridges?: string;
 };
 
-type GetDeltaPriceV2 = (
-  options: DeltaPriceV2Params,
+type GetDeltaPrice = (
+  options: DeltaPriceParams,
   requestParams?: RequestParameters
-) => Promise<DeltaPriceV2>;
+) => Promise<DeltaPrice>;
 
-export type GetDeltaPriceV2Functions = {
+export type GetDeltaPriceFunctions = {
   /** @description Fetch a v2 price quote (route-based response). */
-  getDeltaPriceV2: GetDeltaPriceV2;
+  getDeltaPrice: GetDeltaPrice;
 };
 
-export const constructGetDeltaPriceV2 = ({
+export const constructGetDeltaPrice = ({
   apiURL = API_URL,
   chainId,
   fetcher,
-}: ConstructFetchInput): GetDeltaPriceV2Functions => {
+}: ConstructFetchInput): GetDeltaPriceFunctions => {
   const pricesUrl = `${apiURL}/delta/v2/prices` as const;
 
-  const getDeltaPriceV2: GetDeltaPriceV2 = async (options, requestParams) => {
+  const getDeltaPrice: GetDeltaPrice = async (options, requestParams) => {
     const {
       includeAgents,
       excludeAgents,
@@ -83,7 +83,7 @@ export const constructGetDeltaPriceV2 = ({
       ...rest
     } = options;
 
-    const search = constructSearchString<DeltaPriceV2QueryOptions>({
+    const search = constructSearchString<DeltaPriceQueryOptions>({
       ...rest,
       chainId,
       side: options.side ?? SwapSide.SELL,
@@ -95,7 +95,7 @@ export const constructGetDeltaPriceV2 = ({
 
     const fetchURL = `${pricesUrl}${search}` as const;
 
-    const data = await fetcher<DeltaPriceV2>({
+    const data = await fetcher<DeltaPrice>({
       url: fetchURL,
       method: 'GET',
       requestParams,
@@ -104,5 +104,5 @@ export const constructGetDeltaPriceV2 = ({
     return data;
   };
 
-  return { getDeltaPriceV2 };
+  return { getDeltaPrice };
 };