@pear-protocol/core-sdk 2.2.0 → 2.4.0

package/dist/core/index.js

@@ -567,6 +567,7 @@ class Core {
         const file = await gzipJson(body);
         const formData = new FormData();
         formData.append("file", file, "payload.json.gz");
+        formData.append("executionsUpdatedAtEpochMs", String(body.meta.executionsUpdatedAtEpochMs));
         return await this.client.fetch(`/sync/fills/create/bulk`, {
           method: "POST",
           headers: {

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { Core } from './core/index.js';
 import { External } from './external/index.js';
 import { SDKConfig } from './types.js';
 export { AuthErrorContext } from './types.js';
+import { Vaults } from './vaults/index.js';
 export { ExternalTrigger, ExternalTriggerSource, HttpTypes, SearchTriggersParams, SearchTriggersResponse, TriggerOutcome } from '@pear-protocol/types';
 export * from '@pear-protocol/utils';
 export { FetchError } from './utils.js';
@@ -14,6 +15,7 @@ declare class PearSDK {
     auth: Auth;
     core: Core;
     external: External;
+    vaults: Vaults;
     constructor(config: SDKConfig);
 }
 

package/dist/index.js

@@ -7,6 +7,7 @@ export { External } from './external';
 import { HttpClient } from './http';
 import { FetchError } from './utils';
 export { FetchError } from './utils';
+import { Vaults } from './vaults';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -18,6 +19,7 @@ class PearSDK {
   auth;
   core;
   external;
+  vaults;
   constructor(config) {
     if (config.proxy) configureProxy(config.proxy);
     const authMode = config.auth?.type ?? "session";
@@ -32,6 +34,7 @@ class PearSDK {
     this.auth = new Auth(client);
     this.core = new Core(client, config.clientId);
     this.external = new External();
+    this.vaults = new Vaults(client);
     if (authMode === "session") {
       let refreshInFlight = null;
       const retried = /* @__PURE__ */ new WeakSet();

package/dist/vaults/index.d.ts

@@ -0,0 +1,426 @@
+import { HttpTypes } from '@pear-protocol/types';
+import { HttpClient } from '../http.js';
+import { ClientHeaders } from '../types.js';
+import '@pear-protocol/utils';
+
+/** Typed vaults client over the gateway base URL — one method per public vault-service route. */
+
+/** Typed client for all vault-service routes. */
+declare class Vaults {
+    private readonly client;
+    /** Bind the shared HTTP client this surface dispatches through. */
+    constructor(client: HttpClient);
+    /** POST /vaults — create a vault from the leader-signed envelope. */
+    create: (body: HttpTypes.CreateVaultInput, headers?: ClientHeaders) => Promise<{
+        result: {
+            success: true;
+            vaultAddress: HttpTypes.EthereumAddress;
+            agentAddress: HttpTypes.EthereumAddress;
+            ownerAddress: HttpTypes.EthereumAddress;
+            status: "active" | "inactive" | "pending_activation";
+            maxWithdrawalPeriodDays: number;
+            txHash: string;
+        } | {
+            success: false;
+            status: "in_progress";
+            activityId: string;
+        };
+    }>;
+    /** GET /vaults — list vaults with optional filter params. */
+    list: (query?: HttpTypes.VaultListParamsInput, headers?: ClientHeaders) => Promise<{
+        vaults: {
+            id: string;
+            vaultAddress: HttpTypes.EthereumAddress;
+            ownerAddress: HttpTypes.EthereumAddress;
+            traderAddress: HttpTypes.EthereumAddress | null;
+            agentAddress: HttpTypes.EthereumAddress;
+            status: "active" | "inactive" | "pending_activation";
+            isApproved: boolean;
+            name: string | null;
+            about: string | null;
+            imageUrl: string | null;
+            transactionHash: string | null;
+            maxWithdrawalPeriodDays: number;
+            createdAt: string;
+            updatedAt: string;
+        }[];
+    }>;
+    /** GET /vaults/:vaultAddress — fetch a single vault by its on-chain address. */
+    get: (vaultAddress: string, headers?: ClientHeaders) => Promise<{
+        vault: {
+            id: string;
+            vaultAddress: HttpTypes.EthereumAddress;
+            ownerAddress: HttpTypes.EthereumAddress;
+            traderAddress: HttpTypes.EthereumAddress | null;
+            agentAddress: HttpTypes.EthereumAddress;
+            status: "active" | "inactive" | "pending_activation";
+            isApproved: boolean;
+            name: string | null;
+            about: string | null;
+            imageUrl: string | null;
+            transactionHash: string | null;
+            maxWithdrawalPeriodDays: number;
+            createdAt: string;
+            updatedAt: string;
+        };
+    }>;
+    /** GET /vaults/overview — fetch aggregate overview stats across vaults. */
+    overview: (query?: HttpTypes.VaultsOverviewQueryParamsInput, headers?: ClientHeaders) => Promise<{
+        items: {
+            vaultAddress: HttpTypes.EthereumAddress;
+            agentAddress: HttpTypes.EthereumAddress;
+            leaderAddress: HttpTypes.EthereumAddress;
+            name: string | null;
+            imageUrl: string | null;
+            latest: {
+                tvl: string;
+                sharePrice: string;
+                accountValue: string | null;
+                openInterest: string | null;
+                unrealizedPnl: string | null;
+                cumulativeRealizedPnl: string | null;
+                investorCount: number;
+                createdAt: string;
+            } | null;
+            sparkline: {
+                timestamp: number;
+                createdAt: string;
+                tvl: string;
+                sharePrice: string;
+            }[];
+        }[];
+        page: number;
+        pageSize: number;
+        total: number;
+    }>;
+    /** GET /vaults/investments — list investor positions across all vaults. */
+    investments: (query: HttpTypes.VaultInvestmentsQueryParamsInput, headers?: ClientHeaders) => Promise<{
+        totals: {
+            totalInvested: number;
+            totalCurrentValue: number;
+            totalPnl: number;
+            totalUnrealizedPnl: number;
+        };
+        investments: {
+            vaultAddress: HttpTypes.EthereumAddress;
+            name: string | null;
+            imageUrl: string | null;
+            isLeader: boolean;
+            depositAmount: string;
+            currentValue: string;
+            allTimePnl: number;
+            unrealizedPnl: number;
+            shares: string;
+        }[];
+        partial: boolean;
+        failedVaults: {
+            vaultAddress: HttpTypes.EthereumAddress;
+            name: string | null;
+            reason: string;
+        }[];
+    }>;
+    /** GET /vaults/:vaultAddress/stats — fetch performance stats for a vault. */
+    stats: (vaultAddress: string, query?: HttpTypes.VaultStatsQueryParamsInput, headers?: ClientHeaders) => Promise<{
+        tvl: string;
+        totalSupply: string;
+        sharePrice: string;
+        withdrawalFeeBps: number;
+        leaderInvestment: {
+            depositAmount: string;
+            currentValue: string;
+            shares: string;
+            percentageOfTVL: number;
+        };
+        totalPnl: number;
+        totalPnlPercentage: number | null;
+        thirtyDayPnl: number;
+        apr: number | null;
+        maxDrawdown: number | null;
+        winRate: number | null;
+        profitFactor: number | null;
+        unrealizedPnl: number;
+        investors: {
+            address: string;
+            depositAmount: string;
+            shares: string;
+            currentValue: string;
+        }[];
+        tradedVolume?: number | undefined;
+        userStats?: {
+            allTimePnl: number;
+            depositAmount: string;
+            currentValue: string;
+            shares: string;
+            unrealizedPnl: number;
+        } | undefined;
+    }>;
+    snapshots: {
+        /** POST /vaults/snapshots/bulk — ingest a batch of vault snapshots. */
+        bulk: (body: HttpTypes.SnapshotsBulkInput, headers?: ClientHeaders) => Promise<{
+            snapshots: Record<string, {
+                timestamp: number;
+                createdAt: string;
+                tvl?: string | undefined;
+                sharePrice?: string | undefined;
+                accountValue?: null | undefined;
+                unrealizedPnl?: null | undefined;
+                cumulativeRealizedPnl?: null | undefined;
+                leaderSharePct?: null | undefined;
+            }[]>;
+        }>;
+    };
+    activity: {
+        /** GET /vaults/:vaultAddress/activity — list activity events for a vault. */
+        list: (vaultAddress: string, headers?: ClientHeaders) => Promise<{
+            vaultAddress: string;
+            activity: {
+                id: string;
+                type: "vault.create" | "vault.set_trader" | "vault.update_metadata" | "bridge.withdraw_to_evm";
+                status: "failed" | "pending" | "succeeded";
+                createdAt: string;
+                updatedAt: string;
+                vaultAddress?: string | undefined;
+                txHash?: string | undefined;
+                error?: string | undefined;
+            }[];
+        }>;
+        /** GET /vaults/activity/:id — fetch a single activity event by ID. */
+        get: (id: string, headers?: ClientHeaders) => Promise<{
+            activity: {
+                id: string;
+                type: "vault.create" | "vault.set_trader" | "vault.update_metadata" | "bridge.withdraw_to_evm";
+                status: "failed" | "pending" | "succeeded";
+                createdAt: string;
+                updatedAt: string;
+                vaultAddress?: string | undefined;
+                txHash?: string | undefined;
+                error?: string | undefined;
+            };
+        }>;
+    };
+    transactions: {
+        /** GET /vaults/:vaultAddress/transactions — list on-chain transactions for a vault. */
+        list: (vaultAddress: string, query?: HttpTypes.VaultEventListParamsInput, headers?: ClientHeaders) => Promise<{
+            events: {
+                id: string;
+                vaultAddress: HttpTypes.EthereumAddress;
+                eventType: "DEPOSIT" | "WITHDRAWAL";
+                userAddress: HttpTypes.EthereumAddress;
+                receiver: HttpTypes.EthereumAddress;
+                assets: string;
+                shares: string;
+                fee: string;
+                withdrawalId: string | null;
+                txHash: string;
+                blockNumber: string;
+                logIndex: number;
+                createdAt: string;
+            }[];
+        }>;
+    };
+    metadata: {
+        /** PATCH /vaults/:vaultAddress — update mutable metadata fields on a vault. */
+        update: (vaultAddress: string, body: HttpTypes.UpdateVaultMetadataInput, headers?: ClientHeaders) => Promise<{
+            result: {
+                success: true;
+                vault: {
+                    id: string;
+                    vaultAddress: HttpTypes.EthereumAddress;
+                    ownerAddress: HttpTypes.EthereumAddress;
+                    traderAddress: HttpTypes.EthereumAddress | null;
+                    agentAddress: HttpTypes.EthereumAddress;
+                    status: "active" | "inactive" | "pending_activation";
+                    isApproved: boolean;
+                    name: string | null;
+                    about: string | null;
+                    imageUrl: string | null;
+                    transactionHash: string | null;
+                    maxWithdrawalPeriodDays: number;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            } | {
+                success: false;
+                status: "in_progress";
+                activityId: string;
+            };
+        }>;
+    };
+    trader: {
+        /** POST /vaults/:vaultAddress/trader — assign a new trader to a vault. */
+        set: (vaultAddress: string, body: HttpTypes.SetTraderInput, headers?: ClientHeaders) => Promise<{
+            result: {
+                success: true;
+                vault: {
+                    id: string;
+                    vaultAddress: HttpTypes.EthereumAddress;
+                    ownerAddress: HttpTypes.EthereumAddress;
+                    traderAddress: HttpTypes.EthereumAddress | null;
+                    agentAddress: HttpTypes.EthereumAddress;
+                    status: "active" | "inactive" | "pending_activation";
+                    isApproved: boolean;
+                    name: string | null;
+                    about: string | null;
+                    imageUrl: string | null;
+                    transactionHash: string | null;
+                    maxWithdrawalPeriodDays: number;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            } | {
+                success: false;
+                status: "in_progress";
+                activityId: string;
+            };
+        }>;
+    };
+    /** POST /vaults/:vaultAddress/withdraw-to-evm — initiate an EVM-side withdrawal from a vault. */
+    withdrawToEvm: (vaultAddress: string, body: HttpTypes.WithdrawToEvmInput, headers?: ClientHeaders) => Promise<{
+        result: {
+            success: true;
+            amount: string;
+            token: string;
+            tokenId: string;
+            destination: string;
+            vaultAddress: string;
+            activityId: string;
+            bridgeStatus: string;
+            bridgeSettleMs: number;
+            transferTxHash: string;
+        } | {
+            success: false;
+            status: "in_progress";
+            amount: string;
+            token: string;
+            tokenId: string;
+            destination: string;
+            vaultAddress: string;
+            activityId: string;
+        };
+    }>;
+    agent: {
+        /** GET /vaults/:vaultAddress/balances — fetch agent balances for a vault. */
+        balances: (vaultAddress: string, headers?: ClientHeaders) => Promise<{
+            agentAddress: string;
+            spot: Record<string, string>;
+            perp: {
+                accountValue: string;
+                withdrawable: string;
+            };
+        }>;
+        /** POST /vaults/:vaultAddress/agent/approve — approve an agent action for a vault. */
+        approve: (vaultAddress: string, body: HttpTypes.AgentApproveInput, headers?: ClientHeaders) => Promise<{
+            result: {
+                success: true;
+                transactionHash: string;
+                tokenAddress: string;
+                spender: string;
+                amount: string;
+            } | {
+                success: false;
+                status: "already_approved";
+                tokenAddress: string;
+                spender: string;
+                allowance: string;
+            };
+        }>;
+        /** POST /vaults/:vaultAddress/set-unified-account — configure the unified account for a vault agent. */
+        setUnifiedAccount: (vaultAddress: string, body: HttpTypes.SetUnifiedAccountInput, headers?: ClientHeaders) => Promise<{
+            success: boolean;
+            agentAddress: string;
+        }>;
+    };
+    nav: {
+        /** GET /vaults/:vaultAddress/nav/latest — fetch the most recent NAV snapshot for a vault. */
+        latest: (vaultAddress: string, headers?: ClientHeaders) => Promise<{
+            snapshot: {
+                vaultAddress: HttpTypes.EthereumAddress;
+                takenAt: string;
+                totalAssets: string;
+                totalSupply: string;
+                sharePrice: string;
+                blockNumber: string;
+            };
+        }>;
+        /** GET /vaults/:vaultAddress/nav — fetch NAV snapshots over a time range for a vault. */
+        range: (vaultAddress: string, query: HttpTypes.NavRangeQueryParamsInput, headers?: ClientHeaders) => Promise<{
+            points: {
+                bucket: string;
+                totalAssets: string;
+                totalSupply: string;
+                sharePrice: string;
+                blockNumber: string;
+            }[];
+        }>;
+        /** GET /vaults/:vaultAddress/nav/stats — fetch NAV performance statistics for a vault. */
+        stats: (vaultAddress: string, query: HttpTypes.NavStatsQueryParams, headers?: ClientHeaders) => Promise<{
+            window: "24h" | "7d" | "30d";
+            samples: number;
+            returnPct: number | null;
+            sharePriceMin: string | null;
+            sharePriceMax: string | null;
+            sharePriceFirst: string | null;
+            sharePriceLast: string | null;
+        }>;
+    };
+    positions: {
+        /** GET /vaults/:vaultAddress/positions/open — list open positions held by a vault. */
+        open: (vaultAddress: string, query?: HttpTypes.VaultOpenPositionListParamsInput, headers?: ClientHeaders) => Promise<{
+            limit: number;
+            vaultAddress: HttpTypes.EthereumAddress;
+            positions: {
+                status: "OPEN";
+                connector: "hyperliquid" | "binance" | "bybit" | "okx" | "lighter" | "lighter_rhc";
+                updatedAt: string;
+                positionId: string;
+                openedAt: string;
+                realizedGrossPnl: `-${string}` | `+${string}`;
+                netCashflow: `-${string}` | `+${string}`;
+                legs: {
+                    side: "LONG" | "SHORT";
+                    asset: string;
+                    realized: {
+                        quantity: string;
+                        unpricedQuantity: string;
+                        grossPnl: `-${string}` | `+${string}`;
+                        netPnl: `-${string}` | `+${string}`;
+                        exitVwap?: string | undefined;
+                    };
+                    remaining: {
+                        quantity: `-${string}` | `+${string}`;
+                        entryVwap?: string | undefined;
+                    };
+                }[];
+            }[];
+            nextCursor?: string | undefined;
+        }>;
+        /** GET /vaults/:vaultAddress/positions/closed — list closed positions held by a vault. */
+        closed: (vaultAddress: string, query?: HttpTypes.VaultClosedPositionListParamsInput, headers?: ClientHeaders) => Promise<{
+            limit: number;
+            vaultAddress: HttpTypes.EthereumAddress;
+            positions: {
+                status: "CLOSED";
+                connector: "hyperliquid" | "binance" | "bybit" | "okx" | "lighter" | "lighter_rhc";
+                closedAt: string;
+                grossPnl: `-${string}` | `+${string}`;
+                netPnl: `-${string}` | `+${string}`;
+                positionId: string;
+                openedAt: string;
+                hasProvisionalFills: boolean;
+                legs: {
+                    side: "LONG" | "SHORT";
+                    asset: string;
+                    grossPnl: `-${string}` | `+${string}`;
+                    netPnl: `-${string}` | `+${string}`;
+                    entryNotional: string;
+                    entryVwap?: string | undefined;
+                    exitVwap?: string | undefined;
+                }[];
+                closedReason?: "USER" | "NETTED" | "LIQUIDATED" | undefined;
+            }[];
+            nextCursor?: string | undefined;
+        }>;
+    };
+}
+
+export { Vaults };

package/dist/vaults/index.js

@@ -0,0 +1,193 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+class Vaults {
+  static {
+    __name(this, "Vaults");
+  }
+  client;
+  /** Bind the shared HTTP client this surface dispatches through. */
+  constructor(client) {
+    this.client = client;
+  }
+  /** POST /vaults — create a vault from the leader-signed envelope. */
+  create = /* @__PURE__ */ __name(async (body, headers) => {
+    return await this.client.fetch(`/vaults`, {
+      method: "POST",
+      headers,
+      body
+    });
+  }, "create");
+  /** GET /vaults — list vaults with optional filter params. */
+  list = /* @__PURE__ */ __name(async (query, headers) => {
+    return await this.client.fetch(`/vaults`, {
+      method: "GET",
+      headers,
+      query
+    });
+  }, "list");
+  /** GET /vaults/:vaultAddress — fetch a single vault by its on-chain address. */
+  get = /* @__PURE__ */ __name(async (vaultAddress, headers) => {
+    return await this.client.fetch(`/vaults/${vaultAddress}`, {
+      method: "GET",
+      headers
+    });
+  }, "get");
+  /** GET /vaults/overview — fetch aggregate overview stats across vaults. */
+  overview = /* @__PURE__ */ __name(async (query, headers) => {
+    return await this.client.fetch(`/vaults/overview`, {
+      method: "GET",
+      headers,
+      query
+    });
+  }, "overview");
+  /** GET /vaults/investments — list investor positions across all vaults. */
+  investments = /* @__PURE__ */ __name(async (query, headers) => {
+    return await this.client.fetch(`/vaults/investments`, {
+      method: "GET",
+      headers,
+      query
+    });
+  }, "investments");
+  /** GET /vaults/:vaultAddress/stats — fetch performance stats for a vault. */
+  stats = /* @__PURE__ */ __name(async (vaultAddress, query, headers) => {
+    return await this.client.fetch(`/vaults/${vaultAddress}/stats`, {
+      method: "GET",
+      headers,
+      query
+    });
+  }, "stats");
+  snapshots = {
+    /** POST /vaults/snapshots/bulk — ingest a batch of vault snapshots. */
+    bulk: /* @__PURE__ */ __name(async (body, headers) => {
+      return await this.client.fetch(`/vaults/snapshots/bulk`, {
+        method: "POST",
+        headers,
+        body
+      });
+    }, "bulk")
+  };
+  activity = {
+    /** GET /vaults/:vaultAddress/activity — list activity events for a vault. */
+    list: /* @__PURE__ */ __name(async (vaultAddress, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/activity`, {
+        method: "GET",
+        headers
+      });
+    }, "list"),
+    /** GET /vaults/activity/:id — fetch a single activity event by ID. */
+    get: /* @__PURE__ */ __name(async (id, headers) => {
+      return await this.client.fetch(`/vaults/activity/${id}`, {
+        method: "GET",
+        headers
+      });
+    }, "get")
+  };
+  transactions = {
+    /** GET /vaults/:vaultAddress/transactions — list on-chain transactions for a vault. */
+    list: /* @__PURE__ */ __name(async (vaultAddress, query, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/transactions`, {
+        method: "GET",
+        headers,
+        query
+      });
+    }, "list")
+  };
+  metadata = {
+    /** PATCH /vaults/:vaultAddress — update mutable metadata fields on a vault. */
+    update: /* @__PURE__ */ __name(async (vaultAddress, body, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}`, {
+        method: "PATCH",
+        headers,
+        body
+      });
+    }, "update")
+  };
+  trader = {
+    /** POST /vaults/:vaultAddress/trader — assign a new trader to a vault. */
+    set: /* @__PURE__ */ __name(async (vaultAddress, body, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/trader`, {
+        method: "POST",
+        headers,
+        body
+      });
+    }, "set")
+  };
+  /** POST /vaults/:vaultAddress/withdraw-to-evm — initiate an EVM-side withdrawal from a vault. */
+  withdrawToEvm = /* @__PURE__ */ __name(async (vaultAddress, body, headers) => {
+    return await this.client.fetch(`/vaults/${vaultAddress}/withdraw-to-evm`, {
+      method: "POST",
+      headers,
+      body
+    });
+  }, "withdrawToEvm");
+  agent = {
+    /** GET /vaults/:vaultAddress/balances — fetch agent balances for a vault. */
+    balances: /* @__PURE__ */ __name(async (vaultAddress, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/balances`, {
+        method: "GET",
+        headers
+      });
+    }, "balances"),
+    /** POST /vaults/:vaultAddress/agent/approve — approve an agent action for a vault. */
+    approve: /* @__PURE__ */ __name(async (vaultAddress, body, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/agent/approve`, {
+        method: "POST",
+        headers,
+        body
+      });
+    }, "approve"),
+    /** POST /vaults/:vaultAddress/set-unified-account — configure the unified account for a vault agent. */
+    setUnifiedAccount: /* @__PURE__ */ __name(async (vaultAddress, body, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/set-unified-account`, {
+        method: "POST",
+        headers,
+        body
+      });
+    }, "setUnifiedAccount")
+  };
+  nav = {
+    /** GET /vaults/:vaultAddress/nav/latest — fetch the most recent NAV snapshot for a vault. */
+    latest: /* @__PURE__ */ __name(async (vaultAddress, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/nav/latest`, {
+        method: "GET",
+        headers
+      });
+    }, "latest"),
+    /** GET /vaults/:vaultAddress/nav — fetch NAV snapshots over a time range for a vault. */
+    range: /* @__PURE__ */ __name(async (vaultAddress, query, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/nav`, {
+        method: "GET",
+        headers,
+        query
+      });
+    }, "range"),
+    /** GET /vaults/:vaultAddress/nav/stats — fetch NAV performance statistics for a vault. */
+    stats: /* @__PURE__ */ __name(async (vaultAddress, query, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/nav/stats`, {
+        method: "GET",
+        headers,
+        query
+      });
+    }, "stats")
+  };
+  positions = {
+    /** GET /vaults/:vaultAddress/positions/open — list open positions held by a vault. */
+    open: /* @__PURE__ */ __name(async (vaultAddress, query, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/positions/open`, {
+        method: "GET",
+        headers,
+        query
+      });
+    }, "open"),
+    /** GET /vaults/:vaultAddress/positions/closed — list closed positions held by a vault. */
+    closed: /* @__PURE__ */ __name(async (vaultAddress, query, headers) => {
+      return await this.client.fetch(`/vaults/${vaultAddress}/positions/closed`, {
+        method: "GET",
+        headers,
+        query
+      });
+    }, "closed")
+  };
+}
+
+export { Vaults };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pear-protocol/core-sdk",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Pear Protocol Core SDK",
   "private": false,
   "type": "module",
@@ -26,8 +26,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@pear-protocol/types": "^2.2.0",
-    "@pear-protocol/utils": "^1.1.0",
+    "@pear-protocol/types": "^2.11.0",
+    "@pear-protocol/utils": "^1.2.0",
     "qs": "^6.14.0"
   },
   "devDependencies": {