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

package/src/examples/deltaV2.ts

@@ -1,196 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import axios from 'axios';
-import { ethers, Wallet } from 'ethersV5';
-import {
-  constructPartialSDK,
-  constructEthersContractCaller,
-  constructAxiosFetcher,
-  DeltaV2,
-} 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,
-  },
-  DeltaV2.constructAllDeltaOrdersHandlers
-);
-
-const DAI_TOKEN = '0x6b175474e89094c44da98b954eedeac495271d0f';
-const USDC_TOKEN = '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48';
-
-async function simpleDeltaV2Flow() {
-  const amount = '1000000000000'; // wei
-
-  const deltaPrice = await deltaSDK.getDeltaPrice({
-    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.submitDeltaOrder({
-    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.getDeltaOrderById(deltaAuction.id));
-}
-
-async function manualDeltaV2Flow() {
-  const amount = '1000000000000'; // wei
-
-  const deltaPrice = await deltaSDK.getDeltaPrice({
-    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.buildDeltaOrder({
-    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.signDeltaOrder(builtOrder);
-
-  const deltaAuction = await deltaSDK.postDeltaOrder({
-    // partner: "..." // if available
-    order: builtOrder.toSign.value,
-    signature,
-  });
-
-  // poll if necessary
-  startStatusCheckV2(() => deltaSDK.getDeltaOrderById(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.getDeltaPrice({
-    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.buildExternalDeltaOrder({
-    route: deltaPrice.route,
-    side: deltaPrice.side,
-    owner: account,
-    handler: HANDLER,
-    data: HANDLER_DATA,
-    slippage: 50,
-  });
-
-  const signature = await deltaSDK.signDeltaOrder(builtOrder);
-
-  const deltaAuction = await deltaSDK.postExternalDeltaOrder({
-    order: builtOrder.toSign.value,
-    signature,
-  });
-
-  startStatusCheckV2(() => deltaSDK.getDeltaOrderById(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.getDeltaPrice({
-    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.submitTWAPDeltaOrder({
-    onChainOrderType: 'TWAPOrder',
-    route: deltaPrice.route,
-    owner: account,
-    totalSrcAmount,
-    numSlices,
-    interval: 300, // 5 minutes between slices (min 60)
-    slippage: 50,
-  });
-
-  startStatusCheckV2(() => deltaSDK.getDeltaOrderById(deltaAuction.id));
-}
-
-// Paginated list of a user's orders (v2 returns a { results, pagination } envelope).
-async function listUserOrders() {
-  const page1 = await deltaSDK.getDeltaOrders({
-    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,34 +0,0 @@
-import { DeltaV2 } from '../..';
-
-// v2 status COMPLETED already accounts for destChain bridge settlement
-// (crosschain orders sit in BRIDGING until the destChain leg is done).
-function isCompletedDeltaV2Order(order: DeltaV2.DeltaAuction) {
-  return order.status === 'COMPLETED';
-}
-
-type GetDeltaOrderV2Fn = () => Promise<DeltaV2.DeltaAuction>;
-
-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);
-  const timeoutId = setTimeout(() => clearInterval(intervalId), 60000 * 5); // Stop after 5 minutes
-
-  return () => {
-    clearInterval(intervalId);
-    clearTimeout(timeoutId);
-  };
-}

package/src/methods/deltaV2/buildDeltaOrder.ts

@@ -1,86 +0,0 @@
-import { API_URL } from '../../constants';
-import type { ConstructFetchInput, RequestParameters } from '../../types';
-import type { DeltaAuctionOrder } from '../delta/helpers/types';
-import type { BuiltDeltaOrder, DeltaRoute } from './types';
-export type { BuiltDeltaOrder } from './types';
-
-export type BuildDeltaOrderParams = {
-  /** @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 getDeltaPrice — either price.route or any price.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 BuildDeltaOrder = (
-  buildOrderParams: BuildDeltaOrderParams,
-  requestParams?: RequestParameters
-) => Promise<BuiltDeltaOrder<DeltaAuctionOrder>>;
-
-export type BuildDeltaOrderFunctions = {
-  /** @description Build a Delta v2 order from a DeltaRoute via the server endpoint, ready to sign and post. */
-  buildDeltaOrder: BuildDeltaOrder;
-};
-
-export const constructBuildDeltaOrder = (
-  options: ConstructFetchInput
-): BuildDeltaOrderFunctions => {
-  const { apiURL = API_URL, fetcher } = options;
-  const buildUrl = `${apiURL}/delta/v2/orders/build` as const;
-
-  const buildDeltaOrder: BuildDeltaOrder = async (params, requestParams) =>
-    fetcher<BuiltDeltaOrder<DeltaAuctionOrder>>({
-      url: buildUrl,
-      method: 'POST',
-      data: {
-        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 { buildDeltaOrder };
-};

package/src/methods/deltaV2/buildExternalDeltaOrder.ts

@@ -1,95 +0,0 @@
-import { API_URL } from '../../constants';
-import type { ConstructFetchInput, RequestParameters } from '../../types';
-import type { ExternalDeltaOrder } from '../delta/helpers/types';
-import type { BuiltDeltaOrder, DeltaRoute } from './types';
-export type { BuiltDeltaOrder } from './types';
-
-export type BuildExternalDeltaOrderParams = {
-  /** @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 getDeltaPrice */
-  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 BuildExternalDeltaOrder = (
-  buildOrderParams: BuildExternalDeltaOrderParams,
-  requestParams?: RequestParameters
-) => Promise<BuiltDeltaOrder<ExternalDeltaOrder>>;
-
-export type BuildExternalDeltaOrderFunctions = {
-  /** @description Build a Delta v2 External Order from a DeltaRoute via the server endpoint, ready to sign and post. */
-  buildExternalDeltaOrder: BuildExternalDeltaOrder;
-};
-
-export const constructBuildExternalDeltaOrder = (
-  options: ConstructFetchInput
-): BuildExternalDeltaOrderFunctions => {
-  const { apiURL = API_URL, fetcher } = options;
-  const buildUrl = `${apiURL}/delta/v2/orders/build` as const;
-
-  const buildExternalDeltaOrder: BuildExternalDeltaOrder = async (
-    params,
-    requestParams
-  ) =>
-    fetcher<BuiltDeltaOrder<ExternalDeltaOrder>>({
-      url: buildUrl,
-      method: 'POST',
-      data: {
-        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 { buildExternalDeltaOrder };
-};

package/src/methods/deltaV2/buildTWAPDeltaOrder.ts

@@ -1,131 +0,0 @@
-import { API_URL } from '../../constants';
-import type { ConstructFetchInput, RequestParameters } from '../../types';
-import type { TWAPBuyDeltaOrder, TWAPDeltaOrder } from '../delta/helpers/types';
-import type { BuiltDeltaOrder, DeltaRoute } from './types';
-export type { BuiltDeltaOrder } from './types';
-
-type BuildTWAPDeltaOrderBase = {
-  /** @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 getDeltaPrice 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 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 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;
-  /** @description Maximum source token amount willing to spend across all slices. */
-  maxSrcAmount: string;
-};
-
-export type BuildTWAPDeltaOrderParams =
-  | BuildTWAPSellDeltaOrderParams
-  | BuildTWAPBuyDeltaOrderParams;
-
-type BuildTWAPDeltaOrder = (
-  buildOrderParams: BuildTWAPDeltaOrderParams,
-  requestParams?: RequestParameters
-) => Promise<BuiltDeltaOrder<TWAPDeltaOrder | TWAPBuyDeltaOrder>>;
-
-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. */
-  buildTWAPDeltaOrder: BuildTWAPDeltaOrder;
-};
-
-export const constructBuildTWAPDeltaOrder = (
-  options: ConstructFetchInput
-): BuildTWAPDeltaOrderFunctions => {
-  const { apiURL = API_URL, fetcher } = options;
-  const buildUrl = `${apiURL}/delta/v2/orders/build` as const;
-
-  const buildTWAPDeltaOrder: BuildTWAPDeltaOrder = async (
-    params,
-    requestParams
-  ) => {
-    const commonBody = {
-      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<BuiltDeltaOrder<TWAPDeltaOrder>>({
-        url: buildUrl,
-        method: 'POST',
-        data: {
-          ...commonBody,
-          side: 'SELL',
-          orderType: 'TWAPOrder',
-          totalSrcAmount: params.totalSrcAmount,
-        },
-        requestParams,
-      });
-    }
-
-    return fetcher<BuiltDeltaOrder<TWAPBuyDeltaOrder>>({
-      url: buildUrl,
-      method: 'POST',
-      data: {
-        ...commonBody,
-        side: 'BUY',
-        orderType: 'TWAPBuyOrder',
-        totalDestAmount: params.totalDestAmount,
-        maxSrcAmount: params.maxSrcAmount,
-      },
-      requestParams,
-    });
-  };
-
-  return { buildTWAPDeltaOrder };
-};

package/src/methods/deltaV2/cancelDeltaOrder.ts

@@ -1,100 +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 SignCancelDeltaOrderRequest = (
-  params: CancelDeltaOrderData,
-  requestParams?: RequestParameters
-) => Promise<string>;
-
-export type PostCancelDeltaOrderRequest = (
-  params: CancelDeltaOrderRequestParams,
-  requestParams?: RequestParameters
-) => Promise<SuccessResponse>;
-
-export type CancelDeltaOrder = (
-  params: CancelDeltaOrderData,
-  requestParams?: RequestParameters
-) => Promise<SuccessResponse>;
-
-export type CancelDeltaOrderFunctions = {
-  signCancelDeltaOrderRequest: SignCancelDeltaOrderRequest;
-  postCancelDeltaOrderRequest: PostCancelDeltaOrderRequest;
-  /** @description Cancel one or more Delta orders via the v2 endpoint */
-  cancelDeltaOrders: CancelDeltaOrder;
-};
-
-export const constructCancelDeltaOrder = (
-  options: Pick<
-    ConstructProviderFetchInput<any, 'signTypedDataCall'>,
-    'contractCaller' | 'fetcher' | 'apiURL' | 'chainId'
-  >
-): CancelDeltaOrderFunctions => {
-  const apiURL = options.apiURL ?? API_URL;
-
-  const { getDeltaContract } = constructGetDeltaContract(options);
-
-  const signCancelDeltaOrderRequest: SignCancelDeltaOrderRequest = 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 postCancelDeltaOrderRequest: PostCancelDeltaOrderRequest = async (
-    params,
-    requestParams
-  ) => {
-    const cancelUrl = `${apiURL}/delta/v2/orders/cancel` as const;
-
-    return options.fetcher<SuccessResponse>({
-      url: cancelUrl,
-      method: 'POST',
-      data: params,
-      requestParams,
-    });
-  };
-
-  const cancelDeltaOrders: CancelDeltaOrder = async (
-    { orderIds },
-    requestParams
-  ) => {
-    const signature = await signCancelDeltaOrderRequest(
-      { orderIds },
-      requestParams
-    );
-
-    return postCancelDeltaOrderRequest({ orderIds, signature }, requestParams);
-  };
-
-  return {
-    signCancelDeltaOrderRequest,
-    postCancelDeltaOrderRequest,
-    cancelDeltaOrders,
-  };
-};

package/src/methods/deltaV2/getAgentsList.ts

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