@pear-protocol/types 2.17.0 → 2.19.0

package/dist/realtime/public-events.d.ts

@@ -0,0 +1,342 @@
+import { z } from 'zod';
+/** One instrument's price tick on the `prices` channel. */
+export declare const RealtimePrice: z.ZodObject<{
+    id: z.ZodString;
+    p: z.ZodString;
+    bid: z.ZodNullable<z.ZodString>;
+    ask: z.ZodNullable<z.ZodString>;
+    t: z.ZodNumber;
+}, z.core.$strip>;
+export type RealtimePrice = z.output<typeof RealtimePrice>;
+/** One instrument's funding tick on the `funding` channel. */
+export declare const RealtimeFunding: z.ZodObject<{
+    id: z.ZodString;
+    r: z.ZodString;
+    t: z.ZodNumber;
+    nft: z.ZodNumber;
+}, z.core.$strip>;
+export type RealtimeFunding = z.output<typeof RealtimeFunding>;
+/** One executed leg of a public trade or trigger fire. */
+export declare const PublicTradeLeg: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    symbol: z.ZodString;
+    side: z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>;
+    reduceOnly: z.ZodBoolean;
+    quantity: z.ZodString;
+    price: z.ZodString;
+}, z.core.$strip>;
+export type PublicTradeLeg = z.output<typeof PublicTradeLeg>;
+/** Payload of a `price.updated` frame: the ticks of one connector and price source, keyed by instrument id. */
+export declare const PriceUpdatedData: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+        lighter_rhc: "lighter_rhc";
+    }>;
+    source: z.ZodEnum<{
+        mid: "mid";
+        mark: "mark";
+    }>;
+    prices: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        p: z.ZodString;
+        bid: z.ZodNullable<z.ZodString>;
+        ask: z.ZodNullable<z.ZodString>;
+        t: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PriceUpdatedData = z.output<typeof PriceUpdatedData>;
+/** Payload of a `funding.updated` frame: the funding ticks of one connector, keyed by instrument id. */
+export declare const FundingUpdatedData: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+        lighter_rhc: "lighter_rhc";
+    }>;
+    funding: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+        r: z.ZodString;
+        t: z.ZodNumber;
+        nft: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FundingUpdatedData = z.output<typeof FundingUpdatedData>;
+/** Payload of a `trade.executed` frame: one market execution on Pear. */
+export declare const TradeExecutedData: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+        lighter_rhc: "lighter_rhc";
+    }>;
+    source: z.ZodEnum<{
+        DIRECT: "DIRECT";
+        TRIGGER: "TRIGGER";
+        TWAP: "TWAP";
+    }>;
+    intent: z.ZodEnum<{
+        OPEN: "OPEN";
+        ADJUST: "ADJUST";
+        CLOSE: "CLOSE";
+        REVERSE: "REVERSE";
+    }>;
+    orderType: z.ZodEnum<{
+        MARKET: "MARKET";
+    }>;
+    timestamp: z.ZodISODateTime;
+    clientId: z.ZodOptional<z.ZodString>;
+    legs: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        reduceOnly: z.ZodBoolean;
+        quantity: z.ZodString;
+        price: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TradeExecutedData = z.output<typeof TradeExecutedData>;
+/** Payload of a `trigger.triggered.public` frame: one TP/SL trigger fire. */
+export declare const TriggerTriggeredPublicData: z.ZodObject<{
+    connector: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binance: "binance";
+        bybit: "bybit";
+        okx: "okx";
+        lighter: "lighter";
+        lighter_rhc: "lighter_rhc";
+    }>;
+    accountId: z.ZodString;
+    triggerId: z.ZodString;
+    bracketType: z.ZodEnum<{
+        STOP_LOSS: "STOP_LOSS";
+        TAKE_PROFIT: "TAKE_PROFIT";
+    }>;
+    semanticBracketType: z.ZodEnum<{
+        STOP_LOSS: "STOP_LOSS";
+        TAKE_PROFIT: "TAKE_PROFIT";
+    }>;
+    intent: z.ZodEnum<{
+        OPEN: "OPEN";
+        ADJUST: "ADJUST";
+        CLOSE: "CLOSE";
+    }>;
+    condition: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"ratio">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+            symbol_a: z.ZodString;
+            symbol_b: z.ZodString;
+            track: z.ZodEnum<{
+                PEAK: "PEAK";
+                TROUGH: "TROUGH";
+            }>;
+            threshold: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"price">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+            symbol: z.ZodString;
+            track: z.ZodEnum<{
+                PEAK: "PEAK";
+                TROUGH: "TROUGH";
+            }>;
+            threshold: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"weighted_ratio">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+            basket: z.ZodArray<z.ZodObject<{
+                symbol: z.ZodString;
+                side: z.ZodEnum<{
+                    BUY: "BUY";
+                    SELL: "SELL";
+                }>;
+                weight: z.ZodNumber;
+            }, z.core.$strip>>;
+            track: z.ZodEnum<{
+                PEAK: "PEAK";
+                TROUGH: "TROUGH";
+            }>;
+            threshold: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"notional">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+            track: z.ZodEnum<{
+                PEAK: "PEAK";
+                TROUGH: "TROUGH";
+            }>;
+            threshold: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"upnl">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+            track: z.ZodEnum<{
+                PEAK: "PEAK";
+                TROUGH: "TROUGH";
+            }>;
+            threshold: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"upnl_bps">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+            track: z.ZodEnum<{
+                PEAK: "PEAK";
+                TROUGH: "TROUGH";
+            }>;
+            threshold: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ratio_trailing">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+            symbol_a: z.ZodString;
+            symbol_b: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"price_trailing">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+            symbol: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"weighted_ratio_trailing">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+            basket: z.ZodArray<z.ZodObject<{
+                symbol: z.ZodString;
+                side: z.ZodEnum<{
+                    BUY: "BUY";
+                    SELL: "SELL";
+                }>;
+                weight: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"notional_trailing">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"upnl_trailing">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"upnl_bps_trailing">;
+        data: z.ZodObject<{
+            priceSource: z.ZodEnum<{
+                mid: "mid";
+                mark: "mark";
+            }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"funding_rate">;
+        data: z.ZodObject<{
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binance: "binance";
+                bybit: "bybit";
+                okx: "okx";
+                lighter: "lighter";
+                lighter_rhc: "lighter_rhc";
+            }>;
+            symbol: z.ZodString;
+            track: z.ZodEnum<{
+                PEAK: "PEAK";
+                TROUGH: "TROUGH";
+            }>;
+            threshold: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"prediction_market">;
+        data: z.ZodObject<{
+            source: z.ZodEnum<{
+                kalshi: "kalshi";
+                polymarket: "polymarket";
+            }>;
+            marketKey: z.ZodString;
+            track: z.ZodEnum<{
+                PEAK: "PEAK";
+                TROUGH: "TROUGH";
+            }>;
+            threshold: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"btc_dominance">;
+        data: z.ZodObject<{
+            source: z.ZodLiteral<"coingecko">;
+            track: z.ZodEnum<{
+                PEAK: "PEAK";
+                TROUGH: "TROUGH";
+            }>;
+            threshold: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">;
+    triggerLevel: z.ZodNullable<z.ZodNumber>;
+    timestamp: z.ZodISODateTime;
+    legs: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        reduceOnly: z.ZodBoolean;
+        quantity: z.ZodString;
+        price: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TriggerTriggeredPublicData = z.output<typeof TriggerTriggeredPublicData>;

package/dist/realtime/public-events.js

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { ClientIdCode } from '../common/client-id';
+import { Connector } from '../connector';
+import { PriceSource } from '../price';
+import { TriggerConditionClose, TpSlBracketType } from '../trigger';
+
+const RealtimePrice = z.object({
+  // Connector-native instrument id.
+  id: z.string(),
+  // The price for the subscribed source (mid or mark).
+  p: z.string(),
+  // Best bid, when the venue reports one.
+  bid: z.string().nullable(),
+  // Best ask, when the venue reports one.
+  ask: z.string().nullable(),
+  // Epoch milliseconds of the tick.
+  t: z.number()
+});
+const RealtimeFunding = z.object({
+  // Connector-native instrument id.
+  id: z.string(),
+  // Funding rate.
+  r: z.string(),
+  // Epoch milliseconds of the tick.
+  t: z.number(),
+  // Next funding time in epoch milliseconds.
+  nft: z.number()
+});
+const PublicTradeLeg = z.object({
+  // SYMBOL-MIGRATION switch-to-id: optional while old producers still drain; becomes required once every producer stamps it.
+  id: z.string().optional().describe("Connector-native instrument id"),
+  symbol: z.string(),
+  side: z.enum([
+    "BUY",
+    "SELL"
+  ]),
+  reduceOnly: z.boolean(),
+  quantity: z.string(),
+  price: z.string()
+});
+const PriceUpdatedData = z.object({
+  connector: Connector,
+  source: PriceSource,
+  prices: z.record(z.string(), RealtimePrice)
+});
+const FundingUpdatedData = z.object({
+  connector: Connector,
+  funding: z.record(z.string(), RealtimeFunding)
+});
+const TradeExecutedData = z.object({
+  connector: Connector,
+  source: z.enum([
+    "DIRECT",
+    "TWAP",
+    "TRIGGER"
+  ]),
+  intent: z.enum([
+    "OPEN",
+    "ADJUST",
+    "CLOSE",
+    "REVERSE"
+  ]),
+  orderType: z.enum([
+    "MARKET"
+  ]),
+  timestamp: z.iso.datetime(),
+  clientId: ClientIdCode,
+  legs: z.array(PublicTradeLeg).min(1)
+});
+const TriggerTriggeredPublicData = z.object({
+  connector: Connector,
+  accountId: z.string(),
+  triggerId: z.string(),
+  bracketType: z.enum([
+    "STOP_LOSS",
+    "TAKE_PROFIT"
+  ]),
+  // User-facing bracket semantics; `bracketType` is the crossing encoding (wire-flipped
+  // for a price bracket on a short watched leg). Always stated.
+  semanticBracketType: TpSlBracketType,
+  intent: z.enum([
+    "OPEN",
+    "ADJUST",
+    "CLOSE"
+  ]),
+  condition: TriggerConditionClose,
+  triggerLevel: z.number().nullable(),
+  timestamp: z.iso.datetime(),
+  legs: z.array(PublicTradeLeg).min(1)
+});
+
+export { FundingUpdatedData, PriceUpdatedData, PublicTradeLeg, RealtimeFunding, RealtimePrice, TradeExecutedData, TriggerTriggeredPublicData };

package/dist/realtime/user-events.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/** Topics of the private `user_events` channel; each tells the user one of their entities changed. */
+export declare const UserEventTopic: z.ZodEnum<{
+    "execution.failed": "execution.failed";
+    "execution.completed": "execution.completed";
+    "position.created": "position.created";
+    "position.updated": "position.updated";
+    "position.closed": "position.closed";
+    "schedule.created": "schedule.created";
+    "schedule.completed": "schedule.completed";
+    "schedule.failed": "schedule.failed";
+    "schedule.cancelled": "schedule.cancelled";
+    "ladder.created": "ladder.created";
+    "ladder.updated": "ladder.updated";
+    "ladder.cancelled": "ladder.cancelled";
+    "trigger.created": "trigger.created";
+    "trigger.triggered": "trigger.triggered";
+    "trigger.cancelled": "trigger.cancelled";
+    "trigger.converted": "trigger.converted";
+    "rebalance.created": "rebalance.created";
+    "rebalance.updated": "rebalance.updated";
+    "rebalance.executed": "rebalance.executed";
+    "rebalance.paused": "rebalance.paused";
+    "rebalance.cancelled": "rebalance.cancelled";
+    "notification.created": "notification.created";
+}>;
+export type UserEventTopic = z.infer<typeof UserEventTopic>;
+/** Invalidation-only payload of a `user_events` frame: the client refetches the named entity. */
+export declare const UserEventData: z.ZodObject<{
+    entityId: z.ZodString;
+}, z.core.$strip>;
+export type UserEventData = z.output<typeof UserEventData>;

package/dist/realtime/user-events.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+
+const UserEventTopic = z.enum([
+  "execution.failed",
+  "execution.completed",
+  "position.created",
+  "position.updated",
+  "position.closed",
+  "schedule.created",
+  "schedule.completed",
+  "schedule.failed",
+  "schedule.cancelled",
+  "ladder.created",
+  "ladder.updated",
+  "ladder.cancelled",
+  "trigger.created",
+  "trigger.triggered",
+  "trigger.cancelled",
+  "trigger.converted",
+  "rebalance.created",
+  "rebalance.updated",
+  "rebalance.executed",
+  "rebalance.paused",
+  "rebalance.cancelled",
+  "notification.created"
+]);
+const UserEventData = z.object({
+  // The changed entity (execution, position, schedule, ladder, trigger, rebalance or notification id).
+  entityId: z.string()
+});
+
+export { UserEventData, UserEventTopic };

package/dist/realtime/vault-events.d.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { EthereumAddress } from '../common/address';
+/** Read models behind the anonymous vault pages; anyone watching the vault on `vault_events` may hear they changed. */
+export declare const PublicVaultDataset: z.ZodEnum<{
+    positions: "positions";
+    detail: "detail";
+    nav: "nav";
+    ledger: "ledger";
+}>;
+export type PublicVaultDataset = z.infer<typeof PublicVaultDataset>;
+/** Read models behind the owner/trader-only tabs; only `vault_management` grants may hear they changed. */
+export declare const ManagementVaultDataset: z.ZodEnum<{
+    orders: "orders";
+    schedules: "schedules";
+    private_history: "private_history";
+}>;
+export type ManagementVaultDataset = z.infer<typeof ManagementVaultDataset>;
+/** The vault read models a client refetches when told one changed. */
+export declare const VaultDataset: z.ZodEnum<{
+    positions: "positions";
+    orders: "orders";
+    detail: "detail";
+    nav: "nav";
+    ledger: "ledger";
+    schedules: "schedules";
+    private_history: "private_history";
+}>;
+export type VaultDataset = z.infer<typeof VaultDataset>;
+/** Reports whether anyone, not only the vault's owner/trader, may hear that this dataset changed. */
+export declare function isPublicVaultDataset(dataset: VaultDataset): dataset is PublicVaultDataset;
+/** Invalidation-only notice: names the vault and dataset to refetch, never an entity or its payload. */
+export declare const VaultInvalidatedData: z.ZodObject<{
+    vaultAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>;
+    dataset: z.ZodEnum<{
+        positions: "positions";
+        orders: "orders";
+        detail: "detail";
+        nav: "nav";
+        ledger: "ledger";
+        schedules: "schedules";
+        private_history: "private_history";
+    }>;
+    eventId: z.ZodUUID;
+    emittedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type VaultInvalidatedData = z.output<typeof VaultInvalidatedData>;
+/** The notice `vault_events` carries: only a public dataset. */
+export declare const PublicVaultInvalidatedData: z.ZodObject<{
+    vaultAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>;
+    eventId: z.ZodUUID;
+    emittedAt: z.ZodNumber;
+    dataset: z.ZodEnum<{
+        positions: "positions";
+        detail: "detail";
+        nav: "nav";
+        ledger: "ledger";
+    }>;
+}, z.core.$strip>;
+export type PublicVaultInvalidatedData = z.output<typeof PublicVaultInvalidatedData>;
+/** The notice `vault_management` carries: only an owner/trader dataset. */
+export declare const ManagementVaultInvalidatedData: z.ZodObject<{
+    vaultAddress: z.ZodPipe<z.ZodString, z.ZodTransform<EthereumAddress, string>>;
+    eventId: z.ZodUUID;
+    emittedAt: z.ZodNumber;
+    dataset: z.ZodEnum<{
+        orders: "orders";
+        schedules: "schedules";
+        private_history: "private_history";
+    }>;
+}, z.core.$strip>;
+export type ManagementVaultInvalidatedData = z.output<typeof ManagementVaultInvalidatedData>;

package/dist/realtime/vault-events.js

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { EthereumAddress } from '../common/address';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const PublicVaultDataset = z.enum([
+  "positions",
+  "detail",
+  "nav",
+  "ledger"
+]);
+const ManagementVaultDataset = z.enum([
+  "orders",
+  "schedules",
+  "private_history"
+]);
+const VaultDataset = z.enum([
+  ...PublicVaultDataset.options,
+  ...ManagementVaultDataset.options
+]);
+function isPublicVaultDataset(dataset) {
+  return PublicVaultDataset.safeParse(dataset).success;
+}
+__name(isPublicVaultDataset, "isPublicVaultDataset");
+const VaultInvalidatedData = z.object({
+  // The vault whose dataset changed, lowercased.
+  vaultAddress: EthereumAddress,
+  // The read model to refetch; its visibility decides which channel carries the notice.
+  dataset: VaultDataset,
+  // Unique per emitted invalidation so clients can dedupe redeliveries.
+  eventId: z.uuid(),
+  // Epoch milliseconds when realtime emitted the invalidation.
+  emittedAt: z.number().int().nonnegative()
+});
+const PublicVaultInvalidatedData = VaultInvalidatedData.extend({
+  dataset: PublicVaultDataset
+});
+const ManagementVaultInvalidatedData = VaultInvalidatedData.extend({
+  dataset: ManagementVaultDataset
+});
+
+export { ManagementVaultDataset, ManagementVaultInvalidatedData, PublicVaultDataset, PublicVaultInvalidatedData, VaultDataset, VaultInvalidatedData, isPublicVaultDataset };