@decibeltrade/sdk 0.2.0 → 0.2.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"user-positions.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-positions/user-positions.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,WAAW,wBAAyB,SAAQ,eAAe;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;iBAiB7B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;kBAA8B,CAAC;AAE/D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA+B,CAAC;AAExE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;iBAEvC,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

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

@@ -1,25 +1,30 @@
-import z from "zod/v4";
-export const UserPositionSchema = z.object({
-    market: z.string(),
-    user: z.string(),
-    size: z.number(),
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPositionsWsMessageSchema = exports.UserPositionWsMessageSchema = exports.UserPositionsSchema = exports.UserPositionSchema = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+exports.UserPositionSchema = v4_1.default.object({
+    market: v4_1.default.string(),
+    user: v4_1.default.string(),
+    size: v4_1.default.number(),
     // margin: z.number(),
-    max_allowed_leverage: z.number(),
-    user_leverage: z.number(),
-    entry_price: z.number(),
-    is_isolated: z.boolean(),
-    unrealized_funding: z.number(),
-    estimated_liquidation_price: z.number(),
-    tp_order_id: z.string().nullable(),
-    tp_trigger_price: z.number().nullable(),
-    tp_limit_price: z.number().nullable(),
-    sl_order_id: z.string().nullable(),
-    sl_trigger_price: z.number().nullable(),
-    sl_limit_price: z.number().nullable(),
-    has_fixed_sized_tpsls: z.boolean(),
+    user_leverage: v4_1.default.number(),
+    entry_price: v4_1.default.number(),
+    is_isolated: v4_1.default.boolean(),
+    unrealized_funding: v4_1.default.number(),
+    estimated_liquidation_price: 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(),
+    has_fixed_sized_tpsls: v4_1.default.boolean(),
 });
-export const UserPositionsSchema = z.array(UserPositionSchema);
-export const UserPositionWsMessageSchema = z.object(UserPositionSchema);
-export const UserPositionsWsMessageSchema = z.object({
-    positions: UserPositionsSchema,
+exports.UserPositionsSchema = v4_1.default.array(exports.UserPositionSchema);
+exports.UserPositionWsMessageSchema = v4_1.default.object(exports.UserPositionSchema);
+exports.UserPositionsWsMessageSchema = v4_1.default.object({
+    positions: exports.UserPositionsSchema,
 });

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

@@ -15,3 +15,4 @@ export declare class UserSubaccountsReader extends BaseReader {
         is_active?: boolean | undefined;
     }[]>;
 }
+//# sourceMappingURL=user-subaccounts.reader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user-subaccounts.reader.d.ts","sourceRoot":"","sources":["../../../src/read/user-subaccounts/user-subaccounts.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,0BAA0B,EAAyB,MAAM,0BAA0B,CAAC;AAE7F,qBAAa,qBAAsB,SAAQ,UAAU;IACnD;;;;;OAKG;IACG,SAAS,CAAC,EACd,SAAS,EAET,YAAY,GACb,EAAE,0BAA0B;;;;;;;CAe9B"}

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

@@ -1,6 +1,9 @@
-import { BaseReader } from "../base-reader";
-import { UserSubaccountsSchema } from "./user-subaccounts.types";
-export class UserSubaccountsReader extends BaseReader {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSubaccountsReader = void 0;
+const base_reader_1 = require("../base-reader");
+const user_subaccounts_types_1 = require("./user-subaccounts.types");
+class UserSubaccountsReader extends base_reader_1.BaseReader {
     /**
      * Get the subaccounts for a given user
      * @param ownerAddr The address of the owner to get subaccounts for
@@ -15,7 +18,7 @@ export class UserSubaccountsReader extends BaseReader {
             // limit: limit.toString(),
         });
         const response = await this.getRequest({
-            schema: UserSubaccountsSchema,
+            schema: user_subaccounts_types_1.UserSubaccountsSchema,
             url: `${this.deps.config.tradingHttpUrl}/api/v1/subaccounts`, // TODO: update to /user_subaccounts?
             queryParams,
             options: fetchOptions,
@@ -23,3 +26,4 @@ export class UserSubaccountsReader extends BaseReader {
         return response.data;
     }
 }
+exports.UserSubaccountsReader = UserSubaccountsReader;

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

@@ -19,3 +19,4 @@ export declare const UserSubaccountsSchema: z.ZodArray<z.ZodObject<{
 }, z.core.$strip>>;
 export type UserSubaccount = z.infer<typeof UserSubaccountSchema>;
 export type UserSubaccounts = UserSubaccount[];
+//# sourceMappingURL=user-subaccounts.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user-subaccounts.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-subaccounts/user-subaccounts.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,WAAW,0BAA2B,SAAQ,eAAe;IACjE,SAAS,EAAE,MAAM,CAAC;CAEnB;AAED,eAAO,MAAM,oBAAoB;;;;;;iBAM/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;kBAAgC,CAAC;AAEnE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,cAAc,EAAE,CAAC"}

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

@@ -1,9 +1,15 @@
-import z from "zod/v4";
-export const UserSubaccountSchema = z.object({
-    subaccount_address: z.string(),
-    primary_account_address: z.string(),
-    is_primary: z.boolean(),
-    is_active: z.boolean().optional(),
-    custom_label: z.string().nullable(),
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSubaccountsSchema = exports.UserSubaccountSchema = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+exports.UserSubaccountSchema = v4_1.default.object({
+    subaccount_address: v4_1.default.string(),
+    primary_account_address: v4_1.default.string(),
+    is_primary: v4_1.default.boolean(),
+    is_active: v4_1.default.boolean().optional(),
+    custom_label: v4_1.default.string().nullable(),
 });
-export const UserSubaccountsSchema = z.array(UserSubaccountSchema);
+exports.UserSubaccountsSchema = v4_1.default.array(exports.UserSubaccountSchema);

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

@@ -23,10 +23,11 @@ export declare class UserTradeHistoryReader extends BaseReader {
         transaction_version: number;
     }[]>;
     /**
-     * Subscribe to trade history updates
+     * Subscribe to user trades 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
+     * @param onData Callback function for received user trades data
+     * @returns A function to unsubscribe from the user trades updates
      */
     subscribeByAddr(subAddr: string, onData: (data: UserTradesWsMessage) => void): () => void;
 }
+//# sourceMappingURL=user-trade-history.reader.d.ts.map

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

@@ -0,0 +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"}

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

@@ -1,6 +1,9 @@
-import { BaseReader } from "../base-reader";
-import { UserTradesSchema, UserTradesWsMessageSchema, } from "./user-trade-history.types";
-export class UserTradeHistoryReader extends BaseReader {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTradeHistoryReader = void 0;
+const base_reader_1 = require("../base-reader");
+const user_trade_history_types_1 = require("./user-trade-history.types");
+class UserTradeHistoryReader 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
@@ -9,7 +12,7 @@ export class UserTradeHistoryReader extends BaseReader {
      */
     async getByAddr({ subAddr, limit = 10, fetchOptions }) {
         const response = await this.getRequest({
-            schema: UserTradesSchema,
+            schema: user_trade_history_types_1.UserTradesSchema,
             url: `${this.deps.config.tradingHttpUrl}/api/v1/trade_history`,
             queryParams: { user: subAddr, limit: limit.toString() },
             options: fetchOptions,
@@ -17,13 +20,14 @@ export class UserTradeHistoryReader extends BaseReader {
         return response.data;
     }
     /**
-     * Subscribe to trade history updates
+     * Subscribe to user trades 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
+     * @param onData Callback function for received user trades data
+     * @returns A function to unsubscribe from the user trades updates
      */
     subscribeByAddr(subAddr, onData) {
-        const topic = `user_trade_history:${subAddr}`;
-        return this.deps.ws.subscribe(topic, UserTradesWsMessageSchema, onData);
+        const topic = `user_trades:${subAddr}`;
+        return this.deps.ws.subscribe(topic, user_trade_history_types_1.UserTradesWsMessageSchema, onData);
     }
 }
+exports.UserTradeHistoryReader = UserTradeHistoryReader;

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

@@ -54,3 +54,4 @@ export declare const UserTradesWsMessageSchema: z.ZodObject<{
 export type UserTrade = z.infer<typeof UserTradeSchema>;
 export type UserTrades = z.infer<typeof UserTradesSchema>;
 export type UserTradesWsMessage = z.infer<typeof UserTradesWsMessageSchema>;
+//# sourceMappingURL=user-trade-history.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user-trade-history.types.d.ts","sourceRoot":"","sources":["../../../src/read/user-trade-history/user-trade-history.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,WAAW,2BAA4B,SAAQ,eAAe;IAClE,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;iBAc1B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;kBAA2B,CAAC;AACzD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;iBAEpC,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-trade-history/user-trade-history.types.js

@@ -1,20 +1,26 @@
-import z from "zod/v4";
-export const UserTradeSchema = z.object({
-    account: z.string(),
-    market: z.string(),
-    action: z.string(),
-    size: z.number(),
-    price: z.number(),
-    is_profit: z.boolean(),
-    realized_pnl_amount: z.number(),
-    is_funding_positive: z.boolean(),
-    realized_funding_amount: z.number(),
-    is_rebate: z.boolean(),
-    fee_amount: z.number(),
-    transaction_unix_ms: z.number(),
-    transaction_version: z.number(),
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserTradesWsMessageSchema = exports.UserTradesSchema = exports.UserTradeSchema = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+exports.UserTradeSchema = v4_1.default.object({
+    account: v4_1.default.string(),
+    market: v4_1.default.string(),
+    action: v4_1.default.string(),
+    size: v4_1.default.number(),
+    price: v4_1.default.number(),
+    is_profit: v4_1.default.boolean(),
+    realized_pnl_amount: 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(),
+    transaction_version: v4_1.default.number(),
 });
-export const UserTradesSchema = z.array(UserTradeSchema);
-export const UserTradesWsMessageSchema = z.object({
-    trades: z.array(UserTradeSchema),
+exports.UserTradesSchema = v4_1.default.array(exports.UserTradeSchema);
+exports.UserTradesWsMessageSchema = v4_1.default.object({
+    trades: v4_1.default.array(exports.UserTradeSchema),
 });

package/dist/read/vaults/vaults.reader.d.ts

@@ -26,7 +26,7 @@ export declare class VaultsReader extends BaseReader {
             average_leverage: number | null;
             depositors: number | null;
             perp_equity: number | null;
-            vault_type: string;
+            vault_type: "user" | "protocol";
             pnl_history: string[] | null;
             social_links: string[] | null;
         }[];
@@ -72,3 +72,4 @@ export declare class VaultsReader extends BaseReader {
         weekly_win_rate_12w: number | null;
     }[]>;
 }
+//# sourceMappingURL=vaults.reader.d.ts.map

package/dist/read/vaults/vaults.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vaults.reader.d.ts","sourceRoot":"","sources":["../../../src/read/vaults/vaults.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EACL,uBAAuB,EACvB,0BAA0B,EAE1B,mCAAmC,EAGpC,MAAM,gBAAgB,CAAC;AAExB,qBAAa,YAAa,SAAQ,UAAU;IAC1C;;;OAGG;IACG,SAAS,CAAC,EAAE,YAAY,EAAE,GAAG,IAAI,EAAE,GAAE,uBAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBvE;;;;OAIG;IACG,kBAAkB,CAAC,EAAE,YAAY,EAAE,GAAG,IAAI,EAAE,EAAE,0BAA0B;;;;;;;;;;;;;;;IAmB9E;;;;OAIG;IACG,2BAA2B,CAAC,EAChC,YAAY,EACZ,GAAG,IAAI,EACR,EAAE,mCAAmC;;;;;;;;;;;;CAcvC"}

package/dist/read/vaults/vaults.reader.js

@@ -1,6 +1,9 @@
-import { BaseReader } from "../base-reader";
-import { UserOwnedVaultsResponseSchema, UserPerformancesOnVaultsResponseSchema, VaultsResponseSchema, } from "./vaults.types";
-export class VaultsReader extends BaseReader {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultsReader = void 0;
+const base_reader_1 = require("../base-reader");
+const vaults_types_1 = require("./vaults.types");
+class VaultsReader extends base_reader_1.BaseReader {
     /**
      * Get all vaults
      * @returns  All vaults
@@ -13,8 +16,12 @@ export class VaultsReader extends BaseReader {
             queryParams.set("limit", args.limit.toString());
         if (args.offset)
             queryParams.set("offset", args.offset.toString());
+        if (args.address)
+            queryParams.set("vault_address", args.address);
+        if (args.search)
+            queryParams.set("search", args.search);
         const response = await this.getRequest({
-            schema: VaultsResponseSchema,
+            schema: vaults_types_1.VaultsResponseSchema,
             url: `${this.deps.config.tradingHttpUrl}/api/v1/vaults`,
             queryParams,
             options: fetchOptions,
@@ -35,7 +42,7 @@ export class VaultsReader extends BaseReader {
         if (args.offset)
             queryParams.set("offset", args.offset.toString());
         const response = await this.getRequest({
-            schema: UserOwnedVaultsResponseSchema,
+            schema: vaults_types_1.UserOwnedVaultsResponseSchema,
             url: `${this.deps.config.tradingHttpUrl}/api/v1/user_owned_vaults`,
             queryParams,
             options: fetchOptions,
@@ -52,7 +59,7 @@ export class VaultsReader extends BaseReader {
             user_address: args.ownerAddr,
         });
         const response = await this.getRequest({
-            schema: UserPerformancesOnVaultsResponseSchema,
+            schema: vaults_types_1.UserPerformancesOnVaultsResponseSchema,
             url: `${this.deps.config.tradingHttpUrl}/api/v1/user_vault_performance`,
             queryParams,
             options: fetchOptions,
@@ -60,3 +67,4 @@ export class VaultsReader extends BaseReader {
         return response.data;
     }
 }
+exports.VaultsReader = VaultsReader;

package/dist/read/vaults/vaults.types.d.ts

@@ -8,11 +8,14 @@ export interface UserOwnedVaultsRequestArgs extends BaseRequestArgs {
     limit?: number;
     offset?: number;
 }
+export declare const vaultTypeValues: readonly ["user", "protocol"];
+export type VaultType = (typeof vaultTypeValues)[number];
 export interface PublicVaultsRequestArgs extends BaseRequestArgs {
     limit?: number;
     offset?: number;
-    vaultType?: "user" | "protocol";
+    vaultType?: VaultType;
     address?: string;
+    search?: string;
 }
 /**
  * Arguments for fetching user performance metrics for a specific subaccount
@@ -44,7 +47,10 @@ export declare const VaultSchema: z.ZodObject<{
     average_leverage: z.ZodNullable<z.ZodNumber>;
     depositors: z.ZodNullable<z.ZodNumber>;
     perp_equity: z.ZodNullable<z.ZodNumber>;
-    vault_type: z.ZodString;
+    vault_type: z.ZodEnum<{
+        user: "user";
+        protocol: "protocol";
+    }>;
     pnl_history: z.ZodNullable<z.ZodArray<z.ZodString>>;
     social_links: z.ZodNullable<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
@@ -69,7 +75,10 @@ export declare const VaultsResponseSchema: z.ZodObject<{
         average_leverage: z.ZodNullable<z.ZodNumber>;
         depositors: z.ZodNullable<z.ZodNumber>;
         perp_equity: z.ZodNullable<z.ZodNumber>;
-        vault_type: z.ZodString;
+        vault_type: z.ZodEnum<{
+            user: "user";
+            protocol: "protocol";
+        }>;
         pnl_history: z.ZodNullable<z.ZodArray<z.ZodString>>;
         social_links: z.ZodNullable<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
@@ -144,3 +153,4 @@ export declare const UserPerformancesOnVaultsResponseSchema: z.ZodArray<z.ZodObj
 }, z.core.$strip>>;
 export type UserPerformanceOnVault = z.infer<typeof UserPerformanceOnVaultSchema>;
 export type UserPerformancesOnVaults = UserPerformanceOnVault[];
+//# sourceMappingURL=vaults.types.d.ts.map

package/dist/read/vaults/vaults.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vaults.types.d.ts","sourceRoot":"","sources":["../../../src/read/vaults/vaults.types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD;;GAEG;AACH,MAAM,WAAW,0BAA2B,SAAQ,eAAe;IACjE,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,eAAe,+BAAgC,CAAC;AAC7D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AACzD,MAAM,WAAW,uBAAwB,SAAQ,eAAe;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,mCAAoC,SAAQ,eAAe;IAC1E,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBtB,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAChD,MAAM,MAAM,MAAM,GAAG,KAAK,EAAE,CAAC;AAE7B;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;iBAW/B,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;iBAAgD,CAAC;AAC3F,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,cAAc,EAAE,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;iBAWvC,CAAC;AACH,eAAO,MAAM,sCAAsC;;;;;;;;;;;kBAAwC,CAAC;AAC5F,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,wBAAwB,GAAG,sBAAsB,EAAE,CAAC"}

package/dist/read/vaults/vaults.types.js

@@ -1,68 +1,75 @@
-import z from "zod/v4";
-import { PaginatedResponseSchema } from "../pagination.types";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPerformancesOnVaultsResponseSchema = exports.UserPerformanceOnVaultSchema = exports.UserOwnedVaultsResponseSchema = exports.UserOwnedVaultSchema = exports.VaultsResponseSchema = exports.VaultSchema = exports.vaultTypeValues = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+const pagination_types_1 = require("../pagination.types");
+exports.vaultTypeValues = ["user", "protocol"];
 /**
  * Schema for a vault in the protocol
  * Represents both protocol-wide vaults and user-managed vaults
  */
-export const VaultSchema = z.object({
-    address: z.string(),
-    name: z.string(),
-    description: z.string().nullable(),
-    manager: z.string(),
-    status: z.string(),
-    created_at: z.number(),
-    tvl: z.number().nullable(),
-    volume: z.number().nullable(),
-    all_time_return: z.number().nullable(),
-    past_month_return: z.number().nullable(),
-    sharpe_ratio: z.number().nullable(),
-    max_drawdown: z.number().nullable(),
-    weekly_win_rate_12w: z.number().nullable(),
-    profit_share: z.number().nullable(),
-    pnl_90d: z.number().nullable(),
-    manager_avg_cash: z.number().nullable(),
-    average_leverage: z.number().nullable(),
-    depositors: z.number().nullable(),
-    perp_equity: z.number().nullable(),
-    vault_type: z.string(),
-    pnl_history: z.array(z.string()).nullable(),
-    social_links: z.array(z.string()).nullable(),
+exports.VaultSchema = v4_1.default.object({
+    address: v4_1.default.string(),
+    name: v4_1.default.string(),
+    description: v4_1.default.string().nullable(),
+    manager: v4_1.default.string(),
+    status: v4_1.default.string(),
+    created_at: v4_1.default.number(),
+    tvl: v4_1.default.number().nullable(),
+    volume: v4_1.default.number().nullable(),
+    all_time_return: v4_1.default.number().nullable(),
+    past_month_return: v4_1.default.number().nullable(),
+    sharpe_ratio: v4_1.default.number().nullable(),
+    max_drawdown: v4_1.default.number().nullable(),
+    weekly_win_rate_12w: v4_1.default.number().nullable(),
+    profit_share: v4_1.default.number().nullable(),
+    pnl_90d: v4_1.default.number().nullable(),
+    manager_avg_cash: v4_1.default.number().nullable(),
+    average_leverage: v4_1.default.number().nullable(),
+    depositors: v4_1.default.number().nullable(),
+    perp_equity: v4_1.default.number().nullable(),
+    vault_type: v4_1.default.enum(exports.vaultTypeValues),
+    pnl_history: v4_1.default.array(v4_1.default.string()).nullable(),
+    social_links: v4_1.default.array(v4_1.default.string()).nullable(),
 });
-export const VaultsResponseSchema = PaginatedResponseSchema(VaultSchema).extend({
-    total_value_locked: z.number(),
-    total_volume: z.number(),
+exports.VaultsResponseSchema = (0, pagination_types_1.PaginatedResponseSchema)(exports.VaultSchema).extend({
+    total_value_locked: v4_1.default.number(),
+    total_volume: v4_1.default.number(),
 });
 /**
  * Schema for vaults owned/managed by a specific user
  * Contains summary information about vaults the user manages
  */
-export const UserOwnedVaultSchema = z.object({
-    vault_address: z.string(),
-    vault_name: z.string(),
-    vault_share_symbol: z.string(),
-    status: z.string(),
-    age_days: z.number(),
-    num_managers: z.number(),
-    tvl: z.number().nullable(),
-    apr: z.number().nullable(),
-    manager_equity: z.number().nullable(),
-    manager_stake: z.number().nullable(),
+exports.UserOwnedVaultSchema = v4_1.default.object({
+    vault_address: v4_1.default.string(),
+    vault_name: v4_1.default.string(),
+    vault_share_symbol: v4_1.default.string(),
+    status: v4_1.default.string(),
+    age_days: v4_1.default.number(),
+    num_managers: v4_1.default.number(),
+    tvl: v4_1.default.number().nullable(),
+    apr: v4_1.default.number().nullable(),
+    manager_equity: v4_1.default.number().nullable(),
+    manager_stake: v4_1.default.number().nullable(),
 });
-export const UserOwnedVaultsResponseSchema = PaginatedResponseSchema(UserOwnedVaultSchema);
+exports.UserOwnedVaultsResponseSchema = (0, pagination_types_1.PaginatedResponseSchema)(exports.UserOwnedVaultSchema);
 /**
  * Schema for user performance metrics within a vault
  * Tracks a user's deposits, shares, returns, and PnL for a specific vault
  */
-export const UserPerformanceOnVaultSchema = z.object({
-    vault_address: z.string(),
-    user_address: z.string(),
-    net_deposits: z.number().nullable(),
-    current_num_shares: z.number().nullable(),
-    current_value_of_shares: z.number().nullable(),
-    all_time_return: z.number().nullable(),
-    unrealized_pnl: z.number().nullable(),
-    share_price: z.number(),
-    volume: z.number(),
-    weekly_win_rate_12w: z.number().nullable(),
+exports.UserPerformanceOnVaultSchema = v4_1.default.object({
+    vault_address: v4_1.default.string(),
+    user_address: v4_1.default.string(),
+    net_deposits: v4_1.default.number().nullable(),
+    current_num_shares: v4_1.default.number().nullable(),
+    current_value_of_shares: v4_1.default.number().nullable(),
+    all_time_return: v4_1.default.number().nullable(),
+    unrealized_pnl: v4_1.default.number().nullable(),
+    share_price: v4_1.default.number(),
+    volume: v4_1.default.number(),
+    weekly_win_rate_12w: v4_1.default.number().nullable(),
 });
-export const UserPerformancesOnVaultsResponseSchema = z.array(UserPerformanceOnVaultSchema);
+exports.UserPerformancesOnVaultsResponseSchema = v4_1.default.array(exports.UserPerformanceOnVaultSchema);

package/dist/read/ws-subscription.d.ts

@@ -18,3 +18,4 @@ export declare class DecibelWsSubscription {
     close(): void;
     readyState(): 0 | 2 | 1 | 3;
 }
+//# sourceMappingURL=ws-subscription.d.ts.map

package/dist/read/ws-subscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-subscription.d.ts","sourceRoot":"","sources":["../../src/read/ws-subscription.ts"],"names":[],"mappings":"AAAA,OAAkB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C,qBAAa,qBAAqB;;IAE9B,QAAQ,CAAC,MAAM,EAAE,aAAa;IAC9B,QAAQ,CAAC,OAAO,CAAC,GAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI;gBADrC,MAAM,EAAE,aAAa,EACrB,OAAO,CAAC,GAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,aAAA;IA+FhD,SAAS,CAAC,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EAC/B,MAAM,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCtD,OAAO,CAAC,WAAW;IAqBnB;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAoB7B,KAAK,CAAC,KAAK,EAAE,MAAM;IAYnB,KAAK;IAKL,UAAU;CAGX"}

package/dist/read/ws-subscription.js

@@ -1,6 +1,12 @@
-import WebSocket from "isomorphic-ws";
-import { bigIntReviver, prettifyMaybeZodError } from "../utils";
-export class DecibelWsSubscription {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecibelWsSubscription = void 0;
+const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+const utils_1 = require("../utils");
+class DecibelWsSubscription {
     config;
     onError;
     constructor(config, onError) {
@@ -21,7 +27,7 @@ export class DecibelWsSubscription {
             return null;
         }
         try {
-            const jsonData = JSON.parse(data, bigIntReviver);
+            const jsonData = JSON.parse(data, utils_1.bigIntReviver);
             if (jsonData &&
                 typeof jsonData === "object" &&
                 "topic" in jsonData &&
@@ -39,7 +45,7 @@ export class DecibelWsSubscription {
         if (this.#ws) {
             return;
         }
-        const ws = new WebSocket(this.config.tradingWsUrl);
+        const ws = new isomorphic_ws_1.default(this.config.tradingWsUrl);
         ws.addEventListener("open", () => {
             this.#reconnectAttempts = 0;
             this.#subscriptions.keys().forEach((topic) => {
@@ -88,7 +94,7 @@ export class DecibelWsSubscription {
         const listeners = this.#subscriptions.get(topic) ?? new Set();
         // If subscription arent found, subscribe to topic first
         if (listeners.size === 0) {
-            if (this.#ws?.readyState === WebSocket.OPEN) {
+            if (this.#ws?.readyState === isomorphic_ws_1.default.OPEN) {
                 this.#ws.send(this.#getSubscribeMessage(topic));
             }
         }
@@ -98,7 +104,7 @@ export class DecibelWsSubscription {
                 void onData(parsedData);
             }
             catch (e) {
-                throw prettifyMaybeZodError(e);
+                throw (0, utils_1.prettifyMaybeZodError)(e);
             }
         };
         listeners.add(listener);
@@ -113,7 +119,7 @@ export class DecibelWsSubscription {
         if (!this.#subscriptions.has(topic))
             return;
         this.#subscriptions.delete(topic);
-        if (this.#ws?.readyState === WebSocket.OPEN) {
+        if (this.#ws?.readyState === isomorphic_ws_1.default.OPEN) {
             this.#ws.send(this.#getUnsubscribeMessage(topic));
         }
         // Close the WebSocket if the last subscription was removed.
@@ -153,7 +159,7 @@ export class DecibelWsSubscription {
         if (!this.#subscriptions.has(topic)) {
             return;
         }
-        if (this.#ws?.readyState === WebSocket.OPEN) {
+        if (this.#ws?.readyState === isomorphic_ws_1.default.OPEN) {
             this.#ws.send(this.#getUnsubscribeMessage(topic));
             this.#ws.send(this.#getSubscribeMessage(topic));
             return;
@@ -164,6 +170,7 @@ export class DecibelWsSubscription {
         this.#ws?.close();
     }
     readyState() {
-        return this.#ws?.readyState ?? WebSocket.CLOSED;
+        return this.#ws?.readyState ?? isomorphic_ws_1.default.CLOSED;
     }
 }
+exports.DecibelWsSubscription = DecibelWsSubscription;

package/dist/subaccount-types.d.ts

@@ -21,3 +21,4 @@ export declare const RenameSubaccountSchema: z.ZodObject<{
     new_name: z.ZodString;
 }, z.core.$strip>;
 export type RenameSubaccount = z.infer<typeof RenameSubaccountSchema>;
+//# sourceMappingURL=subaccount-types.d.ts.map

package/dist/subaccount-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subaccount-types.d.ts","sourceRoot":"","sources":["../src/subaccount-types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAIvB,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,4BAA4B;IAC3C,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACvC,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAED,MAAM,WAAW,oBAAoB;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/subaccount-types.js

@@ -1,5 +1,11 @@
-import z from "zod/v4";
-export const RenameSubaccountSchema = z.object({
-    subaccount_address: z.string(),
-    new_name: z.string(),
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenameSubaccountSchema = void 0;
+const v4_1 = __importDefault(require("zod/v4"));
+exports.RenameSubaccountSchema = v4_1.default.object({
+    subaccount_address: v4_1.default.string(),
+    new_name: v4_1.default.string(),
 });

package/dist/transaction-builder.d.ts

@@ -11,3 +11,4 @@ export declare function buildSimpleTransactionSync(args: {
     timeDeltaMs?: number;
 }): SimpleTransaction;
 export declare const generateExpireTimestamp: (aptosConfig: AptosConfig, timeDeltaMs?: number) => number;
+//# sourceMappingURL=transaction-builder.d.ts.map