@decibeltrade/sdk 0.1.1

package/dist/read/user-bulk-orders/user-bulk-orders.types.d.ts

@@ -0,0 +1,46 @@
+import z from "zod/v4";
+export declare const UserBulkOrderSchema: z.ZodObject<{
+    market: z.ZodString;
+    sequence_number: z.ZodNumber;
+    previous_seq_num: z.ZodNumber;
+    bid_prices: z.ZodArray<z.ZodNumber>;
+    bid_sizes: z.ZodArray<z.ZodNumber>;
+    ask_prices: z.ZodArray<z.ZodNumber>;
+    ask_sizes: z.ZodArray<z.ZodNumber>;
+    cancelled_bid_prices: z.ZodArray<z.ZodNumber>;
+    cancelled_bid_sizes: z.ZodArray<z.ZodNumber>;
+    cancelled_ask_prices: z.ZodArray<z.ZodNumber>;
+    cancelled_ask_sizes: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const UserBulkOrdersSchema: z.ZodArray<z.ZodObject<{
+    market: z.ZodString;
+    sequence_number: z.ZodNumber;
+    previous_seq_num: z.ZodNumber;
+    bid_prices: z.ZodArray<z.ZodNumber>;
+    bid_sizes: z.ZodArray<z.ZodNumber>;
+    ask_prices: z.ZodArray<z.ZodNumber>;
+    ask_sizes: z.ZodArray<z.ZodNumber>;
+    cancelled_bid_prices: z.ZodArray<z.ZodNumber>;
+    cancelled_bid_sizes: z.ZodArray<z.ZodNumber>;
+    cancelled_ask_prices: z.ZodArray<z.ZodNumber>;
+    cancelled_ask_sizes: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>>;
+export declare const UserBulkOrdersWsMessageSchema: z.ZodObject<{
+    bulk_orders: z.ZodArray<z.ZodObject<{
+        market: z.ZodString;
+        sequence_number: z.ZodNumber;
+        previous_seq_num: z.ZodNumber;
+        bid_prices: z.ZodArray<z.ZodNumber>;
+        bid_sizes: z.ZodArray<z.ZodNumber>;
+        ask_prices: z.ZodArray<z.ZodNumber>;
+        ask_sizes: z.ZodArray<z.ZodNumber>;
+        cancelled_bid_prices: z.ZodArray<z.ZodNumber>;
+        cancelled_bid_sizes: z.ZodArray<z.ZodNumber>;
+        cancelled_ask_prices: z.ZodArray<z.ZodNumber>;
+        cancelled_ask_sizes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UserBulkOrder = z.infer<typeof UserBulkOrderSchema>;
+export type UserBulkOrders = z.infer<typeof UserBulkOrdersSchema>;
+export type UserBulkOrdersWsMessage = z.infer<typeof UserBulkOrdersWsMessageSchema>;
+//# sourceMappingURL=user-bulk-orders.types.d.ts.map

package/dist/read/user-bulk-orders/user-bulk-orders.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-bulk-orders.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-bulk-orders/user-bulk-orders.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;iBAY9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;kBAA+B,CAAC;AAEjE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;iBAExC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/read/user-bulk-orders/user-bulk-orders.types.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserBulkOrdersWsMessageSchema = exports.UserBulkOrdersSchema = exports.UserBulkOrderSchema = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+exports.UserBulkOrderSchema = v4_1.default.object({
+    market: v4_1.default.string(),
+    sequence_number: v4_1.default.number(),
+    previous_seq_num: v4_1.default.number(),
+    bid_prices: v4_1.default.array(v4_1.default.number()),
+    bid_sizes: v4_1.default.array(v4_1.default.number()),
+    ask_prices: v4_1.default.array(v4_1.default.number()),
+    ask_sizes: v4_1.default.array(v4_1.default.number()),
+    cancelled_bid_prices: v4_1.default.array(v4_1.default.number()),
+    cancelled_bid_sizes: v4_1.default.array(v4_1.default.number()),
+    cancelled_ask_prices: v4_1.default.array(v4_1.default.number()),
+    cancelled_ask_sizes: v4_1.default.array(v4_1.default.number()),
+});
+exports.UserBulkOrdersSchema = v4_1.default.array(exports.UserBulkOrderSchema);
+exports.UserBulkOrdersWsMessageSchema = v4_1.default.object({
+    bulk_orders: v4_1.default.array(exports.UserBulkOrderSchema),
+});

package/dist/read/user-funding-history/user-funding-history.reader.d.ts

@@ -0,0 +1,28 @@
+import { BaseReader } from "../base-reader";
+import { UserFundingHistoryWsMessage } from "./user-funding-history.types";
+export declare class UserFundingHistoryReader extends BaseReader {
+    /**
+     * Get the trade history for a given user
+     * @param subAddr The subaccount address of the user to get trade history for
+     * @param limit The number of trades to get (default: 10)
+     * @returns The trade history for the given user
+     */
+    getByAddr(subAddr: string, limit?: number): Promise<{
+        market: string;
+        action: string;
+        size: number;
+        is_funding_positive: boolean;
+        realized_funding_amount: number;
+        is_rebate: boolean;
+        fee_amount: number;
+        transaction_unix_ms: number;
+    }[]>;
+    /**
+     * Subscribe to trade history updates
+     * @param subAddr The subaccount address of the user to subscribe to
+     * @param onData Callback function for received trade history data
+     * @returns A function to unsubscribe from the trade history updates
+     */
+    subscribeByAddr(subAddr: string, onData: (data: UserFundingHistoryWsMessage) => void): () => void;
+}
+//# sourceMappingURL=user-funding-history.reader.d.ts.map

package/dist/read/user-funding-history/user-funding-history.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-funding-history.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-funding-history/user-funding-history.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAEL,2BAA2B,EAE5B,MAAM,8BAA8B,CAAC;AAEtC,qBAAa,wBAAyB,SAAQ,UAAU;IACtD;;;;;OAKG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,SAAK;;;;;;;;;;IAU3C;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,2BAA2B,KAAK,IAAI;CAKrF"}

package/dist/read/user-funding-history/user-funding-history.reader.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserFundingHistoryReader = void 0;
+const base_reader_1 = require("../base-reader");
+const user_funding_history_types_1 = require("./user-funding-history.types");
+class UserFundingHistoryReader extends base_reader_1.BaseReader {
+    /**
+     * Get the trade history for a given user
+     * @param subAddr The subaccount address of the user to get trade history for
+     * @param limit The number of trades to get (default: 10)
+     * @returns The trade history for the given user
+     */
+    async getByAddr(subAddr, limit = 10) {
+        const response = await this.getRequest({
+            schema: user_funding_history_types_1.UserFundingHistorySchema,
+            url: `${this.deps.config.tradingHttpUrl}/api/v1/funding_rate_history`,
+            queryParams: { user: subAddr, limit: limit.toString() },
+        });
+        return response.data;
+    }
+    /**
+     * Subscribe to trade history updates
+     * @param subAddr The subaccount address of the user to subscribe to
+     * @param onData Callback function for received trade history data
+     * @returns A function to unsubscribe from the trade history updates
+     */
+    subscribeByAddr(subAddr, onData) {
+        const topic = `user_funding_rate_history:${subAddr}`;
+        return this.deps.ws.subscribe(topic, user_funding_history_types_1.UserFundingHistoryWsMessageSchema, onData);
+    }
+}
+exports.UserFundingHistoryReader = UserFundingHistoryReader;

package/dist/read/user-funding-history/user-funding-history.types.d.ts

@@ -0,0 +1,37 @@
+import z from "zod/v4";
+export declare const UserFundingSchema: z.ZodObject<{
+    market: z.ZodString;
+    action: z.ZodString;
+    size: z.ZodNumber;
+    is_funding_positive: z.ZodBoolean;
+    realized_funding_amount: z.ZodNumber;
+    is_rebate: z.ZodBoolean;
+    fee_amount: z.ZodNumber;
+    transaction_unix_ms: z.ZodNumber;
+}, z.core.$strip>;
+export declare const UserFundingHistorySchema: z.ZodArray<z.ZodObject<{
+    market: z.ZodString;
+    action: z.ZodString;
+    size: z.ZodNumber;
+    is_funding_positive: z.ZodBoolean;
+    realized_funding_amount: z.ZodNumber;
+    is_rebate: z.ZodBoolean;
+    fee_amount: z.ZodNumber;
+    transaction_unix_ms: z.ZodNumber;
+}, z.core.$strip>>;
+export declare const UserFundingHistoryWsMessageSchema: z.ZodObject<{
+    funding_history: z.ZodArray<z.ZodObject<{
+        market: z.ZodString;
+        action: z.ZodString;
+        size: z.ZodNumber;
+        is_funding_positive: z.ZodBoolean;
+        realized_funding_amount: z.ZodNumber;
+        is_rebate: z.ZodBoolean;
+        fee_amount: z.ZodNumber;
+        transaction_unix_ms: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UserFunding = z.infer<typeof UserFundingSchema>;
+export type UserFundingHistory = z.infer<typeof UserFundingHistorySchema>;
+export type UserFundingHistoryWsMessage = z.infer<typeof UserFundingHistoryWsMessageSchema>;
+//# sourceMappingURL=user-funding-history.types.d.ts.map

package/dist/read/user-funding-history/user-funding-history.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-funding-history.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-funding-history/user-funding-history.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,eAAO,MAAM,iBAAiB;;;;;;;;;iBAS5B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;kBAA6B,CAAC;AAEnE,eAAO,MAAM,iCAAiC;;;;;;;;;;;iBAE5C,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC"}

package/dist/read/user-funding-history/user-funding-history.types.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserFundingHistoryWsMessageSchema = exports.UserFundingHistorySchema = exports.UserFundingSchema = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+exports.UserFundingSchema = v4_1.default.object({
+    market: v4_1.default.string(),
+    action: v4_1.default.string(),
+    size: v4_1.default.number(),
+    is_funding_positive: v4_1.default.boolean(),
+    realized_funding_amount: v4_1.default.number(),
+    is_rebate: v4_1.default.boolean(),
+    fee_amount: v4_1.default.number(),
+    transaction_unix_ms: v4_1.default.number(),
+});
+exports.UserFundingHistorySchema = v4_1.default.array(exports.UserFundingSchema);
+exports.UserFundingHistoryWsMessageSchema = v4_1.default.object({
+    funding_history: exports.UserFundingHistorySchema,
+});

package/dist/read/user-notifications/user-notifications.reader.d.ts

@@ -0,0 +1,13 @@
+import { BaseReader } from "../base-reader";
+import { UserNotification } from "./user-notifications.types";
+export declare class UserNotificationsReader extends BaseReader {
+    /**
+     * Subscribe to user positions updates
+     * @param subAddr The subaccount address of the user to subscribe to
+     * @param apiUrl The WebSocket server URL
+     * @param onData Callback function for received user positions data
+     * @returns A function to unsubscribe from the user positions updates
+     */
+    subscribeByAddr(subAddr: string, onData: (data: UserNotification) => void): () => void;
+}
+//# sourceMappingURL=user-notifications.reader.d.ts.map

package/dist/read/user-notifications/user-notifications.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-notifications.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-notifications/user-notifications.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAA0B,MAAM,4BAA4B,CAAC;AAEtF,qBAAa,uBAAwB,SAAQ,UAAU;IACrD;;;;;;OAMG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI;CAK1E"}

package/dist/read/user-notifications/user-notifications.reader.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserNotificationsReader = void 0;
+const base_reader_1 = require("../base-reader");
+const user_notifications_types_1 = require("./user-notifications.types");
+class UserNotificationsReader extends base_reader_1.BaseReader {
+    /**
+     * Subscribe to user positions updates
+     * @param subAddr The subaccount address of the user to subscribe to
+     * @param apiUrl The WebSocket server URL
+     * @param onData Callback function for received user positions data
+     * @returns A function to unsubscribe from the user positions updates
+     */
+    subscribeByAddr(subAddr, onData) {
+        const topic = `notifications:${subAddr}`;
+        return this.deps.ws.subscribe(topic, user_notifications_types_1.UserNotificationSchema, onData);
+    }
+}
+exports.UserNotificationsReader = UserNotificationsReader;

package/dist/read/user-notifications/user-notifications.types.d.ts

@@ -0,0 +1,49 @@
+import z from "zod/v4";
+export declare const UserNotificationSchema: z.ZodObject<{
+    notification: z.ZodObject<{
+        account: z.ZodString;
+        message: z.ZodString;
+        notification_type: z.ZodString;
+        order: z.ZodOptional<z.ZodObject<{
+            parent: z.ZodString;
+            market: z.ZodString;
+            client_order_id: z.ZodString;
+            order_id: z.ZodString;
+            status: z.ZodString;
+            order_type: z.ZodString;
+            trigger_condition: z.ZodString;
+            order_direction: z.ZodString;
+            orig_size: z.ZodNumber;
+            remaining_size: z.ZodNumber;
+            size_delta: z.ZodNumber;
+            price: z.ZodNumber;
+            is_buy: z.ZodBoolean;
+            is_reduce_only: z.ZodBoolean;
+            details: z.ZodString;
+            tp_order_id: z.ZodNullable<z.ZodString>;
+            tp_trigger_price: z.ZodNullable<z.ZodNumber>;
+            tp_limit_price: z.ZodNullable<z.ZodNumber>;
+            sl_order_id: z.ZodNullable<z.ZodString>;
+            sl_trigger_price: z.ZodNullable<z.ZodNumber>;
+            sl_limit_price: z.ZodNullable<z.ZodNumber>;
+            transaction_version: z.ZodNumber;
+            unix_ms: z.ZodNumber;
+        }, z.core.$strip>>;
+        twap: z.ZodOptional<z.ZodObject<{
+            market: z.ZodString;
+            is_buy: z.ZodBoolean;
+            order_id: z.ZodString;
+            is_reduce_only: z.ZodBoolean;
+            start_unix_ms: z.ZodNumber;
+            frequency_s: z.ZodNumber;
+            duration_s: z.ZodNumber;
+            orig_size: z.ZodNumber;
+            remaining_size: z.ZodNumber;
+            status: z.ZodString;
+            transaction_unix_ms: z.ZodNumber;
+            transaction_version: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type UserNotification = z.infer<typeof UserNotificationSchema>;
+//# sourceMappingURL=user-notifications.types.d.ts.map

package/dist/read/user-notifications/user-notifications.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-notifications.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-notifications/user-notifications.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAKvB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/read/user-notifications/user-notifications.types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserNotificationSchema = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+const user_active_twaps_types_1 = require("../user-active-twaps/user-active-twaps.types");
+const user_order_history_types_1 = require("../user-order-history/user-order-history.types");
+exports.UserNotificationSchema = v4_1.default.object({
+    notification: v4_1.default.object({
+        account: v4_1.default.string(),
+        message: v4_1.default.string(),
+        notification_type: v4_1.default.string(),
+        order: user_order_history_types_1.UserOrderSchema.optional(), // Optional order data
+        twap: user_active_twaps_types_1.UserActiveTwapSchema.optional(), // Optional twap data
+    }),
+});

package/dist/read/user-open-orders/user-open-orders.reader.d.ts

@@ -0,0 +1,40 @@
+import { BaseReader } from "../base-reader";
+import { UserOpenOrdersWsMessage } from "./user-open-orders.types";
+export declare class UserOpenOrdersReader extends BaseReader {
+    /**
+     * Get the open orders for a given user
+     * @param subAddr The subaccount address of the user to get open orders for
+     * @returns The open orders for the given user
+     */
+    getByAddr(subAddr: string): Promise<{
+        parent: string;
+        market: string;
+        order_id: string;
+        orig_size: number | null;
+        remaining_size: number | null;
+        size_delta: number | null;
+        price: number | null;
+        is_buy: boolean;
+        details: string;
+        transaction_version: number;
+        unix_ms: number;
+        tp_order_id: string | null;
+        tp_trigger_price: number | null;
+        tp_limit_price: number | null;
+        sl_order_id: string | null;
+        sl_trigger_price: number | null;
+        sl_limit_price: number | null;
+        order_type?: string | undefined;
+        trigger_condition?: string | undefined;
+        order_direction?: string | undefined;
+        is_reduce_only?: boolean | undefined;
+    }[]>;
+    /**
+     * Subscribe to user orders updates
+     * @param subAddr The subaccount address of the user to subscribe to
+     * @param onData Callback function for received user orders data
+     * @returns A function to unsubscribe from the user orders updates
+     */
+    subscribeByAddr(subAddr: string, onData: (data: UserOpenOrdersWsMessage) => void): () => void;
+}
+//# sourceMappingURL=user-open-orders.reader.d.ts.map

package/dist/read/user-open-orders/user-open-orders.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-open-orders.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-open-orders/user-open-orders.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAEL,uBAAuB,EAExB,MAAM,0BAA0B,CAAC;AAElC,qBAAa,oBAAqB,SAAQ,UAAU;IAClD;;;;OAIG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;IAU/B;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,uBAAuB,KAAK,IAAI;CAIjF"}

package/dist/read/user-open-orders/user-open-orders.reader.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserOpenOrdersReader = void 0;
+const base_reader_1 = require("../base-reader");
+const user_open_orders_types_1 = require("./user-open-orders.types");
+class UserOpenOrdersReader extends base_reader_1.BaseReader {
+    /**
+     * Get the open orders for a given user
+     * @param subAddr The subaccount address of the user to get open orders for
+     * @returns The open orders for the given user
+     */
+    async getByAddr(subAddr) {
+        const response = await this.getRequest({
+            schema: user_open_orders_types_1.UserOpenOrdersSchema,
+            url: `${this.deps.config.tradingHttpUrl}/api/v1/open_orders`,
+            queryParams: { user: subAddr },
+        });
+        return response.data;
+    }
+    /**
+     * Subscribe to user orders updates
+     * @param subAddr The subaccount address of the user to subscribe to
+     * @param onData Callback function for received user orders data
+     * @returns A function to unsubscribe from the user orders updates
+     */
+    subscribeByAddr(subAddr, onData) {
+        const topic = `user_open_orders:${subAddr}`;
+        return this.deps.ws.subscribe(topic, user_open_orders_types_1.UserOpenOrdersWsMessageSchema, onData);
+    }
+}
+exports.UserOpenOrdersReader = UserOpenOrdersReader;

package/dist/read/user-open-orders/user-open-orders.types.d.ts

@@ -0,0 +1,76 @@
+import z from "zod/v4";
+export declare const UserOpenOrderSchema: z.ZodObject<{
+    parent: z.ZodString;
+    market: z.ZodString;
+    order_id: z.ZodString;
+    orig_size: z.ZodNullable<z.ZodNumber>;
+    remaining_size: z.ZodNullable<z.ZodNumber>;
+    size_delta: z.ZodNullable<z.ZodNumber>;
+    price: z.ZodNullable<z.ZodNumber>;
+    is_buy: z.ZodBoolean;
+    details: z.ZodString;
+    transaction_version: z.ZodNumber;
+    unix_ms: z.ZodNumber;
+    tp_order_id: z.ZodNullable<z.ZodString>;
+    tp_trigger_price: z.ZodNullable<z.ZodNumber>;
+    tp_limit_price: z.ZodNullable<z.ZodNumber>;
+    sl_order_id: z.ZodNullable<z.ZodString>;
+    sl_trigger_price: z.ZodNullable<z.ZodNumber>;
+    sl_limit_price: z.ZodNullable<z.ZodNumber>;
+    order_type: z.ZodOptional<z.ZodString>;
+    trigger_condition: z.ZodOptional<z.ZodString>;
+    order_direction: z.ZodOptional<z.ZodString>;
+    is_reduce_only: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const UserOpenOrdersSchema: z.ZodArray<z.ZodObject<{
+    parent: z.ZodString;
+    market: z.ZodString;
+    order_id: z.ZodString;
+    orig_size: z.ZodNullable<z.ZodNumber>;
+    remaining_size: z.ZodNullable<z.ZodNumber>;
+    size_delta: z.ZodNullable<z.ZodNumber>;
+    price: z.ZodNullable<z.ZodNumber>;
+    is_buy: z.ZodBoolean;
+    details: z.ZodString;
+    transaction_version: z.ZodNumber;
+    unix_ms: z.ZodNumber;
+    tp_order_id: z.ZodNullable<z.ZodString>;
+    tp_trigger_price: z.ZodNullable<z.ZodNumber>;
+    tp_limit_price: z.ZodNullable<z.ZodNumber>;
+    sl_order_id: z.ZodNullable<z.ZodString>;
+    sl_trigger_price: z.ZodNullable<z.ZodNumber>;
+    sl_limit_price: z.ZodNullable<z.ZodNumber>;
+    order_type: z.ZodOptional<z.ZodString>;
+    trigger_condition: z.ZodOptional<z.ZodString>;
+    order_direction: z.ZodOptional<z.ZodString>;
+    is_reduce_only: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export declare const UserOpenOrdersWsMessageSchema: z.ZodObject<{
+    orders: z.ZodArray<z.ZodObject<{
+        parent: z.ZodString;
+        market: z.ZodString;
+        order_id: z.ZodString;
+        orig_size: z.ZodNullable<z.ZodNumber>;
+        remaining_size: z.ZodNullable<z.ZodNumber>;
+        size_delta: z.ZodNullable<z.ZodNumber>;
+        price: z.ZodNullable<z.ZodNumber>;
+        is_buy: z.ZodBoolean;
+        details: z.ZodString;
+        transaction_version: z.ZodNumber;
+        unix_ms: z.ZodNumber;
+        tp_order_id: z.ZodNullable<z.ZodString>;
+        tp_trigger_price: z.ZodNullable<z.ZodNumber>;
+        tp_limit_price: z.ZodNullable<z.ZodNumber>;
+        sl_order_id: z.ZodNullable<z.ZodString>;
+        sl_trigger_price: z.ZodNullable<z.ZodNumber>;
+        sl_limit_price: z.ZodNullable<z.ZodNumber>;
+        order_type: z.ZodOptional<z.ZodString>;
+        trigger_condition: z.ZodOptional<z.ZodString>;
+        order_direction: z.ZodOptional<z.ZodString>;
+        is_reduce_only: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UserOpenOrder = z.infer<typeof UserOpenOrderSchema>;
+export type UserOpenOrders = z.infer<typeof UserOpenOrdersSchema>;
+export type UserOpenOrdersWsMessage = z.infer<typeof UserOpenOrdersWsMessageSchema>;
+//# sourceMappingURL=user-open-orders.types.d.ts.map

package/dist/read/user-open-orders/user-open-orders.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-open-orders.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-open-orders/user-open-orders.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;iBAsB9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;kBAA+B,CAAC;AAEjE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;iBAExC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/read/user-open-orders/user-open-orders.types.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserOpenOrdersWsMessageSchema = exports.UserOpenOrdersSchema = exports.UserOpenOrderSchema = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+exports.UserOpenOrderSchema = v4_1.default.object({
+    parent: v4_1.default.string(),
+    market: v4_1.default.string(),
+    order_id: v4_1.default.string(),
+    orig_size: v4_1.default.number().nullable(),
+    remaining_size: v4_1.default.number().nullable(),
+    size_delta: v4_1.default.number().nullable(),
+    price: v4_1.default.number().nullable(),
+    is_buy: v4_1.default.boolean(),
+    details: v4_1.default.string(),
+    transaction_version: v4_1.default.number(),
+    unix_ms: v4_1.default.number(),
+    tp_order_id: v4_1.default.string().nullable(),
+    tp_trigger_price: v4_1.default.number().nullable(),
+    tp_limit_price: v4_1.default.number().nullable(),
+    sl_order_id: v4_1.default.string().nullable(),
+    sl_trigger_price: v4_1.default.number().nullable(),
+    sl_limit_price: v4_1.default.number().nullable(),
+    order_type: v4_1.default.string().optional(),
+    trigger_condition: v4_1.default.string().optional(),
+    order_direction: v4_1.default.string().optional(),
+    is_reduce_only: v4_1.default.boolean().optional(),
+});
+exports.UserOpenOrdersSchema = v4_1.default.array(exports.UserOpenOrderSchema);
+exports.UserOpenOrdersWsMessageSchema = v4_1.default.object({
+    orders: v4_1.default.array(exports.UserOpenOrderSchema),
+});

package/dist/read/user-order-history/user-order-history.reader.d.ts

@@ -0,0 +1,40 @@
+import { BaseReader } from "../base-reader";
+import { UserOrdersWsMessage } from "./user-order-history.types";
+export declare class UserOrderHistoryReader extends BaseReader {
+    getByAddr(subAddr: string): Promise<{
+        items: {
+            parent: string;
+            market: string;
+            client_order_id: string;
+            order_id: string;
+            status: string;
+            order_type: string;
+            trigger_condition: string;
+            order_direction: string;
+            orig_size: number;
+            remaining_size: number;
+            size_delta: number;
+            price: number;
+            is_buy: boolean;
+            is_reduce_only: boolean;
+            details: string;
+            tp_order_id: string | null;
+            tp_trigger_price: number | null;
+            tp_limit_price: number | null;
+            sl_order_id: string | null;
+            sl_trigger_price: number | null;
+            sl_limit_price: number | null;
+            transaction_version: number;
+            unix_ms: number;
+        }[];
+        total_count: number;
+    }>;
+    /**
+     * Subscribe to user order history updates
+     * @param subAddr The subaccount address of the user to subscribe to
+     * @param onData Callback function for received user order history data
+     * @returns A function to unsubscribe from the user order history updates
+     */
+    subscribeByAddr(subAddr: string, onData: (data: UserOrdersWsMessage) => void): () => void;
+}
+//# sourceMappingURL=user-order-history.reader.d.ts.map

package/dist/read/user-order-history/user-order-history.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-order-history.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-order-history/user-order-history.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAEL,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,sBAAuB,SAAQ,UAAU;IAC9C,SAAS,CAAC,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAY/B;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI;CAK7E"}

package/dist/read/user-order-history/user-order-history.reader.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserOrderHistoryReader = void 0;
+const base_reader_1 = require("../base-reader");
+const user_order_history_types_1 = require("./user-order-history.types");
+class UserOrderHistoryReader extends base_reader_1.BaseReader {
+    async getByAddr(subAddr) {
+        const response = await this.getRequest({
+            schema: user_order_history_types_1.UserOrdersSchema,
+            url: `${this.deps.config.tradingHttpUrl}/api/v1/order_history`,
+            queryParams: {
+                user: subAddr,
+            },
+        });
+        return response.data;
+    }
+    /**
+     * Subscribe to user order history updates
+     * @param subAddr The subaccount address of the user to subscribe to
+     * @param onData Callback function for received user order history data
+     * @returns A function to unsubscribe from the user order history updates
+     */
+    subscribeByAddr(subAddr, onData) {
+        const topic = `user_order_history:${subAddr}`;
+        return this.deps.ws.subscribe(topic, user_order_history_types_1.UserOrdersWsMessageSchema, onData);
+    }
+}
+exports.UserOrderHistoryReader = UserOrderHistoryReader;