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

package/src/examples/deltaV2.ts

@@ -1,200 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import axios from 'axios';
-import { ethers, Wallet } from 'ethersV5';
-import {
-  constructPartialSDK,
-  constructEthersContractCaller,
-  constructAxiosFetcher,
-  constructAllDeltaV2OrdersHandlers,
-} from '..';
-import { startStatusCheckV2 } from './helpers/deltaV2';
-
-const fetcher = constructAxiosFetcher(axios);
-
-const provider = ethers.getDefaultProvider(1);
-const signer = Wallet.createRandom().connect(provider);
-const account = signer.address;
-const contractCaller = constructEthersContractCaller(
-  {
-    ethersProviderOrSigner: provider,
-    EthersContract: ethers.Contract,
-  },
-  account
-);
-
-const deltaSDK = constructPartialSDK(
-  {
-    chainId: 1,
-    fetcher,
-    contractCaller,
-  },
-  constructAllDeltaV2OrdersHandlers
-);
-
-const DAI_TOKEN = '0x6b175474e89094c44da98b954eedeac495271d0f';
-const USDC_TOKEN = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
-
-async function simpleDeltaV2Flow() {
-  const amount = '1000000000000'; // wei
-
-  const deltaPrice = await deltaSDK.getDeltaPriceV2({
-    srcToken: DAI_TOKEN,
-    destToken: USDC_TOKEN,
-    amount,
-    userAddress: account,
-    srcDecimals: 18,
-    destDecimals: 6,
-    // partner: "..." // if available
-  });
-
-  const DeltaContract = await deltaSDK.getDeltaContract();
-
-  // or sign a Permit1 or Permit2 TransferFrom for DeltaContract
-  const tx = await deltaSDK.approveTokenForDelta(amount, DAI_TOKEN);
-  await tx.wait();
-
-  const deltaAuction = await deltaSDK.submitDeltaOrderV2({
-    route: deltaPrice.route, // or pick from deltaPrice.alternatives
-    side: deltaPrice.side,
-    owner: account,
-    // beneficiary: anotherAccount, // if need to send destToken to another account
-    // permit: "0x1234...", // if signed a Permit1 or Permit2 TransferFrom for DeltaContract
-    slippage: 50, // 50 bps = 0.5% slippage
-  });
-
-  // poll if necessary
-  startStatusCheckV2(() => deltaSDK.getDeltaOrderByIdV2(deltaAuction.id));
-}
-
-async function manualDeltaV2Flow() {
-  const amount = '1000000000000'; // wei
-
-  const deltaPrice = await deltaSDK.getDeltaPriceV2({
-    srcToken: DAI_TOKEN,
-    destToken: USDC_TOKEN,
-    amount,
-    userAddress: account,
-    srcDecimals: 18,
-    destDecimals: 6,
-    // partner: "..." // if available
-  });
-
-  const DeltaContract = await deltaSDK.getDeltaContract();
-
-  // or sign a Permit1 or Permit2 TransferFrom for DeltaContract
-  const tx = await deltaSDK.approveTokenForDelta(amount, DAI_TOKEN);
-  await tx.wait();
-
-  // server-side build (returns EIP-712 typed data + orderHash)
-  const builtOrder = await deltaSDK.buildDeltaOrderV2({
-    route: deltaPrice.route, // or pick from deltaPrice.alternatives
-    side: deltaPrice.side,
-    owner: account,
-    // beneficiary: anotherAccount, // if need to send destToken to another account
-    // permit: "0x1234...", // if signed a Permit1 or Permit2 TransferFrom for DeltaContract
-    slippage: 50, // 50 bps = 0.5% slippage
-  });
-
-  // one signer for every v2 order type (Order / ExternalOrder / TWAPOrder / TWAPBuyOrder)
-  const signature = await deltaSDK.signDeltaOrderV2(builtOrder);
-
-  const deltaAuction = await deltaSDK.postDeltaOrderV2({
-    // partner: "..." // if available
-    order: builtOrder.toSign.value as Parameters<
-      typeof deltaSDK.postDeltaOrderV2
-    >[0]['order'],
-    signature,
-  });
-
-  // poll if necessary
-  startStatusCheckV2(() => deltaSDK.getDeltaOrderByIdV2(deltaAuction.id));
-}
-
-// External orders forward execution to an integrator-provided handler contract.
-// Same build/sign/post shape as standard orders, plus { handler, data }.
-// See externalDelta.ts for handler-specific examples (Aave collateral swap, etc.).
-async function externalDeltaV2Flow() {
-  const amount = ethers.utils.parseUnits('1', 6).toString(); // 1 USDC
-
-  const deltaPrice = await deltaSDK.getDeltaPriceV2({
-    srcToken: USDC_TOKEN,
-    destToken: DAI_TOKEN,
-    amount,
-    userAddress: account,
-    srcDecimals: 6,
-    destDecimals: 18,
-  });
-
-  const HANDLER = '0xb4a2c36668cf8b19fe08f263e3685a5e16e82912'; // handler contract
-  const HANDLER_DATA =
-    '0x0000000000000000000000000000000000000000000000000000000000000000'; // handler-specific encoded bytes
-
-  const builtOrder = await deltaSDK.buildExternalDeltaOrderV2({
-    route: deltaPrice.route,
-    side: deltaPrice.side,
-    owner: account,
-    handler: HANDLER,
-    data: HANDLER_DATA,
-    slippage: 50,
-  });
-
-  const signature = await deltaSDK.signDeltaOrderV2(builtOrder);
-
-  const deltaAuction = await deltaSDK.postExternalDeltaOrderV2({
-    order: builtOrder.toSign.value as Parameters<
-      typeof deltaSDK.postExternalDeltaOrderV2
-    >[0]['order'],
-    signature,
-  });
-
-  startStatusCheckV2(() => deltaSDK.getDeltaOrderByIdV2(deltaAuction.id));
-}
-
-// TWAP sell splits a total srcAmount into N equal slices executed `interval` seconds apart.
-// The price quote is fetched for a single slice; the server multiplies amounts by numSlices.
-async function twapSellDeltaV2Flow() {
-  const numSlices = 4;
-  const totalSrcAmount = ethers.utils.parseUnits('100', 18).toString(); // 100 DAI total
-  const perSliceAmount = (
-    BigInt(totalSrcAmount) / BigInt(numSlices)
-  ).toString();
-
-  // quote a single slice — route amounts must match floor(totalSrcAmount / numSlices)
-  const deltaPrice = await deltaSDK.getDeltaPriceV2({
-    srcToken: DAI_TOKEN,
-    destToken: USDC_TOKEN,
-    amount: perSliceAmount,
-    userAddress: account,
-    srcDecimals: 18,
-    destDecimals: 6,
-  });
-
-  const tx = await deltaSDK.approveTokenForDelta(totalSrcAmount, DAI_TOKEN);
-  await tx.wait();
-
-  const deltaAuction = await deltaSDK.submitTWAPDeltaOrderV2({
-    onChainOrderType: 'TWAPOrder',
-    route: deltaPrice.route,
-    owner: account,
-    totalSrcAmount,
-    numSlices,
-    interval: 300, // 5 minutes between slices (min 60)
-    slippage: 50,
-  });
-
-  startStatusCheckV2(() => deltaSDK.getDeltaOrderByIdV2(deltaAuction.id));
-}
-
-// Paginated list of a user's orders (v2 returns a { results, pagination } envelope).
-async function listUserOrders() {
-  const page1 = await deltaSDK.getDeltaOrdersV2({
-    userAddress: account,
-    page: 1,
-    limit: 50,
-    // status: ['ACTIVE', 'BRIDGING'],
-    // type: 'MARKET',
-  });
-
-  console.log('orders:', page1.data);
-  console.log('total:', page1.total, 'hasMore:', page1.hasMore);
-}

package/src/examples/helpers/deltaV2.ts

@@ -1,29 +0,0 @@
-import { DeltaOrderV2Response } from '../..';
-
-// v2 status COMPLETED already accounts for destChain bridge settlement
-// (crosschain orders sit in BRIDGING until the destChain leg is done).
-function isCompletedDeltaV2Order(order: DeltaOrderV2Response) {
-  return order.status === 'COMPLETED';
-}
-
-type GetDeltaOrderV2Fn = () => Promise<DeltaOrderV2Response>;
-
-function fetchOrderPeriodically(getDeltaOrder: GetDeltaOrderV2Fn) {
-  const intervalId = setInterval(async () => {
-    const order = await getDeltaOrder();
-    console.log('checks: ', order); // Handle or log the fetched order as needed
-
-    if (isCompletedDeltaV2Order(order)) {
-      clearInterval(intervalId); // Stop interval if completed
-      console.log('Order completed');
-    }
-  }, 3000);
-  console.log('Order Pending');
-  // Return intervalId to enable clearing the interval if needed externally
-  return intervalId;
-}
-
-export function startStatusCheckV2(getDeltaOrder: GetDeltaOrderV2Fn) {
-  const intervalId = fetchOrderPeriodically(getDeltaOrder);
-  setTimeout(() => clearInterval(intervalId), 60000 * 5); // Stop after 5 minutes
-}

package/src/methods/deltaV2/buildDeltaOrderV2.ts

@@ -1,86 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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 };
-};