@carbon-terminal/trading-sdk 0.2.5

package/dist/entities/position-entity.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositionEntity = exports.PositionEntityHooks = void 0;
+const core_1 = require("@carbon-terminal/core");
+const hookable_entity_1 = require("./library/hookable-entity");
+var PositionEntityHooks;
+(function (PositionEntityHooks) {
+    PositionEntityHooks["OPEN_PRICE_SETTLED"] = "open-price-settled";
+    PositionEntityHooks["OPEN_REJECTED"] = "open-rejected";
+    PositionEntityHooks["OPEN_SUCCESS"] = "open-success";
+    PositionEntityHooks["RESERVED"] = "reserved";
+    PositionEntityHooks["EXPIRED"] = "expired";
+})(PositionEntityHooks || (exports.PositionEntityHooks = PositionEntityHooks = {}));
+class PositionEntity extends hookable_entity_1.HookableEntity {
+    constructor(tradingSdk, position) {
+        super();
+        this.tradingSdk = tradingSdk;
+        this.internalPosition = position;
+    }
+    getStatus() {
+        return this.internalPosition.status;
+    }
+    getDetails() {
+        return this.internalPosition;
+    }
+    async update() {
+        const positionInfo = await this.tradingSdk.tradeManager.getPositionInfo(this.internalPosition.tempId?.toString() ??
+            this.internalPosition.id.toString(), this.internalPosition.chainId);
+        this.internalPosition = positionInfo;
+        if (this.internalPosition.avgOpenFillPrice &&
+            this.internalPosition.openFillQuantity) {
+            if (this.lastFillQuantity !== this.internalPosition.openFillQuantity) {
+                this.lastFillQuantity = this.internalPosition.openFillQuantity;
+                this.trigger(PositionEntityHooks.OPEN_PRICE_SETTLED, this.internalPosition);
+            }
+        }
+        else if (this.internalPosition.status === core_1.PositionStatus.FAILED) {
+            if (!this.isHookTriggered(PositionEntityHooks.OPEN_REJECTED)) {
+                this.trigger(PositionEntityHooks.OPEN_REJECTED, this.internalPosition);
+            }
+        }
+        else if (this.internalPosition.status === core_1.PositionStatus.OPENED) {
+            if (!this.isHookTriggered(PositionEntityHooks.OPEN_SUCCESS)) {
+                this.trigger(PositionEntityHooks.OPEN_SUCCESS, this.internalPosition);
+            }
+        }
+        else if (this.internalPosition.status === core_1.PositionStatus.LOCKED) {
+            if (!this.isHookTriggered(PositionEntityHooks.RESERVED)) {
+                this.trigger(PositionEntityHooks.RESERVED, this.internalPosition);
+            }
+        }
+        else if (this.internalPosition.status === core_1.PositionStatus.EXPIRED) {
+            if (!this.isHookTriggered(PositionEntityHooks.EXPIRED)) {
+                this.trigger(PositionEntityHooks.EXPIRED, this.internalPosition);
+            }
+        }
+        return this.internalPosition;
+    }
+    isConfirmedOnChain() {
+        return this.internalPosition.status === core_1.PositionStatus.OPENED;
+    }
+    isPriceSettled() {
+        return (this.internalPosition.avgOpenFillPrice ||
+            this.internalPosition.status === core_1.PositionStatus.OPENED);
+    }
+    isFailed() {
+        return this.internalPosition.status === core_1.PositionStatus.FAILED;
+    }
+    // Trading functions
+    async close(quantityToClose, closePrice, orderType) {
+        if (this.internalPosition.status === core_1.PositionStatus.INSTANT_OPEN_SENT) {
+            throw new Error("The position can't be closed before it's confirmed on-chain");
+        }
+        if (this.internalPosition.status !== core_1.PositionStatus.OPENED) {
+            throw new Error("Position is not opened");
+        }
+        if (!this.internalPosition.id ||
+            isNaN(Number(this.internalPosition.id)) ||
+            Number(this.internalPosition.id < 0)) {
+            throw new Error("Position is not suitable for close (id not found)");
+        }
+        const closeResult = await this.tradingSdk.tradeManager.closePosition({
+            quoteId: this.internalPosition.id,
+            quantityToClose: quantityToClose,
+            chainId: this.internalPosition.chainId,
+            orderType,
+        });
+        return closeResult;
+    }
+    // Hookability
+    async waitForCompletion() {
+        while (this.internalPosition.status !== core_1.PositionStatus.OPENED &&
+            this.internalPosition.status !== core_1.PositionStatus.FAILED
+        // this.internalPosition.status !== PositionStatus.LOCKED
+        ) {
+            await this.update();
+            // 3s polling
+            await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+    }
+    async waitForOnChainConfirmation() {
+        while (this.internalPosition.status !== core_1.PositionStatus.OPENED &&
+            this.internalPosition.status !== core_1.PositionStatus.FAILED &&
+            this.internalPosition.status !== core_1.PositionStatus.LOCKED) {
+            await this.update();
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+    }
+}
+exports.PositionEntity = PositionEntity;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./client";
+export * from "./common";
+export * from "./entities";

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./entities"), exports);

package/dist/modules/account-manager/index.d.ts

@@ -0,0 +1,9 @@
+import { AccountBalanceDetails, SubaccountDetails } from "@carbon-terminal/core";
+import { TradingSDK } from "src/client";
+export declare class AccountManager {
+    private readonly tradingSdk;
+    constructor(tradingSdk: TradingSDK);
+    listSubaccounts(userAddress: string): Promise<SubaccountDetails[]>;
+    getSubaccountDetails(subaccountAddress: string, chainId: number): Promise<SubaccountDetails>;
+    getSubaccountBalanceDetails(subaccountAddress: string, chainId: number): Promise<AccountBalanceDetails>;
+}

package/dist/modules/account-manager/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountManager = void 0;
+const exceptions_1 = require("../../common/exceptions");
+class AccountManager {
+    constructor(tradingSdk) {
+        this.tradingSdk = tradingSdk;
+    }
+    async listSubaccounts(userAddress) {
+        const response = await this.tradingSdk.get(`/accounts/subaccounts?userAddress=${userAddress}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message || "Failed to list subaccounts",
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getSubaccountDetails(subaccountAddress, chainId) {
+        const response = await this.tradingSdk.get(`/accounts/subaccount/details?subaccountAddress=${subaccountAddress}&chainId=${chainId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message || "Failed to get subaccount details",
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getSubaccountBalanceDetails(subaccountAddress, chainId) {
+        const response = await this.tradingSdk.get(`/accounts/subaccount/balance?subaccountAddress=${subaccountAddress}&chainId=${chainId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message || "Failed to get subaccount balance details",
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+}
+exports.AccountManager = AccountManager;

package/dist/modules/auth-manager/index.d.ts

@@ -0,0 +1,44 @@
+import { AllowedPermission, AvailableSolvers } from "@carbon-terminal/core";
+import { TradingSDK } from "../../client";
+import { ApiKey } from "./types";
+interface EnableInstantActionParams {
+    subaccountAddress: string;
+    chainId: number;
+    solver: AvailableSolvers;
+}
+interface ToggleSubaccountParams {
+    subaccountAddress: string;
+    chainId: number;
+    enable: boolean;
+}
+declare class AuthManager {
+    private tradingSdk;
+    private token;
+    private privateKey;
+    constructor(tradingSdk: TradingSDK);
+    loginWithPrivateKey(privateKey: string): Promise<void>;
+    allowInstantAction(params: EnableInstantActionParams): Promise<void>;
+    toggleSubaccount(params: ToggleSubaccountParams): Promise<void>;
+    createApiKey(): Promise<string>;
+    listApiKeys(): Promise<ApiKey[]>;
+    validateSubaccountAccess(subaccountAddress: string): Promise<{
+        hasAccess: boolean;
+        instantActionAccesses: {
+            solver: AvailableSolvers;
+            expirationTimestamp: number;
+        }[];
+    }>;
+    verifyInstantActionAccess(subaccountAddress: string, solver: AvailableSolvers): Promise<boolean>;
+    /**
+     * Verify that the API key that has been configured to the SDK has access to operate on the account with the given permissions
+     * @param subaccountAddress
+     * @param permissionsToCheck
+     */
+    verifyPermissionsToSubaccount(subaccountAddress: string, permissionsToCheck?: AllowedPermission): Promise<boolean>;
+    validateApiKey(apiKey: string): Promise<{
+        apiKeyIdentifier: string;
+        isValid: boolean;
+    }>;
+    delegateSubaccountApiPermission(subaccountAddress: string, permissions: AllowedPermission[], toApiKeyIdentifier: string): Promise<unknown>;
+}
+export { AuthManager };

package/dist/modules/auth-manager/index.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthManager = void 0;
+const ethers_1 = require("ethers");
+const exceptions_1 = require("../../common/exceptions");
+const getApiUrl_1 = require("../../utils/api/getApiUrl");
+const apiAuth_1 = require("../../utils/auth/apiAuth");
+const siweAuth_1 = require("../../utils/auth/siweAuth");
+class AuthManager {
+    constructor(tradingSdk) {
+        this.tradingSdk = tradingSdk;
+        this.token = null;
+        this.privateKey = null;
+    }
+    async loginWithPrivateKey(privateKey) {
+        this.privateKey = privateKey;
+        const { token } = await (0, apiAuth_1.authenticateWithPrivateKey)((0, getApiUrl_1.getApiUrl)(), privateKey);
+        this.token = token;
+    }
+    async allowInstantAction(params) {
+        if (!this.token)
+            throw new Error("Not authenticated, please, authenticate with private key");
+        if (!this.privateKey)
+            throw new Error("No private key, please, authenticate with private key");
+        const siweSignature = await (0, siweAuth_1.createSiweSignatureWithPrivateKey)(params.subaccountAddress, params.chainId, params.solver, this.privateKey);
+        // Wait 2 seconds to make sure nonce is propagated
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        const siweToken = await (0, siweAuth_1.siweGetAccessToken)(params.subaccountAddress, params.chainId, params.solver, siweSignature);
+        const expirationTimestamp = Math.floor(Date.now() / 1000) + 3600 * 24 * 365;
+        const response = await this.tradingSdk.post("/account-auth/instant-action/token", {
+            subaccountAddress: (0, ethers_1.getAddress)(params.subaccountAddress),
+            chainId: params.chainId,
+            solver: params.solver,
+            token: siweToken,
+            expirationTimestamp,
+        }, {
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+    }
+    async toggleSubaccount(params) {
+        if (!this.token)
+            throw new Error("Not authenticated");
+        const response = await this.tradingSdk.post("/account-auth/subaccount/toggle-access", {
+            subaccountAddress: (0, ethers_1.getAddress)(params.subaccountAddress),
+            chainId: params.chainId,
+            enable: params.enable,
+        }, {
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+    }
+    async createApiKey() {
+        if (!this.token)
+            throw new Error("Not authenticated");
+        const response = await this.tradingSdk.post("/api-keys/create", {
+            name: "API Key",
+        }, {
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data.apiKey;
+    }
+    async listApiKeys() {
+        if (!this.token)
+            throw new Error("Not authenticated with JWT");
+        const response = await this.tradingSdk.get("/api-keys/list", {
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async validateSubaccountAccess(subaccountAddress) {
+        const response = await this.tradingSdk.get("/account-auth/verify?subaccountAddress=" + subaccountAddress, {
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async verifyInstantActionAccess(subaccountAddress, solver) {
+        const response = await this.tradingSdk.get(`/account-auth/verify-instant-action-api-access`, {
+            params: {
+                subaccountAddress,
+                solver,
+            },
+        });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    /**
+     * Verify that the API key that has been configured to the SDK has access to operate on the account with the given permissions
+     * @param subaccountAddress
+     * @param permissionsToCheck
+     */
+    async verifyPermissionsToSubaccount(subaccountAddress, permissionsToCheck) {
+        const response = await this.tradingSdk.post("/api-keys/check-permission", {
+            subaccountAddress,
+            permissionsToCheck,
+        });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async validateApiKey(apiKey) {
+        const response = await this.tradingSdk.post("/api-keys/validate", {
+            apiKey,
+        });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async delegateSubaccountApiPermission(subaccountAddress, permissions, toApiKeyIdentifier) {
+        const response = await this.tradingSdk.post("/account-auth/delegate-access", {
+            subaccountAddress,
+            permissions,
+            apiKeyIdentifier: toApiKeyIdentifier,
+        }, {
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+}
+exports.AuthManager = AuthManager;

package/dist/modules/auth-manager/types.d.ts

@@ -0,0 +1,7 @@
+export interface ApiKey {
+    id: string;
+    name: string;
+    createdAt: string;
+    lastUsedAt: string | null;
+    isActive: boolean;
+}

package/dist/modules/auth-manager/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/markets-manager/index.d.ts

@@ -0,0 +1,23 @@
+import { AggregatedMarketsData, AvailableSolvers, Market, MarketTicker, SupportedChainId } from "@carbon-terminal/core";
+import { TradingSDK } from "src/client";
+export declare class MarketsManager {
+    private tradingSdk;
+    constructor(tradingSdk: TradingSDK);
+    getAggregatedMarkets(chainId: SupportedChainId): Promise<AggregatedMarketsData>;
+    getMarketTickerById(marketId: number, chainId: SupportedChainId): Promise<MarketTicker | null>;
+    getMarketTickerBySymbol(symbol: string, chainId: SupportedChainId): Promise<MarketTicker | null>;
+    getSolverMarketBySymbol(symbol: string, chainId: SupportedChainId, solver: AvailableSolvers): Promise<Market | null>;
+    getSolverMarketById(marketId: number, chainId: SupportedChainId, solver: AvailableSolvers): Promise<Market | null>;
+    getMarkPriceForSymbol(symbol: string): Promise<number>;
+    getLastPriceForSymbol(symbol: string): Promise<number>;
+    getMarkPricesForSymbols(symbols: string[]): Promise<Record<string, number>>;
+    getLastPricesForSymbols(symbols: string[]): Promise<Record<string, number>>;
+    getSolverOpenInterest(solver: AvailableSolvers, chainId: SupportedChainId): Promise<{
+        used: number;
+        total: number;
+    }>;
+    getSolverNotionalCapForMarket(solver: AvailableSolvers, chainId: SupportedChainId, marketId: number): Promise<{
+        used: number;
+        total: number;
+    }>;
+}

package/dist/modules/markets-manager/index.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketsManager = void 0;
+const exceptions_1 = require("../../common/exceptions");
+class MarketsManager {
+    constructor(tradingSdk) {
+        this.tradingSdk = tradingSdk;
+    }
+    async getAggregatedMarkets(chainId) {
+        const response = await this.tradingSdk.get(`/markets/aggregated/${chainId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getMarketTickerById(marketId, chainId) {
+        const response = await this.tradingSdk.get(`/markets/${chainId}/by-id/${marketId}`);
+        if (!response.success) {
+            throw new exceptions_1.NotFoundException(response.error?.message);
+        }
+        return response.data;
+    }
+    async getMarketTickerBySymbol(symbol, chainId) {
+        const response = await this.tradingSdk.get(`/markets/${chainId}/by-symbol/${symbol}`);
+        if (!response.success) {
+            throw new exceptions_1.NotFoundException(response.error?.message);
+        }
+        return response.data;
+    }
+    async getSolverMarketBySymbol(symbol, chainId, solver) {
+        const response = await this.tradingSdk.get(`/markets/${chainId}/solver/${solver}/by-symbol/${symbol}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getSolverMarketById(marketId, chainId, solver) {
+        const response = await this.tradingSdk.get(`/markets/${chainId}/solver/${solver}/by-id/${marketId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getMarkPriceForSymbol(symbol) {
+        const response = await this.tradingSdk.get(`/pricing/mark-price/${symbol}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getLastPriceForSymbol(symbol) {
+        const response = await this.tradingSdk.get(`/pricing/last-price/${symbol}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getMarkPricesForSymbols(symbols) {
+        const response = await this.tradingSdk.get(`/pricing/mark-prices?symbols=${symbols.join(",")}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getLastPricesForSymbols(symbols) {
+        const response = await this.tradingSdk.get(`/pricing/last-prices?symbols=${symbols.join(",")}`);
+        if (!response.success) {
+            throw new exceptions_1.NotFoundException("");
+        }
+        return response.data;
+    }
+    async getSolverOpenInterest(solver, chainId) {
+        const response = await this.tradingSdk.get(`/solvers/open-interest?solver=${solver}&chainId=${chainId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getSolverNotionalCapForMarket(solver, chainId, marketId) {
+        const response = await this.tradingSdk.get(`/solvers/notional-cap?solver=${solver}&chainId=${chainId}&marketId=${marketId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+}
+exports.MarketsManager = MarketsManager;

package/dist/modules/trade-manager/index.d.ts

@@ -0,0 +1,52 @@
+import { AvailableSolvers, CancelCloseRequestState, CancelQuoteRequestState, CloseRequestState, ListTpSlResponse, OrderType, Position, PositionType, SolverLockedParams, SupportedChainId } from "@carbon-terminal/core";
+import { TradingSDK } from "../../client";
+import { CancelCloseRequestEntity, CancelRequestEntity, CloseRequestEntity, PositionEntity } from "../../entities";
+export declare class TradeManager {
+    private readonly tradingSdk;
+    constructor(tradingSdk: TradingSDK);
+    getPositionInfo(positionId: string, chainId: SupportedChainId): Promise<Position>;
+    getOpenPositionsForSubaccount(subaccountAddress: string, chainId: SupportedChainId): Promise<Position[]>;
+    getCloseRequestInfo(closeRequestId: string, chainId: SupportedChainId): Promise<CloseRequestState>;
+    createPosition(params: {
+        marketId: number;
+        subaccountAddress: string;
+        chainId: SupportedChainId;
+        positionType: PositionType;
+        orderType: OrderType;
+        limitPrice?: number;
+        leverage: number;
+        quantity: number;
+        deadline?: number;
+        slippage?: number;
+        solver: AvailableSolvers;
+        useInstantActions?: boolean;
+    }): Promise<PositionEntity>;
+    closePosition(params: {
+        quoteId: number;
+        quantityToClose: number;
+        chainId: number;
+        slippage?: number;
+        orderType: OrderType;
+        useInstantActions?: boolean;
+    }): Promise<CloseRequestEntity>;
+    setTpSlForPosition(params: {
+        chainId: number;
+        userAddress: string;
+        accountAddress: string;
+        quoteId: string;
+        tpPrice: number;
+        slPrice: number;
+    }): Promise<void>;
+    listTpSlForPositions(chainId: SupportedChainId, quoteIds: string[]): Promise<ListTpSlResponse>;
+    getLockedParameters(chainId: SupportedChainId, solver: AvailableSolvers, marketName: string, leverage: number): Promise<SolverLockedParams>;
+    createCancelQuoteRequest(params: {
+        chainId: SupportedChainId;
+        quoteId: string;
+    }): Promise<CancelRequestEntity>;
+    getCancelQuoteRequestInfo(cancelRequestId: string, chainId: SupportedChainId): Promise<CancelQuoteRequestState>;
+    cancelCloseRequest(params: {
+        chainId: SupportedChainId;
+        quoteId: number;
+    }): Promise<CancelCloseRequestEntity>;
+    getCancelCloseRequestInfo(cancelRequestId: string, chainId: SupportedChainId): Promise<CancelCloseRequestState>;
+}