@carbon-terminal/trading-sdk 0.2.5

package/README.md

@@ -0,0 +1,6 @@
+# SDK for IntentX Trading API
+
+This SDK is used to interact with the IntentX Trading API.
+
+This SDK will use @intentx/core to define the types and interfaces.
+On top of that, it will provide a client to interact with the API.

package/dist/client/index.d.ts

@@ -0,0 +1 @@
+export * from "./trading-sdk";

package/dist/client/index.js

@@ -0,0 +1,17 @@
+"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("./trading-sdk"), exports);

package/dist/client/trading-sdk.d.ts

@@ -0,0 +1,42 @@
+import { APIResponse } from "@carbon-terminal/core";
+import { AxiosRequestConfig } from "axios";
+import { MarketsManager } from "..//modules/markets-manager";
+import { AccountManager } from "../modules/account-manager";
+import { AuthManager } from "../modules/auth-manager";
+import { TradeManager } from "../modules/trade-manager";
+import { TradingSDKConfig } from "./types";
+export declare class TradingSDK {
+    private readonly client;
+    private readonly config;
+    private apiKey;
+    readonly authManager: AuthManager;
+    readonly accountManager: AccountManager;
+    readonly tradeManager: TradeManager;
+    readonly marketsManager: MarketsManager;
+    constructor(config?: TradingSDKConfig);
+    setApiKey(apiKey: string): void;
+    /**
+     * Validate the API key against the trading API
+     */
+    validateApiKey(): Promise<boolean>;
+    /**
+     * Make a GET request to the API
+     * @internal
+     */
+    get<T>(endpoint: string, config?: AxiosRequestConfig): Promise<APIResponse<T>>;
+    /**
+     * Make a POST request to the API
+     * @internal
+     */
+    post<T>(endpoint: string, data?: any, config?: AxiosRequestConfig): Promise<APIResponse<T>>;
+    /**
+     * Make a PUT request to the API
+     * @internal
+     */
+    put<T>(endpoint: string, data?: any, config?: AxiosRequestConfig): Promise<APIResponse<T>>;
+    /**
+     * Make a DELETE request to the API
+     * @internal
+     */
+    delete<T>(endpoint: string, config?: AxiosRequestConfig): Promise<APIResponse<T>>;
+}

package/dist/client/trading-sdk.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingSDK = void 0;
+const axios_1 = __importDefault(require("axios"));
+const markets_manager_1 = require("..//modules/markets-manager");
+const exceptions_1 = require("../common/exceptions");
+const account_manager_1 = require("../modules/account-manager");
+const auth_manager_1 = require("../modules/auth-manager");
+const trade_manager_1 = require("../modules/trade-manager");
+const getApiUrl_1 = require("../utils/api/getApiUrl");
+const types_1 = require("./types");
+class TradingSDK {
+    //#endregion
+    constructor(config) {
+        this.apiKey = null;
+        this.config = config ?? {
+            baseUrl: (0, getApiUrl_1.getApiUrl)(),
+        };
+        if (config?.apiKey)
+            this.apiKey = config.apiKey;
+        this.client = axios_1.default.create({
+            baseURL: config?.baseUrl ?? (0, getApiUrl_1.getApiUrl)(),
+            headers: {
+                "Content-Type": "application/json",
+                ...(config?.apiKey && { "x-api-key": config.apiKey }),
+            },
+        });
+        this.authManager = new auth_manager_1.AuthManager(this);
+        this.accountManager = new account_manager_1.AccountManager(this);
+        this.tradeManager = new trade_manager_1.TradeManager(this);
+        this.marketsManager = new markets_manager_1.MarketsManager(this);
+        // Add response interceptor for error handling
+        this.client.interceptors.response.use((response) => response, (error) => {
+            if (error.response) {
+                throw new types_1.TradingSDKError(error.response?.data?.error?.message || "API request failed", error.response?.data?.error?.code, error.response?.data?.httpStatusCode);
+            }
+            throw new types_1.TradingSDKError("Network error");
+        });
+    }
+    setApiKey(apiKey) {
+        this.apiKey = apiKey;
+        this.client.defaults.headers["x-api-key"] = apiKey;
+    }
+    /**
+     * Validate the API key against the trading API
+     */
+    async validateApiKey() {
+        try {
+            const response = await this.post("/api-keys/validate");
+            if (!response.success) {
+                throw new exceptions_1.APIException({
+                    message: response.error?.message || "Failed to validate API key",
+                    code: response.error?.code,
+                    httpStatusCode: response.httpStatusCode,
+                });
+            }
+            return response.data.isValid;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Make a GET request to the API
+     * @internal
+     */
+    async get(endpoint, config) {
+        const response = await this.client.get(endpoint, config);
+        return response.data;
+    }
+    /**
+     * Make a POST request to the API
+     * @internal
+     */
+    async post(endpoint, data, config) {
+        const response = await this.client.post(endpoint, data, config);
+        return response.data;
+    }
+    /**
+     * Make a PUT request to the API
+     * @internal
+     */
+    async put(endpoint, data, config) {
+        const response = await this.client.put(endpoint, data, config);
+        return response.data;
+    }
+    /**
+     * Make a DELETE request to the API
+     * @internal
+     */
+    async delete(endpoint, config) {
+        const response = await this.client.delete(endpoint, config);
+        return response.data;
+    }
+}
+exports.TradingSDK = TradingSDK;

package/dist/client/types.d.ts

@@ -0,0 +1,9 @@
+export interface TradingSDKConfig {
+    baseUrl?: string;
+    apiKey?: string;
+}
+export declare class TradingSDKError extends Error {
+    code?: string;
+    status?: number;
+    constructor(message: string, code?: string, status?: number);
+}

package/dist/client/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradingSDKError = void 0;
+class TradingSDKError extends Error {
+    constructor(message, code, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = "TradingSDKError";
+        // Mantiene la cadena de prototipos correcta
+        Object.setPrototypeOf(this, TradingSDKError.prototype);
+        // Captura el stack trace correcto
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, TradingSDKError);
+        }
+    }
+}
+exports.TradingSDKError = TradingSDKError;

package/dist/common/exceptions.d.ts

@@ -0,0 +1,21 @@
+export declare class APIException extends Error {
+    readonly code: string;
+    readonly httpStatusCode: number;
+    constructor(params: {
+        message: string;
+        code?: string;
+        httpStatusCode?: number;
+    });
+}
+export declare class InstantActionNotAllowedException extends APIException {
+    constructor(message?: string, code?: string);
+}
+export declare class UnauthorizedException extends APIException {
+    constructor(message?: string, code?: string);
+}
+export declare class NotFoundException extends APIException {
+    constructor(message?: string, code?: string);
+}
+export declare class BadRequestException extends APIException {
+    constructor(message?: string, code?: string);
+}

package/dist/common/exceptions.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestException = exports.NotFoundException = exports.UnauthorizedException = exports.InstantActionNotAllowedException = exports.APIException = void 0;
+class APIException extends Error {
+    constructor(params) {
+        super(params.message);
+        this.code = params.code || "";
+        this.httpStatusCode = params.httpStatusCode || 200;
+    }
+}
+exports.APIException = APIException;
+class InstantActionNotAllowedException extends APIException {
+    constructor(message = "Instant action not allowed", code = "INSTANT_ACTION_NOT_ALLOWED") {
+        super({
+            message,
+            code,
+            httpStatusCode: 403,
+        });
+    }
+}
+exports.InstantActionNotAllowedException = InstantActionNotAllowedException;
+class UnauthorizedException extends APIException {
+    constructor(message = "Unauthorized", code = "NOT_AUTHORIZED") {
+        super({
+            message,
+            code,
+            httpStatusCode: 401,
+        });
+    }
+}
+exports.UnauthorizedException = UnauthorizedException;
+class NotFoundException extends APIException {
+    constructor(message = "Not Found", code = "NOT_FOUND") {
+        super({
+            message,
+            code,
+            httpStatusCode: 404,
+        });
+    }
+}
+exports.NotFoundException = NotFoundException;
+class BadRequestException extends APIException {
+    constructor(message = "Bad Request", code = "BAD_REQUEST") {
+        super({
+            message,
+            code,
+            httpStatusCode: 400,
+        });
+    }
+}
+exports.BadRequestException = BadRequestException;

package/dist/common/index.d.ts

@@ -0,0 +1 @@
+export * from "./exceptions";

package/dist/common/index.js

@@ -0,0 +1,17 @@
+"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("./exceptions"), exports);

package/dist/entities/account-entity.d.ts

@@ -0,0 +1,6 @@
+import { TradingSDK } from "src/client";
+export declare class AccountEntity {
+    private readonly tradingSdk;
+    private readonly subaccountAddress;
+    constructor(tradingSdk: TradingSDK, subaccountAddress: string);
+}

package/dist/entities/account-entity.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountEntity = void 0;
+class AccountEntity {
+    constructor(tradingSdk, subaccountAddress) {
+        this.tradingSdk = tradingSdk;
+        this.subaccountAddress = subaccountAddress;
+    }
+}
+exports.AccountEntity = AccountEntity;

package/dist/entities/cancel-close-request.entity.d.ts

@@ -0,0 +1,22 @@
+import { CancelCloseRequestState, CancelCloseRequestStatus } from "@carbon-terminal/core";
+import { TradingSDK } from "src/client";
+import { HookableEntity } from "./library/hookable-entity";
+export declare enum CancelCloseRequestHooks {
+    FAILED = "failed",
+    SUCCESS = "success"
+}
+export type CancelCloseRequestResultJustification = {
+    message: string;
+    code: string;
+};
+export declare class CancelCloseRequestEntity extends HookableEntity<CancelCloseRequestHooks, CancelCloseRequestState, CancelCloseRequestResultJustification> {
+    private readonly tradingSdk;
+    private internalCancelCloseRequestState;
+    constructor(tradingSdk: TradingSDK, cancelRequestState: CancelCloseRequestState);
+    private update;
+    getId(): string;
+    getStatus(): CancelCloseRequestStatus;
+    isFailed(): boolean;
+    isSuccess(): boolean;
+    waitForCompletion(): Promise<void>;
+}

package/dist/entities/cancel-close-request.entity.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelCloseRequestEntity = exports.CancelCloseRequestHooks = void 0;
+const core_1 = require("@carbon-terminal/core");
+const hookable_entity_1 = require("./library/hookable-entity");
+var CancelCloseRequestHooks;
+(function (CancelCloseRequestHooks) {
+    CancelCloseRequestHooks["FAILED"] = "failed";
+    CancelCloseRequestHooks["SUCCESS"] = "success";
+})(CancelCloseRequestHooks || (exports.CancelCloseRequestHooks = CancelCloseRequestHooks = {}));
+class CancelCloseRequestEntity extends hookable_entity_1.HookableEntity {
+    constructor(tradingSdk, cancelRequestState) {
+        super();
+        this.tradingSdk = tradingSdk;
+        this.internalCancelCloseRequestState = cancelRequestState;
+    }
+    async update() {
+        this.internalCancelCloseRequestState =
+            await this.tradingSdk.tradeManager.getCancelCloseRequestInfo(this.internalCancelCloseRequestState.id, this.internalCancelCloseRequestState.chainId);
+        if (this.internalCancelCloseRequestState.status ===
+            core_1.CancelCloseRequestStatus.CANCEL_SUCCESS) {
+            if (!this.isHookTriggered(CancelCloseRequestHooks.SUCCESS)) {
+                this.trigger(CancelCloseRequestHooks.SUCCESS, this.internalCancelCloseRequestState);
+            }
+        }
+        else if (this.internalCancelCloseRequestState.status ===
+            core_1.CancelCloseRequestStatus.CANCEL_FAILED) {
+            if (!this.isHookTriggered(CancelCloseRequestHooks.FAILED)) {
+                this.trigger(CancelCloseRequestHooks.FAILED, this.internalCancelCloseRequestState);
+            }
+        }
+        return this.internalCancelCloseRequestState;
+    }
+    getId() {
+        return this.internalCancelCloseRequestState.id;
+    }
+    getStatus() {
+        return this.internalCancelCloseRequestState.status;
+    }
+    isFailed() {
+        return this.getStatus() === core_1.CancelCloseRequestStatus.CANCEL_FAILED;
+    }
+    isSuccess() {
+        return this.getStatus() === core_1.CancelCloseRequestStatus.CANCEL_SUCCESS;
+    }
+    async waitForCompletion() {
+        while (this.getStatus() !== core_1.CancelCloseRequestStatus.CANCEL_SUCCESS &&
+            this.getStatus() !== core_1.CancelCloseRequestStatus.CANCEL_FAILED) {
+            await this.update();
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+    }
+}
+exports.CancelCloseRequestEntity = CancelCloseRequestEntity;

package/dist/entities/cancel-request.entity.d.ts

@@ -0,0 +1,22 @@
+import { CancelQuoteRequestState, CancelQuoteRequestStatus } from "@carbon-terminal/core";
+import { TradingSDK } from "src/client";
+import { HookableEntity } from "./library/hookable-entity";
+export declare enum CancelRequestHooks {
+    FAILED = "failed",
+    SUCCESS = "success"
+}
+export type CancelRequestResultJustification = {
+    message: string;
+    code: string;
+};
+export declare class CancelRequestEntity extends HookableEntity<CancelRequestHooks, CancelQuoteRequestState, CancelRequestResultJustification> {
+    private readonly tradingSdk;
+    private internalCancelQuoteRequestState;
+    constructor(tradingSdk: TradingSDK, cancelRequestState: CancelQuoteRequestState);
+    private update;
+    getId(): string;
+    getStatus(): CancelQuoteRequestStatus;
+    isFailed(): boolean;
+    isSuccess(): boolean;
+    waitForCompletion(): Promise<void>;
+}

package/dist/entities/cancel-request.entity.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelRequestEntity = exports.CancelRequestHooks = void 0;
+const core_1 = require("@carbon-terminal/core");
+const hookable_entity_1 = require("./library/hookable-entity");
+var CancelRequestHooks;
+(function (CancelRequestHooks) {
+    CancelRequestHooks["FAILED"] = "failed";
+    CancelRequestHooks["SUCCESS"] = "success";
+})(CancelRequestHooks || (exports.CancelRequestHooks = CancelRequestHooks = {}));
+class CancelRequestEntity extends hookable_entity_1.HookableEntity {
+    constructor(tradingSdk, cancelRequestState) {
+        super();
+        this.tradingSdk = tradingSdk;
+        this.internalCancelQuoteRequestState = cancelRequestState;
+    }
+    async update() {
+        this.internalCancelQuoteRequestState =
+            await this.tradingSdk.tradeManager.getCancelQuoteRequestInfo(this.internalCancelQuoteRequestState.id, this.internalCancelQuoteRequestState.chainId);
+        if (this.internalCancelQuoteRequestState.status ===
+            core_1.CancelQuoteRequestStatus.CANCEL_SUCCESS) {
+            if (!this.isHookTriggered(CancelRequestHooks.SUCCESS)) {
+                this.trigger(CancelRequestHooks.SUCCESS, this.internalCancelQuoteRequestState);
+            }
+        }
+        else if (this.internalCancelQuoteRequestState.status ===
+            core_1.CancelQuoteRequestStatus.CANCEL_FAILED) {
+            if (!this.isHookTriggered(CancelRequestHooks.FAILED)) {
+                this.trigger(CancelRequestHooks.FAILED, this.internalCancelQuoteRequestState);
+            }
+        }
+        return this.internalCancelQuoteRequestState;
+    }
+    getId() {
+        return this.internalCancelQuoteRequestState.id;
+    }
+    getStatus() {
+        return this.internalCancelQuoteRequestState.status;
+    }
+    isFailed() {
+        return this.getStatus() === core_1.CancelQuoteRequestStatus.CANCEL_FAILED;
+    }
+    isSuccess() {
+        return this.getStatus() === core_1.CancelQuoteRequestStatus.CANCEL_SUCCESS;
+    }
+    async waitForCompletion() {
+        while (this.getStatus() !== core_1.CancelQuoteRequestStatus.CANCEL_SUCCESS &&
+            this.getStatus() !== core_1.CancelQuoteRequestStatus.CANCEL_FAILED) {
+            await this.update();
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+    }
+}
+exports.CancelRequestEntity = CancelRequestEntity;

package/dist/entities/close-request.entity.d.ts

@@ -0,0 +1,23 @@
+import { CloseRequestState, CloseRequestStatus } from "@carbon-terminal/core";
+import { TradingSDK } from "src/client";
+import { HookableEntity } from "./library/hookable-entity";
+export declare enum CloseRequestHooks {
+    PRICE_SETTLED = "price-settled",
+    FAILED = "failed",
+    SUCCESS = "success"
+}
+export type CloseRequestResultJustification = {
+    message: string;
+    code: string;
+};
+export declare class CloseRequestEntity extends HookableEntity<CloseRequestHooks, CloseRequestState, CloseRequestResultJustification> {
+    private readonly tradingSdk;
+    private internalCloseRequestState;
+    constructor(tradingSdk: TradingSDK, closeRequestState: CloseRequestState);
+    private update;
+    getId(): string;
+    getStatus(): CloseRequestStatus;
+    isFailed(): boolean;
+    isSuccess(): boolean;
+    waitForCompletion(): Promise<CloseRequestStatus>;
+}

package/dist/entities/close-request.entity.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloseRequestEntity = exports.CloseRequestHooks = void 0;
+const core_1 = require("@carbon-terminal/core");
+const hookable_entity_1 = require("./library/hookable-entity");
+var CloseRequestHooks;
+(function (CloseRequestHooks) {
+    CloseRequestHooks["PRICE_SETTLED"] = "price-settled";
+    CloseRequestHooks["FAILED"] = "failed";
+    CloseRequestHooks["SUCCESS"] = "success";
+})(CloseRequestHooks || (exports.CloseRequestHooks = CloseRequestHooks = {}));
+class CloseRequestEntity extends hookable_entity_1.HookableEntity {
+    constructor(tradingSdk, closeRequestState) {
+        super();
+        this.tradingSdk = tradingSdk;
+        this.internalCloseRequestState = closeRequestState;
+    }
+    async update() {
+        this.internalCloseRequestState =
+            await this.tradingSdk.tradeManager.getCloseRequestInfo(this.internalCloseRequestState.id, this.internalCloseRequestState.chainId);
+        if (this.internalCloseRequestState.status ===
+            core_1.CloseRequestStatus.CLOSE_REQUEST_COMPLETED) {
+            if (!this.isHookTriggered(CloseRequestHooks.SUCCESS)) {
+                this.trigger(CloseRequestHooks.SUCCESS, this.internalCloseRequestState);
+            }
+        }
+        else if (this.internalCloseRequestState.status === core_1.CloseRequestStatus.FAILED) {
+            if (!this.isHookTriggered(CloseRequestHooks.FAILED)) {
+                this.trigger(CloseRequestHooks.FAILED, this.internalCloseRequestState);
+            }
+        }
+        else if (this.internalCloseRequestState.avgFillPrice &&
+            this.internalCloseRequestState.filledQuantity) {
+            if (!this.isHookTriggered(CloseRequestHooks.PRICE_SETTLED)) {
+                this.trigger(CloseRequestHooks.PRICE_SETTLED, this.internalCloseRequestState);
+            }
+        }
+        return this.internalCloseRequestState;
+    }
+    getId() {
+        return this.internalCloseRequestState.id;
+    }
+    getStatus() {
+        return this.internalCloseRequestState.status;
+    }
+    isFailed() {
+        return this.getStatus() === core_1.CloseRequestStatus.FAILED;
+    }
+    isSuccess() {
+        return this.getStatus() === core_1.CloseRequestStatus.CLOSE_REQUEST_COMPLETED;
+    }
+    async waitForCompletion() {
+        // Poll the status until it is not pending
+        while (this.getStatus() !== core_1.CloseRequestStatus.CLOSE_REQUEST_COMPLETED &&
+            this.getStatus() !== core_1.CloseRequestStatus.FAILED) {
+            await this.update();
+            // 3s polling
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+        return this.getStatus();
+    }
+}
+exports.CloseRequestEntity = CloseRequestEntity;

package/dist/entities/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./account-entity";
+export * from "./cancel-close-request.entity";
+export * from "./cancel-request.entity";
+export * from "./close-request.entity";
+export * from "./position-entity";

package/dist/entities/index.js

@@ -0,0 +1,21 @@
+"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("./account-entity"), exports);
+__exportStar(require("./cancel-close-request.entity"), exports);
+__exportStar(require("./cancel-request.entity"), exports);
+__exportStar(require("./close-request.entity"), exports);
+__exportStar(require("./position-entity"), exports);

package/dist/entities/library/hookable-entity.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class HookableEntity<T, S, J> {
+    private hooksTriggerRecords;
+    private hooksMap;
+    constructor();
+    on(hook: T, callback: (state: S, justification: J) => void): void;
+    protected trigger(hook: T, state: S, justification?: J): void;
+    protected isHookTriggered(hook: T): boolean;
+    abstract waitForCompletion(): any;
+}

package/dist/entities/library/hookable-entity.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookableEntity = void 0;
+class HookableEntity {
+    constructor() {
+        this.hooksTriggerRecords = new Map();
+        this.hooksMap = new Map();
+    }
+    on(hook, callback) {
+        this.hooksMap.set(hook, callback);
+    }
+    trigger(hook, state, justification) {
+        this.hooksTriggerRecords.set(hook, true);
+        this.hooksMap.get(hook)?.(state, justification);
+    }
+    isHookTriggered(hook) {
+        return this.hooksTriggerRecords.get(hook) ?? false;
+    }
+}
+exports.HookableEntity = HookableEntity;

package/dist/entities/position-entity.d.ts

@@ -0,0 +1,29 @@
+import { OrderType, Position, PositionStatus } from "@carbon-terminal/core";
+import { TradingSDK } from "src/client";
+import { HookableEntity } from "./library/hookable-entity";
+export declare enum PositionEntityHooks {
+    OPEN_PRICE_SETTLED = "open-price-settled",
+    OPEN_REJECTED = "open-rejected",
+    OPEN_SUCCESS = "open-success",
+    RESERVED = "reserved",
+    EXPIRED = "expired"
+}
+export type PositionResultJustification = {
+    message: string;
+    code: string;
+};
+export declare class PositionEntity extends HookableEntity<PositionEntityHooks, Position, PositionResultJustification> {
+    private readonly tradingSdk;
+    private internalPosition;
+    private lastFillQuantity;
+    constructor(tradingSdk: TradingSDK, position: Position);
+    getStatus(): PositionStatus;
+    getDetails(): Position;
+    update(): Promise<Position>;
+    isConfirmedOnChain(): boolean;
+    isPriceSettled(): number | boolean;
+    isFailed(): boolean;
+    close(quantityToClose: number, closePrice: number, orderType: OrderType): Promise<import("./close-request.entity").CloseRequestEntity>;
+    waitForCompletion(): Promise<void>;
+    waitForOnChainConfirmation(): Promise<void>;
+}