@luxexchange/api 1.0.1 → 1.0.3

package/src/clients/trading/__generated__/services/DefaultService.ts

@@ -1,46 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { PlanResponse } from '../models/PlanResponse';
-import type { UpdatePlanRequest } from '../models/UpdatePlanRequest';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class DefaultService {
-    /**
-     * Update an existing plan with step proofs
-     * Updates an existing execution plan by submitting proof of completed plan steps (transaction hashes or signatures). The endpoint retrieves the existing plan, attaches proofs to specified steps, verifies the proofs, and potentially regenerates remaining steps if needed. Returns the full updated plan with current status. Note: Order IDs are not accepted in requests; they are system-generated after receiving a signature.
-     * @returns PlanResponse Update plan successful.
-     * @throws ApiError
-     */
-    public static updatePlan({
-        planId,
-        requestBody,
-    }: {
-        /**
-         * The unique identifier of the plan to update.
-         */
-        planId: string,
-        requestBody?: UpdatePlanRequest,
-    }): CancelablePromise<PlanResponse> {
-        return __request(OpenAPI, {
-            method: 'PATCH',
-            url: '/plan/{planId}',
-            path: {
-                'planId': planId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. No quotes available or Gas fee/price not available`,
-                422: `UnprocessableEntity eg. Plan is already completed and cannot be updated.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-}

package/src/clients/trading/__generated__/services/IndicativeQuoteService.ts

@@ -1,39 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { IndicativeQuoteRequest } from '../models/IndicativeQuoteRequest';
-import type { IndicativeQuoteResponse } from '../models/IndicativeQuoteResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class IndicativeQuoteService {
-    /**
-     * @deprecated
-     * Get an indicative quote
-     * Deprecated. Instead, use the /quote endpoint and specify the `routingPreference` parameter.  with value of `FASTEST`. See the Token Trading Workflow page for more details.
-     *
-     * This endpoint receives a fast indicative quote according to the provided details. The quote will not include any gas or fee information.
-     * @returns IndicativeQuoteResponse Indicative quote request successful.
-     * @throws ApiError
-     */
-    public static indicativeQuote({
-        requestBody,
-    }: {
-        requestBody?: IndicativeQuoteRequest,
-    }): CancelablePromise<IndicativeQuoteResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/indicative_quote',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                404: `ResourceNotFound eg. No quotes available or Gas fee/price not available`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-}

package/src/clients/trading/__generated__/services/LimitOrderQuoteService.ts

@@ -1,37 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { LimitOrderQuoteRequest } from '../models/LimitOrderQuoteRequest';
-import type { LimitOrderQuoteResponse } from '../models/LimitOrderQuoteResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class LimitOrderQuoteService {
-    /**
-     * Get a limit order quote
-     * Get a quote for a limit order according to the provided configuration.
-     * @returns LimitOrderQuoteResponse Limit Order Quote request successful.
-     * @throws ApiError
-     */
-    public static getLimitOrderQuote({
-        requestBody,
-    }: {
-        requestBody?: LimitOrderQuoteRequest,
-    }): CancelablePromise<LimitOrderQuoteResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/limit_order_quote',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. No quotes available or Gas fee/price not available`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-}

package/src/clients/trading/__generated__/services/LiquidityService.ts

@@ -1,239 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { CheckApprovalLPRequest } from '../models/CheckApprovalLPRequest';
-import type { CheckApprovalLPResponse } from '../models/CheckApprovalLPResponse';
-import type { ClaimLPFeesRequest } from '../models/ClaimLPFeesRequest';
-import type { ClaimLPFeesResponse } from '../models/ClaimLPFeesResponse';
-import type { ClaimLPRewardsRequest } from '../models/ClaimLPRewardsRequest';
-import type { ClaimLPRewardsResponse } from '../models/ClaimLPRewardsResponse';
-import type { CreateLPPositionRequest } from '../models/CreateLPPositionRequest';
-import type { CreateLPPositionResponse } from '../models/CreateLPPositionResponse';
-import type { DecreaseLPPositionRequest } from '../models/DecreaseLPPositionRequest';
-import type { DecreaseLPPositionResponse } from '../models/DecreaseLPPositionResponse';
-import type { IncreaseLPPositionRequest } from '../models/IncreaseLPPositionRequest';
-import type { IncreaseLPPositionResponse } from '../models/IncreaseLPPositionResponse';
-import type { MigrateLPPositionRequest } from '../models/MigrateLPPositionRequest';
-import type { MigrateLPPositionResponse } from '../models/MigrateLPPositionResponse';
-import type { PoolInfoRequest } from '../models/PoolInfoRequest';
-import type { PoolInfoResponse } from '../models/PoolInfoResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class LiquidityService {
-    /**
-     * Check if tokens and permits need to be approved to add liquidity
-     * Checks if the wallet address has the required approvals. If the wallet address does not have the required approval, then the response will include the transactions to approve the tokens. If the wallet address has the required approval, then the response will be empty for the corresponding tokens. If the parameter `simulateTransaction` is set to `true`, then the response will include the gas fees for the approval transactions.
-     *
-     * Note that approval is required for both creating and removing positions in V2 pools. Approval is only required for creating positions in V3 and V4 pools.
-     * @returns CheckApprovalLPResponse Approve LP successful.
-     * @throws ApiError
-     */
-    public static checkApprovalLp({
-        requestBody,
-    }: {
-        requestBody?: CheckApprovalLPRequest,
-    }): CancelablePromise<CheckApprovalLPResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/lp/approve',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. Token allowance not found or Gas info not found.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-    /**
-     * Create pool and position calldata
-     * This request allows the caller to create a position in a pool or, if the pool does not yet exist, to create a new pool. If a new pool must be created, a transaction is returned for the pool creation. In either case, a transaction is returned to create the new position in the pool. If the parameter `simulateTransaction` is set to true, then the response will include the gas fee for the creation transaction(s).
-     *
-     * Different fields are required depending on the pool version (V2, V3, or V4) into which a new position will be created, in addition to the fields which are always required. When creating a position in a V2 pool, the `position` object must contain token0 and token1 addresses. When creating a position in a V3 pool, the `position` object must contain all fields except for `hooks` which are not supported in V3 pools. When creating a position in a V4 pool, all fields within the `position` object are required except for `hooks` which is optional. Note that both V3 and V4 pools require the population of `tickLower` and `tickUpper` fields. Furthermore, `poolLiquidity`, `currentTick`, and `sqrtRatioX96` are always required when creating a position in a V3 or V4 pool. All pool versions require the population of `amount0` and `amount1`, which specify the quantity of tokens being entered into the pool.
-     *
-     * When creating a pool, additional fields are required depending on the pool version being created, in addition to the fields which are always required. When creating a V3 or V4 pool, either `initialPrice` or `poolLiquidity`, `currentTick`, and `sqrtRatioX96` are required. When creating a V2 pool, only `initialPrice` is required. V3 and V4 pools require `amount0` and `amount1` fields to be populated, as the creation of the pool must include seeding of liquidity. V2 pools may optionally have `amount0` and `amount1` populated; V2 pools do not require liquidity to be seeded when creating the pool.
-     * @returns CreateLPPositionResponse Create LP Position successful.
-     * @throws ApiError
-     */
-    public static createLpPosition({
-        requestBody,
-    }: {
-        requestBody?: CreateLPPositionRequest,
-    }): CancelablePromise<CreateLPPositionResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/lp/create',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. Cant Find LP Position.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-    /**
-     * Increase LP position calldata
-     * The response will also have the transaction to increase the position for the corresponding pool. If the parameter `simulateTransaction` is set to `true`, then the response will include the gas fees for the increase transaction.
-     * @returns IncreaseLPPositionResponse Create LP Position successful.
-     * @throws ApiError
-     */
-    public static increaseLpPosition({
-        requestBody,
-    }: {
-        requestBody?: IncreaseLPPositionRequest,
-    }): CancelablePromise<IncreaseLPPositionResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/lp/increase',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. Cant Find LP Position.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-    /**
-     * Decrease LP position calldata
-     * The response will also have the transaction to decrease the position for the corresponding pool. If the parameter `simulateTransaction` is set to `true`, then the response will include the gas fees for the decrease transaction.
-     * @returns DecreaseLPPositionResponse Decrease LP Position successful.
-     * @throws ApiError
-     */
-    public static decreaseLpPosition({
-        requestBody,
-    }: {
-        requestBody?: DecreaseLPPositionRequest,
-    }): CancelablePromise<DecreaseLPPositionResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/lp/decrease',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. Cant Find LP Position.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-    /**
-     * Claim LP fees calldata
-     * The response will also have the transaction to claim the fees for an LP position for the corresponding pool. If the parameter `simulateTransaction` is set to `true`, then the response will include the gas fees for the claim transaction.
-     * @returns ClaimLPFeesResponse Claim LP Fees successful.
-     * @throws ApiError
-     */
-    public static claimLpFees({
-        requestBody,
-    }: {
-        requestBody?: ClaimLPFeesRequest,
-    }): CancelablePromise<ClaimLPFeesResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/lp/claim',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. Cant Find LP Position.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-    /**
-     * Migrate LP position calldata
-     * The response will also have the transaction to migrate the position for the corresponding pool. If the parameter `simulateTransaction` is set to `true`, then the response will include the gas fees for the migrate transaction.
-     * @returns MigrateLPPositionResponse Migrate LP Position successful.
-     * @throws ApiError
-     */
-    public static migrateLpPosition({
-        requestBody,
-    }: {
-        requestBody?: MigrateLPPositionRequest,
-    }): CancelablePromise<MigrateLPPositionResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/lp/migrate',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. Cant Find LP Position.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-    /**
-     * Claim LP rewards calldata
-     * The response will have the transaction to claim the rewards. If the parameter `simulateTransaction` is set to `true`, then the response will include the gas fees for the claim transaction.
-     * @returns ClaimLPRewardsResponse Claim LP Rewards successful.
-     * @throws ApiError
-     */
-    public static claimLpRewards({
-        requestBody,
-    }: {
-        requestBody?: ClaimLPRewardsRequest,
-    }): CancelablePromise<ClaimLPRewardsResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/lp/claim_rewards',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. No rewards found for wallet on given chain`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-    /**
-     * Fetch Pool Information
-     * Given either a pair address/pool address/pool Id return all the details pertaining to the pool.
-     * @returns PoolInfoResponse Pool information response successful.
-     * @throws ApiError
-     */
-    public static poolInfo({
-        requestBody,
-    }: {
-        requestBody?: PoolInfoRequest,
-    }): CancelablePromise<PoolInfoResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/lp/pool_info',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. No pool information on given chain`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-}

package/src/clients/trading/__generated__/services/OrderService.ts

@@ -1,131 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { Address } from '../models/Address';
-import type { GetOrdersResponse } from '../models/GetOrdersResponse';
-import type { orderId } from '../models/orderId';
-import type { OrderIds } from '../models/OrderIds';
-import type { OrderRequest } from '../models/OrderRequest';
-import type { OrderResponse } from '../models/OrderResponse';
-import type { OrderStatus } from '../models/OrderStatus';
-import type { OrderTypeQuery } from '../models/OrderTypeQuery';
-import type { SortKey } from '../models/SortKey';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class OrderService {
-    /**
-     * Create a gasless order
-     * The order endpoint is used to submit a DEX intent. If the `routing` field in the response to a quote is any of `DUTCH_V2`, `DUTCH_V3`, `LIMIT_ORDER`, or `PRIORITY` this endpoint is used to submit your order to the DEX protocol to be filled by the filler network. These orders are gasless because the filler will pay the gas to complete the transaction.
-     *
-     * The order will be validated and, if valid, will be submitted to the filler network. The network will try to fill the order at the quoted `startAmount`. If the order is not filled at the `startAmount` by the `deadline`, the amount will start decaying until the `endAmount` is reached. The order will remain `open` until it is either filled, canceled, or has expired by remaining unfilled beyond the `decayEndTime`.
-     *
-     * For simplicity, the order request is identical to the quote response except for the addition of the signed permit.
-     *
-     * Native ETH on DEX: If the quote you are submitting uses native ETH as the input token (e.g. `tokenIn` is `0x0000000000000000000000000000000000000000`), include `x-erc20eth-enabled: true`. Native ETH input on DEX requires wallet support for EIP-7914 and sufficient native allowance. For 7702-delegated smart contract wallets, you can generate the required approval call(s) via `/swap_7702` when needed.
-     * @returns OrderResponse Encoded order submitted.
-     * @throws ApiError
-     */
-    public static postOrder({
-        xErc20EthEnabled = false,
-        requestBody,
-    }: {
-        /**
-         * Enable native ETH input support for DEX via ERC20-ETH (EIP-7914). When set to true and `tokenIn` is the native currency address (e.g. `0x0000000000000000000000000000000000000000`), the API may return DEX routes that spend native ETH for supported wallets.
-         */
-        xErc20EthEnabled?: boolean,
-        requestBody?: OrderRequest,
-    }): CancelablePromise<OrderResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/order',
-            headers: {
-                'x-erc20eth-enabled': xErc20EthEnabled,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-    /**
-     * Get gasless orders
-     * Retrieve one or more gasless orders filtered, optionally filered by query param(s). The request must at minimum include one of the following parameters: `orderId`, `orderIds`, `orderStatus`, `swapper`, or `filler`.
-     * @returns GetOrdersResponse The request orders matching the query parameters.
-     * @throws ApiError
-     */
-    public static getOrder({
-        orderType,
-        orderId,
-        orderIds,
-        limit,
-        orderStatus,
-        swapper,
-        sortKey,
-        sort,
-        filler,
-        cursor,
-    }: {
-        /**
-         * The default orderType is Dutch_V1_V2 and will grab both Dutch and Dutch_V2 orders.
-         */
-        orderType?: OrderTypeQuery,
-        orderId?: orderId,
-        /**
-         * A list of comma separated orderIds.
-         */
-        orderIds?: OrderIds,
-        limit?: number,
-        /**
-         * Filter by order status.
-         */
-        orderStatus?: OrderStatus,
-        /**
-         * Filter by swapper address.
-         */
-        swapper?: Address,
-        /**
-         * Order the query results by the sort key.
-         */
-        sortKey?: SortKey,
-        /**
-         * Sort query. For example: `sort=gt(UNIX_TIMESTAMP)`, `sort=between(1675872827, 1675872930)`, or `lt(1675872930)`.
-         */
-        sort?: string,
-        /**
-         * Filter by filler address.
-         */
-        filler?: Address,
-        cursor?: string,
-    }): CancelablePromise<GetOrdersResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/orders',
-            query: {
-                'orderType': orderType,
-                'orderId': orderId,
-                'orderIds': orderIds,
-                'limit': limit,
-                'orderStatus': orderStatus,
-                'swapper': swapper,
-                'sortKey': sortKey,
-                'sort': sort,
-                'filler': filler,
-                'cursor': cursor,
-            },
-            errors: {
-                400: `RequestValidationError eg. Token allowance not valid or Insufficient Funds.`,
-                404: `Orders not found.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-}

package/src/clients/trading/__generated__/services/PlanService.ts

@@ -1,76 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { CreatePlanRequest } from '../models/CreatePlanRequest';
-import type { PlanResponse } from '../models/PlanResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class PlanService {
-    /**
-     * Create an execution plan
-     * Creates a multi-step execution plan for chained transactions. The plan breaks down complex multi-chain or multi-transaction flows into sequential steps that can be executed by the client. Each step includes the method (transaction, message signature, or batch calls), payload, and current status. The response includes the current step index to track progress through the plan.
-     * @returns PlanResponse Create plan successful.
-     * @throws ApiError
-     */
-    public static createPlan({
-        requestBody,
-    }: {
-        requestBody?: CreatePlanRequest,
-    }): CancelablePromise<PlanResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/plan',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. No quotes available or Gas fee/price not available`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-    /**
-     * Get an execution plan
-     * Retrieves an existing execution plan by its ID. Returns the full plan with current status and all steps. If forceRefresh is set to true, the plan will be refreshed to check for any updates to step statuses. Note: Completed plans cannot be refreshed.
-     * @returns PlanResponse Get plan successful.
-     * @throws ApiError
-     */
-    public static getPlan({
-        planId,
-        forceRefresh,
-    }: {
-        /**
-         * The unique identifier of the plan to retrieve.
-         */
-        planId: string,
-        /**
-         * Whether to force refresh the plan status. Defaults to false. Completed plans cannot be refreshed.
-         */
-        forceRefresh?: boolean,
-    }): CancelablePromise<PlanResponse> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/plan/{planId}',
-            path: {
-                'planId': planId,
-            },
-            query: {
-                'forceRefresh': forceRefresh,
-            },
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. No quotes available or Gas fee/price not available`,
-                422: `UnprocessableEntity eg. Plan is already completed and cannot be updated.`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-}

package/src/clients/trading/__generated__/services/QuoteService.ts

@@ -1,58 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { QuoteRequest } from '../models/QuoteRequest';
-import type { QuoteResponse } from '../models/QuoteResponse';
-import type { UniversalRouterVersion } from '../models/UniversalRouterVersion';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class QuoteService {
-    /**
-     * Get a quote
-     * Requests a quote according to the specified swap parameters. This endpoint may be used to get a quote for a swap, a bridge, or a wrap/unwrap. The resulting response includes a quote for the swap and the proposed route by which the quote was achieved. The response will also include estimated gas fees for the proposed quote route. If the proposed route is via a Lux Protocol pool, the response may include a permit2 message for the swapper to sign prior to making a /swap request. The proposed route will also be simulated. If the simulation fails, the response will include an error message or `txFailureReason`.
-     *
-     * Certain routing options may be whitelisted by the requestor through the use of the `protocols` field. Further, the requestor may ask for the best price route or for the fastest price route through the 'routingPreference' field. Note that the fastest price route refers to the speed with which a quote is returned, not the number of transactions that may be required to get from the input token and chain to the output token and chain. Further note that all `routingPreference` values except for `FASTEST` and `BEST_PRICE` are deprecated. For more information on the `protocols` and `routingPreference` fields, see the [Token Trading Workflow](https://lux-docs.readme.io/reference/trading-flow#swap-routing) explanation of Swap Routing.
-     *
-     * API integrators using this API for the benefit of customer end users may request a service fee be taken from the output token and deposited to a fee collection address. To request this, please reach out to your Lux Industries contact. This optional fee is associated to the API key and is always taken from the output token. Note if there is a fee and the `type` is `EXACT_INPUT`, the output amount quoted will **not** include the fee subtraction. If there is a fee and the `type` is `EXACT_OUTPUT`, the input amount quoted will **not** include the fee addition. Instead, in both cases, the fee will be recorded in the `portionBips` and `portionAmount` fields.
-     *
-     * Native ETH on DEX: DEX routes (e.g. `DUTCH_V2`, `DUTCH_V3`, `PRIORITY`) can use native ETH as the input token by setting `tokenIn` to the native currency address (e.g. `0x0000000000000000000000000000000000000000`) and passing `x-erc20eth-enabled: true`. Native ETH input on DEX requires wallet support for EIP-7914, a smart wallet activated on your desired network, and a sufficient native allowance (set via /swap_7702 if x-erc20eth-enabled header is set to `true`). If these requirements are not met, DEX quotes for native input may be omitted and the response may fall back to `CLASSIC` routing instead.
-     * @returns QuoteResponse Quote request successful.
-     * @throws ApiError
-     */
-    public static aggregatorQuote({
-        xUniversalRouterVersion,
-        xErc20EthEnabled = false,
-        requestBody,
-    }: {
-        /**
-         * The version of the Universal Router to use for the swap journey. *MUST* be consistent throughout the API calls.
-         */
-        xUniversalRouterVersion?: UniversalRouterVersion,
-        /**
-         * Enable native ETH input support for DEX via ERC20-ETH (EIP-7914). When set to true and `tokenIn` is the native currency address (e.g. `0x0000000000000000000000000000000000000000`), the API may return DEX routes that spend native ETH for supported wallets.
-         */
-        xErc20EthEnabled?: boolean,
-        requestBody?: QuoteRequest,
-    }): CancelablePromise<QuoteResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/quote',
-            headers: {
-                'x-universal-router-version': xUniversalRouterVersion,
-                'x-erc20eth-enabled': xErc20EthEnabled,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. No quotes available or Gas fee/price not available`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-}

package/src/clients/trading/__generated__/services/SendService.ts

@@ -1,37 +0,0 @@
-/* generated using openapi-typescript-codegen -- do no edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-import type { CreateSendRequest } from '../models/CreateSendRequest';
-import type { CreateSendResponse } from '../models/CreateSendResponse';
-import type { CancelablePromise } from '../core/CancelablePromise';
-import { OpenAPI } from '../core/OpenAPI';
-import { request as __request } from '../core/request';
-export class SendService {
-    /**
-     * Create send calldata
-     * This endpoint will generate a calldata for a send transaction based on the inputs. The calldata may be signed by the `sender` to cause the specified `amount` of the `token` to be transfered from the `sender` to the `recipient`. The successful response always includes estimated gas for the transaction.
-     * @returns CreateSendResponse Create send successful.
-     * @throws ApiError
-     */
-    public static createSend({
-        requestBody,
-    }: {
-        requestBody?: CreateSendRequest,
-    }): CancelablePromise<CreateSendResponse> {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/send',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                400: `RequestValidationError, Bad Input`,
-                401: `UnauthorizedError eg. Account is blocked.`,
-                404: `ResourceNotFound eg. Gas fee not available`,
-                429: `Ratelimited`,
-                500: `Unexpected error`,
-                504: `Request duration limit reached.`,
-            },
-        });
-    }
-}