@pear-protocol/types 2.20.0 → 2.22.0

package/dist/realtime/frames.js

@@ -1,140 +0,0 @@
-import { z } from 'zod';
-import { EthereumAddress } from '../common/address';
-import { WebsocketChannel } from './channels';
-import { PriceUpdatedData, FundingUpdatedData, TradeExecutedData, TriggerTriggeredPublicData } from './public-events';
-import { UserEventData, UserEventTopic } from './user-events';
-import { PublicVaultInvalidatedData, ManagementVaultInvalidatedData } from './vault-events';
-
-const FrameRequestId = z.string().optional();
-const WebsocketWelcomeFrame = z.object({
-  type: z.literal("welcome"),
-  connectionId: z.string(),
-  heartbeatIntervalMs: z.number(),
-  resubscribeRequired: z.literal(true)
-});
-const AuthAckFrame = z.object({
-  id: FrameRequestId,
-  type: z.literal("ack"),
-  method: z.literal("auth"),
-  ok: z.literal(true)
-});
-const SubscriptionAckFrame = z.object({
-  id: FrameRequestId,
-  type: z.literal("ack"),
-  method: z.enum([
-    "subscribe",
-    "unsubscribe"
-  ]),
-  channel: WebsocketChannel,
-  ok: z.literal(true)
-});
-const WebsocketAckFrame = z.discriminatedUnion("method", [
-  AuthAckFrame,
-  SubscriptionAckFrame
-]);
-const WebsocketVaultErrorCode = z.enum([
-  "FORBIDDEN",
-  "SUBSCRIPTION_REVOKED"
-]);
-const WebsocketRequestErrorCode = z.enum([
-  "AUTH_EXPIRED",
-  "CAPACITY_UNAVAILABLE",
-  "INTERNAL_ERROR",
-  "INVALID_FRAME",
-  "INVALID_JSON",
-  "INVALID_MESSAGE",
-  "INVALID_SUBSCRIPTION",
-  "RATE_LIMITED",
-  "TOO_MANY_SUBSCRIPTIONS",
-  "UNAUTHENTICATED"
-]);
-const WebsocketErrorCode = z.enum([
-  ...WebsocketRequestErrorCode.options,
-  ...WebsocketVaultErrorCode.options
-]);
-const RequestErrorFrame = z.object({
-  id: FrameRequestId,
-  type: z.literal("error"),
-  code: WebsocketRequestErrorCode,
-  message: z.string()
-});
-const VaultErrorFrame = z.object({
-  id: FrameRequestId,
-  type: z.literal("error"),
-  code: WebsocketVaultErrorCode,
-  message: z.string(),
-  // Vaults a FORBIDDEN refusal or SUBSCRIPTION_REVOKED notice applies to.
-  vaults: z.array(EthereumAddress)
-});
-const WebsocketErrorFrame = z.discriminatedUnion("code", [
-  RequestErrorFrame,
-  VaultErrorFrame
-]);
-const PriceUpdatedFrame = z.object({
-  type: z.literal("event"),
-  channel: z.literal("prices"),
-  topic: z.literal("price.updated"),
-  data: PriceUpdatedData
-});
-const FundingUpdatedFrame = z.object({
-  type: z.literal("event"),
-  channel: z.literal("funding"),
-  topic: z.literal("funding.updated"),
-  data: FundingUpdatedData
-});
-const TradeExecutedFrame = z.object({
-  type: z.literal("event"),
-  channel: z.literal("trades"),
-  topic: z.literal("trade.executed"),
-  data: TradeExecutedData
-});
-const TriggerTriggeredPublicFrame = z.object({
-  type: z.literal("event"),
-  channel: z.literal("trigger_events"),
-  topic: z.literal("trigger.triggered.public"),
-  data: TriggerTriggeredPublicData
-});
-const UserEventFrame = z.object({
-  type: z.literal("event"),
-  channel: z.literal("user_events"),
-  topic: UserEventTopic,
-  data: UserEventData
-});
-const VaultEventsInvalidatedFrame = z.object({
-  type: z.literal("event"),
-  channel: z.literal("vault_events"),
-  topic: z.literal("vault.invalidated"),
-  data: PublicVaultInvalidatedData
-});
-const VaultManagementInvalidatedFrame = z.object({
-  type: z.literal("event"),
-  channel: z.literal("vault_management"),
-  topic: z.literal("vault.invalidated"),
-  data: ManagementVaultInvalidatedData
-});
-const VaultInvalidatedFrame = z.discriminatedUnion("channel", [
-  VaultEventsInvalidatedFrame,
-  VaultManagementInvalidatedFrame
-]);
-const WebsocketEventFrame = z.discriminatedUnion("topic", [
-  PriceUpdatedFrame,
-  FundingUpdatedFrame,
-  TradeExecutedFrame,
-  TriggerTriggeredPublicFrame,
-  UserEventFrame,
-  VaultInvalidatedFrame
-]);
-const WebsocketPongFrame = z.object({
-  id: FrameRequestId,
-  type: z.literal("pong"),
-  timestamp: z.iso.datetime()
-});
-const WebsocketFrame = z.discriminatedUnion("type", [
-  WebsocketWelcomeFrame,
-  WebsocketAckFrame,
-  WebsocketErrorFrame,
-  WebsocketEventFrame,
-  WebsocketPongFrame
-]);
-
-export { WebsocketAckFrame, WebsocketErrorCode, WebsocketErrorFrame, WebsocketEventFrame, WebsocketFrame, WebsocketPongFrame, WebsocketRequestErrorCode, WebsocketVaultErrorCode, WebsocketWelcomeFrame };

package/dist/realtime/index.js

@@ -1,6 +0,0 @@
-export * from './channels';
-export * from './frames';
-export * from './messages';
-export * from './public-events';
-export * from './user-events';
-export * from './vault-events';

package/dist/realtime/messages.js

@@ -1,118 +0,0 @@
-import { z } from 'zod';
-import { EthereumAddress } from '../common/address';
-import { Connector } from '../connector';
-import { WebsocketPublicChannel } from './channels';
-import { UserEventTopic } from './user-events';
-
-const MAX_VAULTS_PER_CONNECTION = 20;
-const WebsocketRequestId = z.union([
-  z.string(),
-  z.number()
-]).transform(String).optional();
-const WebsocketPublicParams = z.object({
-  connectors: z.array(Connector).optional(),
-  instrumentIds: z.array(z.string()).optional()
-}).strict();
-const WebsocketUserEventsParams = z.object({
-  topics: z.array(UserEventTopic).optional()
-}).strict();
-const WebsocketTriggerEventsParams = z.object({
-  connectors: z.array(Connector).optional(),
-  accountIds: z.array(z.string()).optional()
-}).strict();
-const WebsocketVaultEventsParams = z.object({
-  vaults: z.array(EthereumAddress).min(1)
-}).strict();
-const PingMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("ping")
-});
-const AuthMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("auth"),
-  params: z.object({
-    accessToken: z.string().min(1)
-  }).strict()
-});
-const SubscribePublicMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("subscribe"),
-  channel: WebsocketPublicChannel,
-  params: WebsocketPublicParams.optional()
-});
-const SubscribeUserEventsMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("subscribe"),
-  channel: z.literal("user_events"),
-  params: WebsocketUserEventsParams.optional()
-});
-const SubscribeTriggerEventsMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("subscribe"),
-  channel: z.literal("trigger_events"),
-  params: WebsocketTriggerEventsParams.optional()
-});
-const SubscribeVaultEventsMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("subscribe"),
-  channel: z.literal("vault_events"),
-  params: WebsocketVaultEventsParams
-});
-const SubscribeVaultManagementMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("subscribe"),
-  channel: z.literal("vault_management"),
-  params: WebsocketVaultEventsParams
-});
-const UnsubscribePublicMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("unsubscribe"),
-  channel: WebsocketPublicChannel,
-  params: WebsocketPublicParams.optional()
-});
-const UnsubscribeUserEventsMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("unsubscribe"),
-  channel: z.literal("user_events"),
-  params: WebsocketUserEventsParams.optional()
-});
-const UnsubscribeTriggerEventsMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("unsubscribe"),
-  channel: z.literal("trigger_events"),
-  params: WebsocketTriggerEventsParams.optional()
-});
-const UnsubscribeVaultEventsMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("unsubscribe"),
-  channel: z.literal("vault_events"),
-  params: WebsocketVaultEventsParams.optional()
-});
-const UnsubscribeVaultManagementMessage = z.object({
-  id: WebsocketRequestId,
-  method: z.literal("unsubscribe"),
-  channel: z.literal("vault_management"),
-  params: WebsocketVaultEventsParams.optional()
-});
-const SubscribeMessage = z.discriminatedUnion("channel", [
-  SubscribePublicMessage,
-  SubscribeUserEventsMessage,
-  SubscribeTriggerEventsMessage,
-  SubscribeVaultEventsMessage,
-  SubscribeVaultManagementMessage
-]);
-const UnsubscribeMessage = z.discriminatedUnion("channel", [
-  UnsubscribePublicMessage,
-  UnsubscribeUserEventsMessage,
-  UnsubscribeTriggerEventsMessage,
-  UnsubscribeVaultEventsMessage,
-  UnsubscribeVaultManagementMessage
-]);
-const WebsocketControlMessage = z.discriminatedUnion("method", [
-  AuthMessage,
-  PingMessage,
-  SubscribeMessage,
-  UnsubscribeMessage
-]);
-
-export { MAX_VAULTS_PER_CONNECTION, WebsocketControlMessage, WebsocketPublicParams, WebsocketRequestId, WebsocketTriggerEventsParams, WebsocketUserEventsParams, WebsocketVaultEventsParams };

package/dist/realtime/public-events.js

@@ -1,92 +0,0 @@
-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.js

@@ -1,32 +0,0 @@
-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.js

@@ -1,42 +0,0 @@
-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 };

package/dist/rebalance/entities.js

@@ -1,86 +0,0 @@
-import { z } from 'zod';
-import { UnsignedDecimalString } from '../common/schema';
-import { InstrumentId } from '../instrument';
-
-const AutoRebalanceStatus = z.enum([
-  "ACTIVE",
-  "PAUSED"
-]);
-const AutoRebalancePausedReason = z.enum([
-  "USER",
-  "POSITION_CHANGED",
-  "REPEATED_FAILURES",
-  "INVALID_LIVE_BETA_EXPOSURE"
-]);
-const AutoRebalanceWeightSource = z.enum([
-  "INITIAL_WEIGHT",
-  "LIVE_BETA"
-]);
-const AutoRebalanceTimeframe = z.enum([
-  "1h",
-  "4h",
-  "1d"
-]);
-const RebalanceEventStatus = z.enum([
-  "SUCCESS",
-  "FAILED"
-]);
-const WeightMap = z.record(InstrumentId, z.number());
-const AutoRebalanceConfigBase = z.object({
-  id: z.uuid(),
-  positionId: z.uuid(),
-  status: AutoRebalanceStatus,
-  pausedReason: AutoRebalancePausedReason.optional(),
-  minimumDriftPct: UnsignedDecimalString,
-  createdAt: z.iso.datetime(),
-  updatedAt: z.iso.datetime()
-});
-const AutoRebalanceBetaState = z.discriminatedUnion("state", [
-  z.object({
-    state: z.literal("PENDING")
-  }),
-  z.object({
-    state: z.literal("BASELINED"),
-    // The frozen drift baseline: implied beta of the achieved leg split at entry, re-snapshotted after
-    // every rebalance.
-    impliedEntryBeta: UnsignedDecimalString
-  }),
-  z.object({
-    state: z.literal("TRACKING"),
-    // The frozen drift baseline: implied beta of the achieved leg split at entry, re-snapshotted after
-    // every rebalance.
-    impliedEntryBeta: UnsignedDecimalString,
-    // Kalman beta of the last candle this config processed — the moving side of the drift comparison.
-    lastDerivedBeta: UnsignedDecimalString,
-    // Bar time lastDerivedBeta was read at, so a client can judge how fresh that beta is.
-    lastProcessedBetaTime: z.iso.datetime(),
-    // How far lastDerivedBeta sits from impliedEntryBeta, as a fraction (0.05 = 5%) directly comparable
-    // to minimumDriftPct. Derived from the two betas above; absent on a degenerate (zero) baseline.
-    driftPct: UnsignedDecimalString.optional()
-  })
-]);
-const AutoRebalanceConfig = z.discriminatedUnion("weightSource", [
-  AutoRebalanceConfigBase.extend({
-    weightSource: z.literal("INITIAL_WEIGHT")
-  }),
-  AutoRebalanceConfigBase.extend({
-    weightSource: z.literal("LIVE_BETA"),
-    // Stat-arb bar timeframe selecting which realtime candle feed drives the drift comparison.
-    timeframe: AutoRebalanceTimeframe,
-    beta: AutoRebalanceBetaState
-  })
-]);
-const RebalanceEvent = z.object({
-  id: z.uuid(),
-  autoRebalanceConfigId: z.uuid(),
-  positionId: z.uuid(),
-  weightSource: AutoRebalanceWeightSource,
-  driftPct: UnsignedDecimalString,
-  currentWeights: WeightMap,
-  targetWeights: WeightMap,
-  status: RebalanceEventStatus,
-  error: z.string().optional(),
-  createdAt: z.iso.datetime()
-});
-
-export { AutoRebalanceBetaState, AutoRebalanceConfig, AutoRebalancePausedReason, AutoRebalanceStatus, AutoRebalanceTimeframe, AutoRebalanceWeightSource, RebalanceEvent, RebalanceEventStatus, WeightMap };

package/dist/rebalance/index.js

@@ -1,4 +0,0 @@
-export * from './entities';
-export * from './payloads';
-export * from './queries';
-export * from './responses';

package/dist/rebalance/payloads.js

@@ -1,56 +0,0 @@
-import { z } from 'zod';
-import { ClientIdCode } from '../common/client-id';
-import { RefineWeightingSum, RefineUniqueSymbols } from '../common/refinement';
-import { UnsignedDecimalString } from '../common/schema';
-import { ExecutionOrderType } from '../execution';
-import { InstrumentId } from '../instrument';
-import { AutoRebalanceTimeframe, AutoRebalanceStatus } from './entities';
-
-const RebalanceManual = z.object({
-  orderType: ExecutionOrderType,
-  weightings: z.array(z.object({
-    symbol: InstrumentId,
-    weight: z.number().positive({
-      message: "Weight must be greater than 0"
-    }).max(1, {
-      message: "Weight must be less than 1"
-    })
-  })).superRefine(RefineWeightingSum).superRefine(RefineUniqueSymbols).describe("Array of weightings to rebalance the position"),
-  /**
-  * Attribution route code (client_ids.code)
-  */
-  clientId: ClientIdCode
-});
-const MinimumDriftPct = UnsignedDecimalString.refine((value) => Number(value) > 0 && Number(value) <= 1, {
-  message: "minimumDriftPct must be greater than 0 and at most 1"
-});
-const InitialWeightConfig = z.object({
-  weightSource: z.literal("INITIAL_WEIGHT"),
-  minimumDriftPct: MinimumDriftPct
-});
-const LiveBetaConfig = z.object({
-  weightSource: z.literal("LIVE_BETA"),
-  minimumDriftPct: MinimumDriftPct,
-  timeframe: AutoRebalanceTimeframe
-});
-const CreateInitialWeight = InitialWeightConfig.extend({
-  positionId: z.uuid()
-});
-const CreateLiveBeta = LiveBetaConfig.extend({
-  positionId: z.uuid()
-});
-const CreateAutoRebalanceConfig = z.discriminatedUnion("weightSource", [
-  CreateInitialWeight,
-  CreateLiveBeta
-]);
-const ReplaceAutoRebalanceConfig = z.discriminatedUnion("weightSource", [
-  InitialWeightConfig,
-  LiveBetaConfig
-]);
-const UpdateAutoRebalanceConfig = z.object({
-  minimumDriftPct: MinimumDriftPct.optional(),
-  timeframe: AutoRebalanceTimeframe.optional(),
-  status: AutoRebalanceStatus.optional()
-});
-
-export { CreateAutoRebalanceConfig, RebalanceManual, ReplaceAutoRebalanceConfig, UpdateAutoRebalanceConfig };

package/dist/rebalance/queries.js

@@ -1,14 +0,0 @@
-import { z } from 'zod';
-import { normalizeArray, CursorFindParams } from '../common';
-import { AutoRebalanceStatus, AutoRebalanceWeightSource } from './entities';
-
-const StatusArray = z.preprocess((arg) => normalizeArray(arg), z.array(AutoRebalanceStatus));
-const WeightSourceArray = z.preprocess((arg) => normalizeArray(arg), z.array(AutoRebalanceWeightSource));
-const AutoRebalanceListParams = CursorFindParams.extend({
-  status: StatusArray.optional(),
-  weightSource: WeightSourceArray.optional(),
-  positionId: z.uuid().optional()
-});
-const RebalanceEventListParams = CursorFindParams.extend({});
-
-export { AutoRebalanceListParams, RebalanceEventListParams };

package/dist/rebalance/responses.js

@@ -1,41 +0,0 @@
-import { z } from 'zod';
-import { CursorResponse } from '../common';
-import { AutoRebalanceConfig, RebalanceEvent } from './entities';
-
-const RebalanceManualResponse = z.object({
-  plan: z.discriminatedUnion("outcome", [
-    z.object({
-      outcome: z.literal("full_rebalance")
-    }),
-    z.object({
-      outcome: z.literal("partial_rebalance"),
-      messages: z.tuple([
-        z.string()
-      ]).rest(z.string())
-    }),
-    z.object({
-      outcome: z.literal("no_rebalance"),
-      messages: z.tuple([
-        z.string()
-      ]).rest(z.string())
-    }),
-    // `failed` only occurs on background runs (dispatch/cron); MANUAL execution errors throw and surface as HTTP errors instead.
-    z.object({
-      outcome: z.literal("failed"),
-      messages: z.tuple([
-        z.string()
-      ]).rest(z.string())
-    })
-  ])
-});
-const AutoRebalanceListResponse = CursorResponse.extend({
-  items: z.array(AutoRebalanceConfig)
-});
-const CreateAutoRebalanceResponse = z.object({
-  config: AutoRebalanceConfig
-});
-const RebalanceEventListResponse = CursorResponse.extend({
-  items: z.array(RebalanceEvent)
-});
-
-export { AutoRebalanceListResponse, CreateAutoRebalanceResponse, RebalanceEventListResponse, RebalanceManualResponse };