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

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

package/src/methods/deltaV2/index.ts

@@ -0,0 +1,303 @@
+import type { ConstructProviderFetchInput } from '../../types';
+import type { DeltaAuction, OnChainOrderMap } from '../delta/helpers/types';
+
+// reused v1 modules
+import {
+  GetDeltaContractFunctions,
+  constructGetDeltaContract,
+} from '../delta/getDeltaContract';
+import {
+  constructGetPartnerFee,
+  GetPartnerFeeFunctions,
+} from '../delta/getPartnerFee';
+import {
+  ApproveTokenForDeltaFunctions,
+  constructApproveTokenForDelta,
+} from '../delta/approveForDelta';
+import {
+  constructPreSignDeltaOrder,
+  PreSignDeltaOrderFunctions,
+} from '../delta/preSignDeltaOrder';
+import {
+  constructPreSignExternalDeltaOrder,
+  PreSignExternalDeltaOrderFunctions,
+} from '../delta/preSignExternalDeltaOrder';
+import {
+  constructPreSignTWAPDeltaOrder,
+  PreSignTWAPDeltaOrderFunctions,
+} from '../delta/preSignTWAPDeltaOrder';
+import {
+  DeltaTokenModuleFunctions,
+  constructDeltaTokenModule,
+} from '../delta/deltaTokenModule';
+
+// new v2 modules
+import {
+  BuildDeltaOrderV2Functions,
+  BuildDeltaOrderV2Params,
+  BuiltDeltaOrderV2,
+  constructBuildDeltaOrderV2,
+} from './buildDeltaOrderV2';
+import {
+  BuildExternalDeltaOrderV2Functions,
+  BuildExternalDeltaOrderV2Params,
+  constructBuildExternalDeltaOrderV2,
+} from './buildExternalDeltaOrderV2';
+import {
+  BuildTWAPDeltaOrderV2Functions,
+  BuildTWAPDeltaOrderV2Params,
+  constructBuildTWAPDeltaOrderV2,
+} from './buildTWAPDeltaOrderV2';
+import {
+  constructPostDeltaOrderV2,
+  DeltaOrderToPostV2,
+  PostDeltaOrderV2Functions,
+} from './postDeltaOrderV2';
+import {
+  constructPostExternalDeltaOrderV2,
+  PostExternalDeltaOrderV2Functions,
+} from './postExternalDeltaOrderV2';
+import {
+  constructPostTWAPDeltaOrderV2,
+  PostTWAPDeltaOrderV2Functions,
+} from './postTWAPDeltaOrderV2';
+import {
+  constructGetDeltaPriceV2,
+  GetDeltaPriceV2Functions,
+} from './getDeltaPriceV2';
+import {
+  constructGetDeltaOrdersV2,
+  GetDeltaOrdersV2Functions,
+} from './getDeltaOrdersV2';
+import {
+  constructGetBridgeRoutes,
+  GetBridgeRoutesFunctions,
+} from './getBridgeRoutes';
+import {
+  constructIsTokenSupportedInDeltaV2,
+  IsTokenSupportedInDeltaV2Functions,
+} from './isTokenSupportedInDeltaV2';
+import {
+  CancelDeltaOrderV2Functions,
+  constructCancelDeltaOrderV2,
+} from './cancelDeltaOrderV2';
+import {
+  constructGetAgentsListV2,
+  GetAgentsListV2Functions,
+} from './getAgentsListV2';
+
+// ── Sign v2 ─────────────────────────────────────────────────────────────────
+
+type SignDeltaOrderV2 = (builtOrder: BuiltDeltaOrderV2) => Promise<string>;
+
+export type SignDeltaOrderV2Functions = {
+  /** @description Sign a BuiltDeltaOrderV2 (any order type) using EIP-712 typed data. */
+  signDeltaOrderV2: SignDeltaOrderV2;
+};
+
+export const constructSignDeltaOrderV2 = (
+  options: Pick<
+    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
+    'contractCaller'
+  >
+): SignDeltaOrderV2Functions => {
+  const signDeltaOrderV2: SignDeltaOrderV2 = async (builtOrder) => {
+    return options.contractCaller.signTypedDataCall({
+      types: builtOrder.toSign.types,
+      domain: builtOrder.toSign.domain,
+      data: builtOrder.toSign.value,
+    });
+  };
+  return { signDeltaOrderV2 };
+};
+
+// ── Submit orchestrators ─────────────────────────────────────────────────────
+
+export type SubmitDeltaOrderV2Params = BuildDeltaOrderV2Params & {
+  /** @description Referrer address */
+  referrerAddress?: string;
+  degenMode?: boolean;
+} & Pick<DeltaOrderToPostV2, 'type' | 'includeAgents' | 'excludeAgents'>;
+
+type SubmitDeltaOrderV2 = (
+  orderParams: SubmitDeltaOrderV2Params
+) => Promise<DeltaAuction<'Order'>>;
+
+export type SubmitDeltaOrderV2Funcs = {
+  submitDeltaOrderV2: SubmitDeltaOrderV2;
+};
+
+export const constructSubmitDeltaOrderV2 = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitDeltaOrderV2Funcs => {
+  const { buildDeltaOrderV2 } = constructBuildDeltaOrderV2(options);
+  const { signDeltaOrderV2 } = constructSignDeltaOrderV2(options);
+  const { postDeltaOrderV2 } = constructPostDeltaOrderV2(options);
+
+  const submitDeltaOrderV2: SubmitDeltaOrderV2 = async (orderParams) => {
+    const orderData = await buildDeltaOrderV2(orderParams);
+    const signature = await signDeltaOrderV2(orderData);
+
+    return postDeltaOrderV2({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.toSign.value as OnChainOrderMap['Order'],
+      partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
+      degenMode: orderParams.degenMode,
+    });
+  };
+
+  return { submitDeltaOrderV2 };
+};
+
+export type SubmitExternalDeltaOrderV2Params =
+  BuildExternalDeltaOrderV2Params & {
+    referrerAddress?: string;
+  } & Pick<DeltaOrderToPostV2, 'type' | 'includeAgents' | 'excludeAgents'>;
+
+type SubmitExternalDeltaOrderV2 = (
+  orderParams: SubmitExternalDeltaOrderV2Params
+) => Promise<DeltaAuction<'ExternalOrder'>>;
+
+export type SubmitExternalDeltaOrderV2Funcs = {
+  submitExternalDeltaOrderV2: SubmitExternalDeltaOrderV2;
+};
+
+export const constructSubmitExternalDeltaOrderV2 = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitExternalDeltaOrderV2Funcs => {
+  const { buildExternalDeltaOrderV2 } =
+    constructBuildExternalDeltaOrderV2(options);
+  const { signDeltaOrderV2 } = constructSignDeltaOrderV2(options);
+  const { postExternalDeltaOrderV2 } =
+    constructPostExternalDeltaOrderV2(options);
+
+  const submitExternalDeltaOrderV2: SubmitExternalDeltaOrderV2 = async (
+    orderParams
+  ) => {
+    const orderData = await buildExternalDeltaOrderV2(orderParams);
+    const signature = await signDeltaOrderV2(orderData);
+
+    return postExternalDeltaOrderV2({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.toSign.value as OnChainOrderMap['ExternalOrder'],
+      partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
+    });
+  };
+
+  return { submitExternalDeltaOrderV2 };
+};
+
+export type SubmitTWAPDeltaOrderV2Params = BuildTWAPDeltaOrderV2Params & {
+  referrerAddress?: string;
+  degenMode?: boolean;
+} & Pick<DeltaOrderToPostV2, 'type' | 'includeAgents' | 'excludeAgents'>;
+
+type SubmitTWAPDeltaOrderV2 = (
+  orderParams: SubmitTWAPDeltaOrderV2Params
+) => Promise<DeltaAuction<'TWAPOrder'> | DeltaAuction<'TWAPBuyOrder'>>;
+
+export type SubmitTWAPDeltaOrderV2Funcs = {
+  submitTWAPDeltaOrderV2: SubmitTWAPDeltaOrderV2;
+};
+
+export const constructSubmitTWAPDeltaOrderV2 = (
+  options: ConstructProviderFetchInput<any, 'signTypedDataCall'>
+): SubmitTWAPDeltaOrderV2Funcs => {
+  const { buildTWAPDeltaOrderV2 } = constructBuildTWAPDeltaOrderV2(options);
+  const { signDeltaOrderV2 } = constructSignDeltaOrderV2(options);
+  const { postTWAPDeltaOrderV2 } = constructPostTWAPDeltaOrderV2(options);
+
+  const submitTWAPDeltaOrderV2: SubmitTWAPDeltaOrderV2 = async (
+    orderParams
+  ) => {
+    const orderData = await buildTWAPDeltaOrderV2(orderParams);
+    const signature = await signDeltaOrderV2(orderData);
+
+    return postTWAPDeltaOrderV2({
+      signature,
+      partner: orderParams.partner,
+      order: orderData.toSign.value as
+        | OnChainOrderMap['TWAPOrder']
+        | OnChainOrderMap['TWAPBuyOrder'],
+      onChainOrderType: orderParams.onChainOrderType,
+      partiallyFillable: orderParams.partiallyFillable,
+      referrerAddress: orderParams.referrerAddress,
+      type: orderParams.type,
+      includeAgents: orderParams.includeAgents,
+      excludeAgents: orderParams.excludeAgents,
+      degenMode: orderParams.degenMode,
+    });
+  };
+
+  return { submitTWAPDeltaOrderV2 };
+};
+
+// ── Handler bundle ───────────────────────────────────────────────────────────
+
+export type DeltaV2OrderHandlers<TxResponse> = SubmitDeltaOrderV2Funcs &
+  SubmitExternalDeltaOrderV2Funcs &
+  SubmitTWAPDeltaOrderV2Funcs &
+  BuildDeltaOrderV2Functions &
+  BuildExternalDeltaOrderV2Functions &
+  BuildTWAPDeltaOrderV2Functions &
+  PostDeltaOrderV2Functions &
+  PostExternalDeltaOrderV2Functions &
+  PostTWAPDeltaOrderV2Functions &
+  SignDeltaOrderV2Functions &
+  PreSignDeltaOrderFunctions<TxResponse> &
+  PreSignExternalDeltaOrderFunctions<TxResponse> &
+  PreSignTWAPDeltaOrderFunctions<TxResponse> &
+  GetDeltaPriceV2Functions &
+  GetDeltaOrdersV2Functions &
+  GetBridgeRoutesFunctions &
+  IsTokenSupportedInDeltaV2Functions &
+  GetAgentsListV2Functions &
+  GetDeltaContractFunctions &
+  GetPartnerFeeFunctions &
+  ApproveTokenForDeltaFunctions<TxResponse> &
+  DeltaTokenModuleFunctions<TxResponse> &
+  CancelDeltaOrderV2Functions;
+
+/** @description Construct an SDK bundle exposing every Delta v2 method (queries, build/sign/post, on-chain helpers). */
+export const constructAllDeltaV2OrdersHandlers = <TxResponse>(
+  options: ConstructProviderFetchInput<
+    TxResponse,
+    'signTypedDataCall' | 'transactCall'
+  >
+): DeltaV2OrderHandlers<TxResponse> => {
+  return {
+    ...constructSubmitDeltaOrderV2(options),
+    ...constructSubmitExternalDeltaOrderV2(options),
+    ...constructSubmitTWAPDeltaOrderV2(options),
+    ...constructBuildDeltaOrderV2(options),
+    ...constructBuildExternalDeltaOrderV2(options),
+    ...constructBuildTWAPDeltaOrderV2(options),
+    ...constructPostDeltaOrderV2(options),
+    ...constructPostExternalDeltaOrderV2(options),
+    ...constructPostTWAPDeltaOrderV2(options),
+    ...constructSignDeltaOrderV2(options),
+    ...constructPreSignDeltaOrder(options),
+    ...constructPreSignExternalDeltaOrder(options),
+    ...constructPreSignTWAPDeltaOrder(options),
+    ...constructGetDeltaPriceV2(options),
+    ...constructGetDeltaOrdersV2(options),
+    ...constructGetBridgeRoutes(options),
+    ...constructIsTokenSupportedInDeltaV2(options),
+    ...constructGetAgentsListV2(options),
+    ...constructGetDeltaContract(options),
+    ...constructGetPartnerFee(options),
+    ...constructApproveTokenForDelta(options),
+    ...constructDeltaTokenModule(options),
+    ...constructCancelDeltaOrderV2(options),
+  };
+};

package/src/methods/deltaV2/isTokenSupportedInDeltaV2.ts

@@ -0,0 +1,52 @@
+import { API_URL } from '../../constants';
+import { constructSearchString } from '../../helpers/misc';
+import type {
+  Address,
+  ConstructFetchInput,
+  RequestParameters,
+} from '../../types';
+
+type TokenSupportedResponse = { supported: boolean };
+type IsTokenSupportedQuery = {
+  token: Address;
+  chainId: number;
+};
+
+type IsTokenSupportedInDeltaV2 = (
+  token: Address,
+  requestParams?: RequestParameters
+) => Promise<boolean>;
+
+export type IsTokenSupportedInDeltaV2Functions = {
+  isTokenSupportedInDeltaV2: IsTokenSupportedInDeltaV2;
+};
+
+export const constructIsTokenSupportedInDeltaV2 = ({
+  apiURL = API_URL,
+  chainId,
+  fetcher,
+}: ConstructFetchInput): IsTokenSupportedInDeltaV2Functions => {
+  const baseUrl = `${apiURL}/delta/v2/prices/is-token-supported` as const;
+
+  const isTokenSupportedInDeltaV2: IsTokenSupportedInDeltaV2 = async (
+    token,
+    requestParams
+  ) => {
+    const search = constructSearchString<IsTokenSupportedQuery>({
+      token,
+      chainId,
+    });
+
+    const fetchURL = `${baseUrl}/${search}` as const;
+
+    const data = await fetcher<TokenSupportedResponse>({
+      url: fetchURL,
+      method: 'GET',
+      requestParams,
+    });
+
+    return data.supported;
+  };
+
+  return { isTokenSupportedInDeltaV2 };
+};