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

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

package/src/methods/deltaV2/getBridgeRoutes.ts

@@ -0,0 +1,82 @@
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type { ConstructFetchInput, RequestParameters } from '../../types';
+import type { BridgeProtocolResponse } from '../delta/getBridgeInfo';
+import type { BridgeRoute } from './types';
+
+type GetBridgeRoutesParams = {
+  /** @description Include tokens that can be swapped on destChain after bridge. Default is true. */
+  allowBridgeAndSwap?: boolean;
+  /** @description Include only the specified bridges. Default is all bridges. */
+  bridges?: string[];
+};
+
+type BridgeRoutesQuery = {
+  allowBridgeAndSwap?: boolean;
+  bridges?: string;
+};
+
+type BridgeRoutesResponse = { routes: BridgeRoute[] };
+
+type GetBridgeRoutes = (
+  params?: GetBridgeRoutesParams,
+  requestParams?: RequestParameters
+) => Promise<BridgeRoute[]>;
+
+type GetBridgeProtocolsV2 = (
+  requestParams?: RequestParameters
+) => Promise<BridgeProtocolResponse[]>;
+
+type BridgeProtocolsV2Response = {
+  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;
+};
+
+export const constructGetBridgeRoutes = ({
+  apiURL = API_URL,
+  fetcher,
+}: ConstructFetchInput): GetBridgeRoutesFunctions => {
+  const deltaPricesUrl = `${apiURL}/delta/v2/prices` as const;
+
+  const getBridgeRoutes: GetBridgeRoutes = async (
+    params = {},
+    requestParams
+  ) => {
+    const { allowBridgeAndSwap, bridges } = params;
+
+    const search = constructSearchString<BridgeRoutesQuery>({
+      allowBridgeAndSwap,
+      bridges: bridges?.join(','),
+    });
+
+    const fetchURL = `${deltaPricesUrl}/bridge-routes${search}` as const;
+
+    const data = await fetcher<BridgeRoutesResponse>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data.routes;
+  };
+
+  const getBridgeProtocolsV2: GetBridgeProtocolsV2 = async (requestParams) => {
+    const fetchURL = `${deltaPricesUrl}/bridge-protocols` as const;
+
+    const data = await fetcher<BridgeProtocolsV2Response>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data.bridgeProtocols;
+  };
+
+  return { getBridgeRoutes, getBridgeProtocolsV2 };
+};

package/src/methods/deltaV2/getDeltaOrdersV2.ts

@@ -0,0 +1,119 @@
+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 { DeltaOrderStatusV2, DeltaOrderV2Response } from './types';
+
+type GetDeltaOrderByIdV2 = (
+  orderId: string,
+  requestParams?: RequestParameters
+) => Promise<DeltaOrderV2Response>;
+
+type GetDeltaOrderByHashV2 = (
+  orderHash: string,
+  requestParams?: RequestParameters
+) => Promise<DeltaOrderV2Response>;
+
+type OrdersV2Filter = {
+  /** @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?: DeltaOrderStatusV2[];
+  /** @description Filter by order type. MARKET or LIMIT. */
+  type?: DeltaOrderType;
+  /** @description Filter by on-chain order type. */
+  onChainOrderType?: OnChainOrderType;
+};
+
+type OrderFiltersV2Query = Omit<OrdersV2Filter, 'chainId' | 'status'> & {
+  chainId?: string;
+  status?: string;
+};
+
+type GetDeltaOrdersV2 = (
+  options: OrdersV2Filter,
+  requestParams?: RequestParameters
+) => Promise<PaginatedResponse<DeltaOrderV2Response>>;
+
+export type GetDeltaOrdersV2Functions = {
+  /** @description Fetch a single order by its UUID. */
+  getDeltaOrderByIdV2: GetDeltaOrderByIdV2;
+  /** @description Fetch a single order by its EIP-712 order hash. */
+  getDeltaOrderByHashV2: GetDeltaOrderByHashV2;
+  /** @description List Delta orders with the v2 pagination envelope. */
+  getDeltaOrdersV2: GetDeltaOrdersV2;
+};
+
+export const constructGetDeltaOrdersV2 = ({
+  apiURL = API_URL,
+  fetcher,
+}: ConstructFetchInput): GetDeltaOrdersV2Functions => {
+  const baseUrl = `${apiURL}/delta/v2/orders` as const;
+
+  const getDeltaOrderByIdV2: GetDeltaOrderByIdV2 = async (
+    orderId,
+    requestParams
+  ) => {
+    const fetchURL = `${baseUrl}/${orderId}` as const;
+    return fetcher<DeltaOrderV2Response>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+  };
+
+  const getDeltaOrderByHashV2: GetDeltaOrderByHashV2 = async (
+    orderHash,
+    requestParams
+  ) => {
+    const fetchURL = `${baseUrl}/hash/${orderHash}` as const;
+    return fetcher<DeltaOrderV2Response>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+  };
+
+  const getDeltaOrdersV2: GetDeltaOrdersV2 = async (options, requestParams) => {
+    const chainIdString = options.chainId?.join(',');
+    const statusString = options.status?.join(',');
+
+    const search = constructSearchString<OrderFiltersV2Query>({
+      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<DeltaOrderV2Response>>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+  };
+
+  return {
+    getDeltaOrderByIdV2,
+    getDeltaOrderByHashV2,
+    getDeltaOrdersV2,
+  };
+};

package/src/methods/deltaV2/getDeltaPriceV2.ts

@@ -0,0 +1,108 @@
+import { API_URL, SwapSide } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type {
+  ConstructFetchInput,
+  EnumerateLiteral,
+  RequestParameters,
+} from '../../types';
+import type { DeltaPriceV2 } from './types';
+
+type SwapSideUnion = EnumerateLiteral<typeof SwapSide>;
+
+export type DeltaPriceV2Params = {
+  /** @description Source Token Address */
+  srcToken: string;
+  /** @description Destination Token Address. For Crosschain Orders, the destination token on the destination chain */
+  destToken: string;
+  /** @description srcToken amount in wei */
+  amount: string;
+  /** @description Source Token Decimals */
+  srcDecimals: number;
+  /** @description Destination Token Decimals */
+  destDecimals: number;
+  /** @description User's Wallet Address */
+  userAddress?: string;
+  /** @description Beneficiary Address */
+  beneficiary?: string;
+  /** @description Partner string. */
+  partner?: string;
+  /** @description Partner fee in basis points (bps), 50bps=0.5% */
+  partnerFeeBps?: number;
+  /** @description Destination Chain ID for Crosschain Orders */
+  destChainId?: number;
+  /** @description SELL or BUY, default is SELL */
+  side?: SwapSideUnion;
+  /** @description In %. Bypasses the API price impact check (default = 15%) */
+  maxImpact?: number;
+  maxUSDImpact?: number;
+
+  includeAgents?: string[];
+  excludeAgents?: string[];
+  includeBridges?: string[];
+  excludeBridges?: string[];
+
+  /** @description Allow swap on destChain after bridge. Default is true. */
+  allowBridgeAndSwap?: boolean;
+  degenMode?: boolean;
+};
+
+type DeltaPriceV2QueryOptions = Omit<
+  DeltaPriceV2Params,
+  'includeAgents' | 'excludeAgents' | 'includeBridges' | 'excludeBridges'
+> & {
+  chainId: number;
+  includeAgents?: string;
+  excludeAgents?: string;
+  includeBridges?: string;
+  excludeBridges?: string;
+};
+
+type GetDeltaPriceV2 = (
+  options: DeltaPriceV2Params,
+  requestParams?: RequestParameters
+) => Promise<DeltaPriceV2>;
+
+export type GetDeltaPriceV2Functions = {
+  /** @description Fetch a v2 price quote (route-based response). */
+  getDeltaPriceV2: GetDeltaPriceV2;
+};
+
+export const constructGetDeltaPriceV2 = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): GetDeltaPriceV2Functions => {
+  const pricesUrl = `${apiURL}/delta/v2/prices` as const;
+
+  const getDeltaPriceV2: GetDeltaPriceV2 = async (options, requestParams) => {
+    const {
+      includeAgents,
+      excludeAgents,
+      includeBridges,
+      excludeBridges,
+      ...rest
+    } = options;
+
+    const search = constructSearchString<DeltaPriceV2QueryOptions>({
+      ...rest,
+      chainId,
+      side: options.side ?? SwapSide.SELL,
+      includeAgents: includeAgents?.join(','),
+      excludeAgents: excludeAgents?.join(','),
+      includeBridges: includeBridges?.join(','),
+      excludeBridges: excludeBridges?.join(','),
+    });
+
+    const fetchURL = `${pricesUrl}${search}` as const;
+
+    const data = await fetcher<DeltaPriceV2>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data;
+  };
+
+  return { getDeltaPriceV2 };
+};