@decibeltrade/sdk 0.2.8 → 0.3.0

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

@@ -1,4 +1,5 @@
 import z from "zod/v4";
+import { PaginatedResponseSchema } from "../pagination.types";
 export const UserFundingSchema = z.object({
     market: z.string(),
     action: z.string(),
@@ -9,7 +10,4 @@ export const UserFundingSchema = z.object({
     fee_amount: z.number(),
     transaction_unix_ms: z.number(),
 });
-export const UserFundingHistorySchema = z.array(UserFundingSchema);
-export const UserFundingHistoryWsMessageSchema = z.object({
-    funding_history: UserFundingHistorySchema,
-});
+export const UserFundingHistorySchema = PaginatedResponseSchema(UserFundingSchema);

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

@@ -32,7 +32,8 @@ export declare enum ClientNotificationType {
     TwapCancellationPlaced = "TwapCancellationPlaced",
     OrderCancellationErrored = "OrderCancellationErrored",
     PositionCancellationErrored = "PositionCancellationErrored",
-    TwapCancellationErrored = "TwapCancellationErrored"
+    TwapCancellationErrored = "TwapCancellationErrored",
+    LimitOrderSubmitted = "LimitOrderSubmitted"
 }
 export declare const NotificationMetadataSchema: z.ZodObject<{
     trigger_price: z.ZodOptional<z.ZodNumber>;
@@ -59,10 +60,10 @@ export declare const UserNotificationSchema: z.ZodObject<{
             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;
+            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;
             is_reduce_only: z.ZodBoolean;
             details: z.ZodString;
@@ -79,14 +80,18 @@ export declare const UserNotificationSchema: z.ZodObject<{
             market: z.ZodString;
             is_buy: z.ZodBoolean;
             order_id: z.ZodString;
-            client_order_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            client_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;
+            status: z.ZodEnum<{
+                Finished: "Finished";
+                Activated: "Activated";
+                Cancelled: "Cancelled";
+            }>;
             transaction_unix_ms: z.ZodNumber;
             transaction_version: z.ZodNumber;
         }, z.core.$strip>>;

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

@@ -1 +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;AAMvB,oBAAY,gBAAgB;IAC1B,iBAAiB,sBAAsB;IACvC,gBAAgB,qBAAqB;IACrC,qBAAqB,0BAA0B;IAC/C,wBAAwB,6BAA6B;IACrD,oBAAoB,yBAAyB;IAC7C,uBAAuB,4BAA4B;IACnD,oBAAoB,yBAAyB;IAC7C,WAAW,gBAAgB;IAC3B,gBAAgB,qBAAqB;IACrC,cAAc,mBAAmB;IACjC,aAAa,kBAAkB;IAC/B,YAAY,iBAAiB;IAC7B,eAAe,oBAAoB;IACnC,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,gBAAgB,qBAAqB;IACrC,cAAc,mBAAmB;IACjC,iBAAiB,sBAAsB;IACvC,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;CAC5B;AAED,oBAAY,sBAAsB;IAChC,UAAU,eAAe;IACzB,uBAAuB,4BAA4B;IACnD,0BAA0B,+BAA+B;IACzD,sBAAsB,2BAA2B;IACjD,wBAAwB,6BAA6B;IACrD,2BAA2B,gCAAgC;IAC3D,uBAAuB,4BAA4B;CACpD;AAED,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"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;AAMvB,oBAAY,gBAAgB;IAC1B,iBAAiB,sBAAsB;IACvC,gBAAgB,qBAAqB;IACrC,qBAAqB,0BAA0B;IAC/C,wBAAwB,6BAA6B;IACrD,oBAAoB,yBAAyB;IAC7C,uBAAuB,4BAA4B;IACnD,oBAAoB,yBAAyB;IAC7C,WAAW,gBAAgB;IAC3B,gBAAgB,qBAAqB;IACrC,cAAc,mBAAmB;IACjC,aAAa,kBAAkB;IAC/B,YAAY,iBAAiB;IAC7B,eAAe,oBAAoB;IACnC,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,kBAAkB,uBAAuB;IACzC,gBAAgB,qBAAqB;IACrC,cAAc,mBAAmB;IACjC,iBAAiB,sBAAsB;IACvC,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;CAC5B;AAED,oBAAY,sBAAsB;IAChC,UAAU,eAAe;IACzB,uBAAuB,4BAA4B;IACnD,0BAA0B,+BAA+B;IACzD,sBAAsB,2BAA2B;IACjD,wBAAwB,6BAA6B;IACrD,2BAA2B,gCAAgC;IAC3D,uBAAuB,4BAA4B;IACnD,mBAAmB,wBAAwB;CAC5C;AAED,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AAEH,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

@@ -38,6 +38,7 @@ export var ClientNotificationType;
     ClientNotificationType["OrderCancellationErrored"] = "OrderCancellationErrored";
     ClientNotificationType["PositionCancellationErrored"] = "PositionCancellationErrored";
     ClientNotificationType["TwapCancellationErrored"] = "TwapCancellationErrored";
+    ClientNotificationType["LimitOrderSubmitted"] = "LimitOrderSubmitted";
 })(ClientNotificationType || (ClientNotificationType = {}));
 export const NotificationMetadataSchema = z.object({
     trigger_price: z.number().optional(),

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

@@ -6,30 +6,33 @@ export declare class UserOpenOrdersReader extends BaseReader {
      * @param subAddr The subaccount address of the user to get open orders for
      * @returns The open orders for the given user
      */
-    getByAddr({ subAddr, fetchOptions }: UserOpenOrdersRequestArgs): Promise<{
-        parent: string;
-        market: string;
-        order_id: string;
-        client_order_id: string | null;
-        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;
-    }[]>;
+    getByAddr({ subAddr, limit, offset, fetchOptions }: UserOpenOrdersRequestArgs): Promise<{
+        items: {
+            parent: string;
+            market: string;
+            order_id: string;
+            client_order_id: string | null;
+            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;
+        }[];
+        total_count: number;
+    }>;
     /**
      * Subscribe to user orders updates
      * @param subAddr The subaccount address of the user to subscribe to

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

@@ -1 +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,EACL,yBAAyB,EAEzB,uBAAuB,EAExB,MAAM,0BAA0B,CAAC;AAElC,qBAAa,oBAAqB,SAAQ,UAAU;IAClD;;;;OAIG;IACG,SAAS,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;IAWpE;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,uBAAuB,KAAK,IAAI;CAIjF"}
+{"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,EACL,yBAAyB,EAEzB,uBAAuB,EAExB,MAAM,0BAA0B,CAAC;AAElC,qBAAa,oBAAqB,SAAQ,UAAU;IAClD;;;;OAIG;IACG,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqBnF;;;;;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

@@ -6,11 +6,20 @@ export class UserOpenOrdersReader extends BaseReader {
      * @param subAddr The subaccount address of the user to get open orders for
      * @returns The open orders for the given user
      */
-    async getByAddr({ subAddr, fetchOptions }) {
+    async getByAddr({ subAddr, limit, offset, fetchOptions }) {
+        const queryParams = {
+            user: subAddr,
+        };
+        if (limit !== undefined) {
+            queryParams.limit = limit.toString();
+        }
+        if (offset !== undefined) {
+            queryParams.offset = offset.toString();
+        }
         const response = await this.getRequest({
             schema: UserOpenOrdersSchema,
             url: `${this.deps.config.tradingHttpUrl}/api/v1/open_orders`,
-            queryParams: { user: subAddr },
+            queryParams,
             options: fetchOptions,
         });
         return response.data;
@@ -22,7 +31,7 @@ export class UserOpenOrdersReader extends BaseReader {
      * @returns A function to unsubscribe from the user orders updates
      */
     subscribeByAddr(subAddr, onData) {
-        const topic = `user_open_orders:${subAddr}`;
+        const topic = `account_open_orders:${subAddr}`;
         return this.deps.ws.subscribe(topic, UserOpenOrdersWsMessageSchema, onData);
     }
 }

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

@@ -2,6 +2,8 @@ import z from "zod/v4";
 import { BaseRequestArgs } from "../base-reader";
 export interface UserOpenOrdersRequestArgs extends BaseRequestArgs {
     subAddr: string;
+    limit?: number;
+    offset?: number;
 }
 export declare const UserOpenOrderSchema: z.ZodObject<{
     parent: z.ZodString;
@@ -27,30 +29,33 @@ export declare const UserOpenOrderSchema: z.ZodObject<{
     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;
-    client_order_id: z.ZodNullable<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.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        parent: z.ZodString;
+        market: z.ZodString;
+        order_id: z.ZodString;
+        client_order_id: z.ZodNullable<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>>;
+    total_count: z.ZodNumber;
+}, z.core.$strip>;
 export declare const UserOpenOrdersWsMessageSchema: z.ZodObject<{
     orders: z.ZodArray<z.ZodObject<{
         parent: z.ZodString;
@@ -78,6 +83,8 @@ export declare const UserOpenOrdersWsMessageSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type UserOpenOrder = z.infer<typeof UserOpenOrderSchema>;
-export type UserOpenOrders = z.infer<typeof UserOpenOrdersSchema>;
+export type UserOpenOrdersResponse = z.infer<typeof UserOpenOrdersSchema>;
+/** @deprecated Use UserOpenOrder[] instead */
+export type UserOpenOrders = UserOpenOrder[];
 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

@@ -1 +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,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,WAAW,yBAA0B,SAAQ,eAAe;IAChE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;iBAuB9B,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"}
+{"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,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,MAAM,WAAW,yBAA0B,SAAQ,eAAe;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;iBAuB9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA+C,CAAC;AAEjF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;iBAExC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC1E,8CAA8C;AAC9C,MAAM,MAAM,cAAc,GAAG,aAAa,EAAE,CAAC;AAC7C,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

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

@@ -1,4 +1,5 @@
 import z from "zod/v4";
+import { PaginatedResponseSchema } from "../pagination.types";
 export const UserOpenOrderSchema = z.object({
     parent: z.string(),
     market: z.string(),
@@ -23,7 +24,7 @@ export const UserOpenOrderSchema = z.object({
     order_direction: z.string().optional(),
     is_reduce_only: z.boolean().optional(),
 });
-export const UserOpenOrdersSchema = z.array(UserOpenOrderSchema);
+export const UserOpenOrdersSchema = PaginatedResponseSchema(UserOpenOrderSchema);
 export const UserOpenOrdersWsMessageSchema = z.object({
     orders: z.array(UserOpenOrderSchema),
 });

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

@@ -1,7 +1,7 @@
 import { BaseReader } from "../base-reader";
 import { UserOrderHistoryRequestArgs, UserOrdersWsMessage } from "./user-order-history.types";
 export declare class UserOrderHistoryReader extends BaseReader {
-    getByAddr({ subAddr, fetchOptions }: UserOrderHistoryRequestArgs): Promise<{
+    getByAddr({ subAddr, limit, offset, fetchOptions }: UserOrderHistoryRequestArgs): Promise<{
         items: {
             parent: string;
             market: string;
@@ -11,10 +11,10 @@ export declare class UserOrderHistoryReader extends BaseReader {
             order_type: string;
             trigger_condition: string;
             order_direction: string;
-            orig_size: number;
-            remaining_size: number;
-            size_delta: number;
-            price: number;
+            orig_size: number | null;
+            remaining_size: number | null;
+            size_delta: number | null;
+            price: number | null;
             is_buy: boolean;
             is_reduce_only: boolean;
             details: string;

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

@@ -1 +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,EACL,2BAA2B,EAE3B,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,sBAAuB,SAAQ,UAAU;IAC9C,SAAS,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAatE;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI;CAK7E"}
+{"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,EACL,2BAA2B,EAE3B,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,sBAAuB,SAAQ,UAAU;IAC9C,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqBrF;;;;;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

@@ -1,13 +1,20 @@
 import { BaseReader } from "../base-reader";
 import { UserOrdersSchema, UserOrdersWsMessageSchema, } from "./user-order-history.types";
 export class UserOrderHistoryReader extends BaseReader {
-    async getByAddr({ subAddr, fetchOptions }) {
+    async getByAddr({ subAddr, limit, offset, fetchOptions }) {
+        const queryParams = {
+            user: subAddr,
+        };
+        if (limit !== undefined) {
+            queryParams.limit = limit.toString();
+        }
+        if (offset !== undefined) {
+            queryParams.offset = offset.toString();
+        }
         const response = await this.getRequest({
             schema: UserOrdersSchema,
             url: `${this.deps.config.tradingHttpUrl}/api/v1/order_history`,
-            queryParams: {
-                user: subAddr,
-            },
+            queryParams,
             options: fetchOptions,
         });
         return response.data;

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

@@ -2,6 +2,8 @@ import z from "zod/v4";
 import { BaseRequestArgs } from "../base-reader";
 export interface UserOrderHistoryRequestArgs extends BaseRequestArgs {
     subAddr: string;
+    limit?: number;
+    offset?: number;
 }
 export declare const UserOrderSchema: z.ZodObject<{
     parent: z.ZodString;
@@ -12,10 +14,10 @@ export declare const UserOrderSchema: z.ZodObject<{
     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;
+    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;
     is_reduce_only: z.ZodBoolean;
     details: z.ZodString;
@@ -38,10 +40,10 @@ export declare const UserOrdersSchema: z.ZodObject<{
         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;
+        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;
         is_reduce_only: z.ZodBoolean;
         details: z.ZodString;
@@ -68,10 +70,10 @@ export declare const UserOrdersWsMessageSchema: z.ZodObject<{
             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;
+            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;
             is_reduce_only: z.ZodBoolean;
             details: z.ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"user-order-history.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-order-history/user-order-history.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,MAAM,WAAW,2BAA4B,SAAQ,eAAe;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;iBAwB1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2C,CAAC;AAEzE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMpC,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"user-order-history.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-order-history/user-order-history.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,MAAM,WAAW,2BAA4B,SAAQ,eAAe;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;iBAwB1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA2C,CAAC;AAEzE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMpC,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

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

@@ -9,10 +9,10 @@ export const UserOrderSchema = z.object({
     order_type: z.string(),
     trigger_condition: z.string(),
     order_direction: z.string(),
-    orig_size: z.number(),
-    remaining_size: z.number(),
-    size_delta: z.number(),
-    price: z.number(),
+    orig_size: z.number().nullable(),
+    remaining_size: z.number().nullable(),
+    size_delta: z.number().nullable(),
+    price: z.number().nullable(),
     is_buy: z.boolean(),
     is_reduce_only: z.boolean(),
     details: z.string(),

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

@@ -9,7 +9,7 @@ export class UserPositionsReader extends BaseReader {
      */
     async getByAddr({ subAddr, marketAddr, includeDeleted = false, limit = 10, fetchOptions, }) {
         const queryParams = new URLSearchParams({
-            user: subAddr,
+            account: subAddr,
             include_deleted: includeDeleted.toString(),
             limit: limit.toString(),
         });
@@ -18,7 +18,7 @@ export class UserPositionsReader extends BaseReader {
         }
         const response = await this.getRequest({
             schema: UserPositionsSchema,
-            url: `${this.deps.config.tradingHttpUrl}/api/v1/user_positions`,
+            url: `${this.deps.config.tradingHttpUrl}/api/v1/account_positions`,
             queryParams,
             options: fetchOptions,
         });
@@ -32,7 +32,7 @@ export class UserPositionsReader extends BaseReader {
      * @returns A function to unsubscribe from the user positions updates
      */
     subscribeByAddr(subAddr, onData) {
-        const topic = `user_positions:${subAddr}`;
+        const topic = `account_positions:${subAddr}`;
         return this.deps.ws.subscribe(topic, UserPositionsWsMessageSchema, onData);
     }
 }

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

@@ -59,7 +59,6 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         has_fixed_sized_tpsls: z.ZodBoolean;
     };
     keyof: () => z.ZodEnum<{
-        user: "user";
         market: "market";
         size: "size";
         tp_order_id: "tp_order_id";
@@ -68,6 +67,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_order_id: "sl_order_id";
         sl_trigger_price: "sl_trigger_price";
         sl_limit_price: "sl_limit_price";
+        user: "user";
         user_leverage: "user_leverage";
         entry_price: "entry_price";
         is_isolated: "is_isolated";
@@ -160,7 +160,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
     }, z.core.$strip>;
-    extend: <U extends z.core.$ZodLooseShape & Partial<Record<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls", z.core.SomeType>>>(shape: U) => z.ZodObject<(("user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls") & keyof U extends never ? {
+    extend: <U extends z.core.$ZodLooseShape & Partial<Record<"market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls", z.core.SomeType>>>(shape: U) => z.ZodObject<(("market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls") & keyof U extends never ? {
         market: z.ZodString;
         user: z.ZodString;
         size: z.ZodNumber;
@@ -193,7 +193,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
     } extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof U ? never : K]: T_1[K]; } : never) & { [K_1 in keyof U]: U[K_1]; }) extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
-    merge: <U extends z.ZodObject>(other: U) => z.ZodObject<(("user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls") & keyof U["shape"] extends never ? {
+    merge: <U extends z.ZodObject>(other: U) => z.ZodObject<(("market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls") & keyof U["shape"] extends never ? {
         market: z.ZodString;
         user: z.ZodString;
         size: z.ZodNumber;
@@ -226,7 +226,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
     } extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof U["shape"] ? never : K]: T_1[K]; } : never) & (U["shape"] extends infer T_2 extends z.core.util.SomeObject ? { [K_1 in keyof T_2]: T_2[K_1]; } : never)) extends infer T ? { [k in keyof T]: T[k]; } : never, U["_zod"]["config"]>;
-    pick: <M extends z.core.util.Mask<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M) => z.ZodObject<Pick<{
+    pick: <M extends z.core.util.Mask<"market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M) => z.ZodObject<Pick<{
         market: z.ZodString;
         user: z.ZodString;
         size: z.ZodNumber;
@@ -242,8 +242,8 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_trigger_price: z.ZodNullable<z.ZodNumber>;
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
-    }, Extract<"user", keyof M> | Extract<"market", keyof M> | Extract<"size", keyof M> | Extract<"tp_order_id", keyof M> | Extract<"tp_trigger_price", keyof M> | Extract<"tp_limit_price", keyof M> | Extract<"sl_order_id", keyof M> | Extract<"sl_trigger_price", keyof M> | Extract<"sl_limit_price", keyof M> | Extract<"user_leverage", keyof M> | Extract<"entry_price", keyof M> | Extract<"is_isolated", keyof M> | Extract<"unrealized_funding", keyof M> | Extract<"estimated_liquidation_price", keyof M> | Extract<"has_fixed_sized_tpsls", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
-    omit: <M extends z.core.util.Mask<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M) => z.ZodObject<Omit<{
+    }, Extract<"market", keyof M> | Extract<"size", keyof M> | Extract<"tp_order_id", keyof M> | Extract<"tp_trigger_price", keyof M> | Extract<"tp_limit_price", keyof M> | Extract<"sl_order_id", keyof M> | Extract<"sl_trigger_price", keyof M> | Extract<"sl_limit_price", keyof M> | Extract<"user", keyof M> | Extract<"user_leverage", keyof M> | Extract<"entry_price", keyof M> | Extract<"is_isolated", keyof M> | Extract<"unrealized_funding", keyof M> | Extract<"estimated_liquidation_price", keyof M> | Extract<"has_fixed_sized_tpsls", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
+    omit: <M extends z.core.util.Mask<"market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M) => z.ZodObject<Omit<{
         market: z.ZodString;
         user: z.ZodString;
         size: z.ZodNumber;
@@ -259,7 +259,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
         sl_trigger_price: z.ZodNullable<z.ZodNumber>;
         sl_limit_price: z.ZodNullable<z.ZodNumber>;
         has_fixed_sized_tpsls: z.ZodBoolean;
-    }, Extract<"user", keyof M> | Extract<"market", keyof M> | Extract<"size", keyof M> | Extract<"tp_order_id", keyof M> | Extract<"tp_trigger_price", keyof M> | Extract<"tp_limit_price", keyof M> | Extract<"sl_order_id", keyof M> | Extract<"sl_trigger_price", keyof M> | Extract<"sl_limit_price", keyof M> | Extract<"user_leverage", keyof M> | Extract<"entry_price", keyof M> | Extract<"is_isolated", keyof M> | Extract<"unrealized_funding", keyof M> | Extract<"estimated_liquidation_price", keyof M> | Extract<"has_fixed_sized_tpsls", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
+    }, Extract<"market", keyof M> | Extract<"size", keyof M> | Extract<"tp_order_id", keyof M> | Extract<"tp_trigger_price", keyof M> | Extract<"tp_limit_price", keyof M> | Extract<"sl_order_id", keyof M> | Extract<"sl_trigger_price", keyof M> | Extract<"sl_limit_price", keyof M> | Extract<"user", keyof M> | Extract<"user_leverage", keyof M> | Extract<"entry_price", keyof M> | Extract<"is_isolated", keyof M> | Extract<"unrealized_funding", keyof M> | Extract<"estimated_liquidation_price", keyof M> | Extract<"has_fixed_sized_tpsls", keyof M>> extends infer T ? { [k in keyof T]: T[k]; } : never, z.core.$strip>;
     partial: {
         (): z.ZodObject<{
             market: z.ZodOptional<z.ZodString>;
@@ -278,7 +278,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
             sl_limit_price: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
             has_fixed_sized_tpsls: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
-        <M extends z.core.util.Mask<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M): z.ZodObject<{
+        <M extends z.core.util.Mask<"market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M): z.ZodObject<{
             market: "market" extends infer T ? T extends "market" ? T extends keyof M ? z.ZodOptional<{
                 market: z.ZodString;
                 user: z.ZodString;
@@ -794,7 +794,7 @@ export declare const UserPositionWsMessageSchema: z.ZodObject<{
             sl_limit_price: z.ZodNonOptional<z.ZodNullable<z.ZodNumber>>;
             has_fixed_sized_tpsls: z.ZodNonOptional<z.ZodBoolean>;
         }, z.core.$strip>;
-        <M extends z.core.util.Mask<"user" | "market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M): z.ZodObject<{
+        <M extends z.core.util.Mask<"market" | "size" | "tp_order_id" | "tp_trigger_price" | "tp_limit_price" | "sl_order_id" | "sl_trigger_price" | "sl_limit_price" | "user" | "user_leverage" | "entry_price" | "is_isolated" | "unrealized_funding" | "estimated_liquidation_price" | "has_fixed_sized_tpsls">>(mask: M): z.ZodObject<{
             market: "market" extends infer T ? T extends "market" ? T extends keyof M ? z.ZodNonOptional<{
                 market: z.ZodString;
                 user: z.ZodString;

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

@@ -5,23 +5,27 @@ export declare class UserTradeHistoryReader 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)
+     * @param offset The offset for pagination (default: 0)
      * @returns The trade history for the given user
      */
-    getByAddr({ subAddr, limit, fetchOptions }: UserTradeHistoryRequestArgs): Promise<{
-        account: string;
-        market: string;
-        action: string;
-        size: number;
-        price: number;
-        is_profit: boolean;
-        realized_pnl_amount: number;
-        is_funding_positive: boolean;
-        realized_funding_amount: number;
-        is_rebate: boolean;
-        fee_amount: number;
-        transaction_unix_ms: number;
-        transaction_version: number;
-    }[]>;
+    getByAddr({ subAddr, limit, offset, fetchOptions }: UserTradeHistoryRequestArgs): Promise<{
+        items: {
+            account: string;
+            market: string;
+            action: "OpenLong" | "CloseLong" | "OpenShort" | "CloseShort" | "Net";
+            size: number;
+            price: number;
+            is_profit: boolean;
+            realized_pnl_amount: number;
+            is_funding_positive: boolean;
+            realized_funding_amount: number;
+            is_rebate: boolean;
+            fee_amount: number;
+            transaction_unix_ms: number;
+            transaction_version: number;
+        }[];
+        total_count: number;
+    }>;
     /**
      * Subscribe to user trades updates
      * @param subAddr The subaccount address of the user to subscribe to

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

@@ -1 +1 @@
-{"version":3,"file":"user-trade-history.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-trade-history/user-trade-history.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EACL,2BAA2B,EAE3B,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,sBAAuB,SAAQ,UAAU;IACpD;;;;;OAKG;IACG,SAAS,CAAC,EAAE,OAAO,EAAE,KAAU,EAAE,YAAY,EAAE,EAAE,2BAA2B;;;;;;;;;;;;;;;IAWlF;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI;CAK7E"}
+{"version":3,"file":"user-trade-history.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-trade-history/user-trade-history.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EACL,2BAA2B,EAE3B,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,sBAAuB,SAAQ,UAAU;IACpD;;;;;;OAMG;IACG,SAAS,CAAC,EAAE,OAAO,EAAE,KAAU,EAAE,MAAU,EAAE,YAAY,EAAE,EAAE,2BAA2B;;;;;;;;;;;;;;;;;;IAW9F;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,IAAI;CAK7E"}

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

@@ -5,13 +5,14 @@ export class UserTradeHistoryReader 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)
+     * @param offset The offset for pagination (default: 0)
      * @returns The trade history for the given user
      */
-    async getByAddr({ subAddr, limit = 10, fetchOptions }) {
+    async getByAddr({ subAddr, limit = 10, offset = 0, fetchOptions }) {
         const response = await this.getRequest({
             schema: UserTradesSchema,
             url: `${this.deps.config.tradingHttpUrl}/api/v1/trade_history`,
-            queryParams: { user: subAddr, limit: limit.toString() },
+            queryParams: { account: subAddr, limit: limit.toString(), offset: offset.toString() },
             options: fetchOptions,
         });
         return response.data;