@zofai/zo-sdk 0.2.13 → 0.2.15

package/src/oraclePro.ts

@@ -0,0 +1,312 @@
+import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions'
+import { SUI_CLOCK_OBJECT_ID } from '@mysten/sui/utils'
+
+import type {
+  IOracleProConfig,
+  IPythLazerConfig,
+  IZoOracleConfig,
+  Network,
+} from './consts'
+import {
+  buildOracleProConfig,
+  getPythFeederToPriceId,
+  getZoOracleConfig,
+} from './consts'
+import type { PythProChannel } from './pythProClient'
+import { fetchPythProUpdateBytesFromKronos } from './pythProClient'
+import { hexToBytes } from './storkClient'
+import { parseSymbolKey } from './utils'
+
+/** Shared oracle bundle for most entry functions (Clock is passed separately when required). */
+export interface OracleInputs {
+  pythProUpdate: TransactionObjectArgument
+  storkState: TransactionObjectArgument
+  oracleRegistry: TransactionObjectArgument
+  clock: TransactionObjectArgument
+}
+
+/** Alternate order used by liquidate + execute v3_1 (no clock). */
+export interface OracleInputsAlt {
+  oracleRegistry: TransactionObjectArgument
+  storkState: TransactionObjectArgument
+  pythProUpdate: TransactionObjectArgument
+}
+
+export interface IInitPythProOracleTxbResult {
+  tx: Transaction
+  oracle: OracleInputs
+}
+
+export interface IFetchPythProUpdateOptions {
+  channel?: PythProChannel
+  /** Request ema_price for swap volatility fee. */
+  includeEmaPrice?: boolean
+  /** Override kronos REST base URL (default: instance apiEndpoint or `DEFAULT_API_ENDPOINT`). */
+  kronosUrl?: string
+}
+
+/** Normalize coin type strings for zo_oracle ↔ LP deployment matching. */
+export function normalizeCoinType(coinType: string): string {
+  const parts = coinType.split('::')
+  if (parts.length < 2 || !parts[0].startsWith('0x')) {
+    return coinType.toLowerCase()
+  }
+  const hex = parts[0].slice(2).replace(/^0+/, '') || '0'
+  return `0x${hex}::${parts.slice(1).join('::')}`.toLowerCase()
+}
+
+export function requireOracleProConfig(network: Network): IOracleProConfig {
+  return buildOracleProConfig(getZoOracleConfig(network))
+}
+
+/**
+ * Build coin module -> Lazer feed id using zo_oracle symbol configs + Hermes price id map.
+ */
+export function buildCoinModuleToLazerFeedId(
+  pythLazer: IPythLazerConfig,
+  zoOracle: IZoOracleConfig,
+  network: Network,
+): Map<string, number> {
+  const pythFeederToPriceId = getPythFeederToPriceId(network)
+  const map = new Map<string, number>()
+
+  for (const config of Object.values(zoOracle.symbolConfigs)) {
+    const priceId = pythFeederToPriceId[config.pythFeederId]
+    if (!priceId) {
+      continue
+    }
+    const lazerId = pythLazer.feedIds[priceId]
+    if (lazerId === undefined) {
+      continue
+    }
+    map.set(normalizeCoinType(config.coinType), lazerId)
+  }
+
+  return map
+}
+
+export function resolveLazerFeedIds(
+  zoOracle: IZoOracleConfig,
+  coins: Record<string, { module: string }>,
+  tokens: string[],
+  network: Network,
+  legacyFeeders?: Record<string, string>,
+): number[] {
+  const { pythLazer } = zoOracle
+  const coinModuleMap = buildCoinModuleToLazerFeedId(pythLazer, zoOracle, network)
+  const feederToPriceId = getPythFeederToPriceId(network)
+
+  const ids = new Set<number>()
+  for (const token of tokens) {
+    const module = coins[token]?.module
+    if (!module) {
+      throw new Error(`Unknown token: ${token}`)
+    }
+
+    let lazerId = coinModuleMap.get(normalizeCoinType(module))
+
+    if (lazerId === undefined && legacyFeeders?.[token]) {
+      const priceId = feederToPriceId[legacyFeeders[token]]
+      if (priceId) {
+        lazerId = pythLazer.feedIds[priceId]
+      }
+    }
+
+    if (lazerId === undefined) {
+      throw new Error(`No Pyth Lazer feed id for token "${token}" (${module})`)
+    }
+    ids.add(lazerId)
+  }
+  return [...ids]
+}
+
+/** Map Stork asset symbol (e.g. `BTCUSD`) → 32-byte on-chain feeder id bytes. */
+export function buildStorkAssetIdMap(zoOracle: IZoOracleConfig): Map<string, Uint8Array> {
+  const map = new Map<string, Uint8Array>()
+  for (const [symbolKey, config] of Object.entries(zoOracle.symbolConfigs)) {
+    if (!config.storkFeederId) {
+      continue
+    }
+    const asset = symbolKey.replace('/', '')
+    map.set(asset, hexToBytes(config.storkFeederId))
+  }
+  return map
+}
+
+/** Map SDK token id → kronos Stork asset id (e.g. `btc` → `BTCUSD`). */
+export function resolveStorkAssetsForTokens(
+  zoOracle: IZoOracleConfig,
+  coins: Record<string, { module: string }>,
+  tokens: string[],
+): string[] {
+  const moduleToAsset = new Map<string, string>()
+  for (const [symbolKey, config] of Object.entries(zoOracle.symbolConfigs)) {
+    if (!config.storkFeederId) {
+      continue
+    }
+    moduleToAsset.set(normalizeCoinType(config.coinType), symbolKey.replace('/', ''))
+  }
+
+  const assets = new Set<string>()
+  for (const token of tokens) {
+    const module = coins[token]?.module
+    if (!module) {
+      continue
+    }
+    const asset = moduleToAsset.get(normalizeCoinType(module))
+    if (asset) {
+      assets.add(asset)
+    }
+  }
+  return [...assets]
+}
+
+export function toUpdateBytes(raw: Uint8Array | number[]): number[] {
+  return raw instanceof Uint8Array ? Array.from(raw) : raw
+}
+
+/**
+ * PTB step 0: verify a Pyth Pro leEcdsa update on-chain.
+ * Returns the verified `pyth_lazer::update_v2::Update` object.
+ */
+export function parseAndVerifyPythProUpdate(
+  tx: Transaction,
+  config: IOracleProConfig,
+  rawUpdateBytes: Uint8Array | number[],
+): TransactionObjectArgument {
+  const [pythProUpdate] = tx.moveCall({
+    target: `${config.pythLazer.package}::pyth_lazer::parse_and_verify_le_ecdsa_update_v2`,
+    arguments: [
+      tx.object(config.pythLazer.state),
+      tx.object(SUI_CLOCK_OBJECT_ID),
+      tx.pure.vector('u8', toUpdateBytes(rawUpdateBytes)),
+    ],
+  })
+  return pythProUpdate
+}
+
+export function buildOracleInputs(
+  tx: Transaction,
+  config: IOracleProConfig,
+  pythProUpdate: TransactionObjectArgument,
+): OracleInputs {
+  return {
+    pythProUpdate,
+    storkState: tx.object(config.storkState),
+    oracleRegistry: tx.object(config.oracleRegistry),
+    clock: tx.object(SUI_CLOCK_OBJECT_ID),
+  }
+}
+
+/** Pyth Pro + Stork objects: `[pythProUpdate, storkState, oracleRegistry]`. */
+export function oracleArgsStandard(oracle: OracleInputs): TransactionObjectArgument[] {
+  return [oracle.pythProUpdate, oracle.storkState, oracle.oracleRegistry]
+}
+
+/** `[pythProUpdate, storkState, oracleRegistry, clock]` — for public fns that take clock after oracle args. */
+export function oracleArgsWithClock(oracle: OracleInputs): TransactionObjectArgument[] {
+  return [...oracleArgsStandard(oracle), oracle.clock]
+}
+
+export function oracleArgsAlt(oracle: OracleInputsAlt): TransactionObjectArgument[] {
+  return [oracle.oracleRegistry, oracle.storkState, oracle.pythProUpdate]
+}
+
+export function buildOracleInputsAlt(oracle: OracleInputs): OracleInputsAlt {
+  return {
+    oracleRegistry: oracle.oracleRegistry,
+    storkState: oracle.storkState,
+    pythProUpdate: oracle.pythProUpdate,
+  }
+}
+
+/**
+ * Fetch leEcdsa update bytes via kronos REST (`/pyth-pro/latest-price?includeUpdateBytes=true`).
+ */
+export function fetchPythProUpdateBytes(
+  kronosUrl: string,
+  feedIds: number[],
+  options?: Pick<IFetchPythProUpdateOptions, 'channel' | 'includeEmaPrice'>,
+): Promise<Uint8Array> {
+  return fetchPythProUpdateBytesFromKronos(kronosUrl, feedIds, options)
+}
+
+export interface IValuateVaultsV2Params {
+  tx: Transaction
+  upgradedPackage: string
+  lpType: string
+  market: string
+  vaults: Record<string, { reservingFeeModel: string }>
+  coinModules: Record<string, { module: string }>
+  oracle: OracleInputs
+}
+
+/** create_vaults_valuation + valuate_vault_v2 for each vault. */
+export function valuateVaultsV2(params: IValuateVaultsV2Params): TransactionObjectArgument {
+  const { tx, upgradedPackage, lpType, market, vaults, coinModules, oracle } = params
+
+  const vaultsValuation = tx.moveCall({
+    target: `${upgradedPackage}::market::create_vaults_valuation`,
+    typeArguments: [lpType],
+    arguments: [oracle.clock, tx.object(market)],
+  })
+
+  for (const key of Object.keys(vaults)) {
+    const vault = vaults[key]
+    tx.moveCall({
+      target: `${upgradedPackage}::market::valuate_vault_v2`,
+      typeArguments: [lpType, coinModules[key].module],
+      arguments: [
+        tx.object(market),
+        tx.object(vault.reservingFeeModel),
+        ...oracleArgsWithClock(oracle),
+        vaultsValuation,
+      ],
+    })
+  }
+
+  return vaultsValuation
+}
+
+export interface IValuateSymbolsV2Params {
+  tx: Transaction
+  upgradedPackage: string
+  marketPackage: string
+  lpType: string
+  market: string
+  symbols: Record<string, { fundingFeeModel: string }>
+  coinModules: Record<string, { module: string }>
+  oracle: OracleInputs
+}
+
+/** create_symbols_valuation + valuate_symbol_v2 for each symbol. */
+export function valuateSymbolsV2(params: IValuateSymbolsV2Params): TransactionObjectArgument {
+  const { tx, upgradedPackage, marketPackage, lpType, market, symbols, coinModules, oracle } = params
+
+  const symbolsValuation = tx.moveCall({
+    target: `${upgradedPackage}::market::create_symbols_valuation`,
+    typeArguments: [lpType],
+    arguments: [oracle.clock, tx.object(market)],
+  })
+
+  for (const key of Object.keys(symbols)) {
+    const [direction, token] = parseSymbolKey(key)
+    const symbol = symbols[key]
+    tx.moveCall({
+      target: `${upgradedPackage}::market::valuate_symbol_v2`,
+      typeArguments: [
+        lpType,
+        coinModules[token].module,
+        `${marketPackage}::market::${direction.toUpperCase()}`,
+      ],
+      arguments: [
+        tx.object(market),
+        tx.object(symbol.fundingFeeModel),
+        ...oracleArgsWithClock(oracle),
+        symbolsValuation,
+      ],
+    })
+  }
+
+  return symbolsValuation
+}

package/src/pythProClient.ts

@@ -0,0 +1,406 @@
+/** Kronos Pyth Pro (Pyth Lazer) REST + WebSocket client. */
+
+export type PythProChannel
+  = | 'real_time'
+    | 'fixed_rate@50ms'
+    | 'fixed_rate@200ms'
+    | 'fixed_rate@1000ms'
+
+export interface PythProPriceFeed {
+  priceFeedId: number
+  price: string
+  exponent: number
+  confidence: string
+  feedUpdateTimestamp: string
+  priceUsd: number
+  emaPrice?: string | null
+  emaPriceUsd?: number | null
+}
+
+export interface PythProLatestPriceData {
+  timestampUs: string
+  priceFeeds: PythProPriceFeed[]
+  leEcdsaHex: string | null
+}
+
+export interface PythProLatestPriceResponse {
+  success: boolean
+  timestamp?: string
+  data?: PythProLatestPriceData
+  message?: string
+}
+
+export interface IGetLatestPythProPricesOptions {
+  priceFeedIds: number[]
+  channel?: PythProChannel
+  includeEmaPrice?: boolean
+  includeUpdateBytes?: boolean
+  /** Override kronos REST base URL (default: `DEFAULT_API_ENDPOINT` or SDK instance apiEndpoint). */
+  kronosUrl?: string
+}
+
+export interface PythProStreamUpdate {
+  subscriptionId: number
+  timestampUs: string
+  priceFeeds: PythProPriceFeed[]
+  leEcdsaHex?: string | null
+}
+
+export interface IPythProStreamSubscription {
+  subscriptionId: number
+  priceFeedIds: number[]
+  channel?: PythProChannel
+  includeEmaPrice?: boolean
+  includeUpdateBytes?: boolean
+}
+
+export type PythProStreamServerMessage
+  = | { type: 'connected', message?: string }
+    | { type: 'subscribed', subscriptionId: number }
+    | { type: 'unsubscribed', subscriptionId: number }
+    | { type: 'streamUpdated' } & PythProStreamUpdate
+    | { type: 'subscriptionError', subscriptionId: number, message?: string }
+    | { type: 'subscribedWithInvalidFeedIdsIgnored', subscriptionId: number, ignoredFeedIds?: number[] }
+    | { type: 'error', message?: string }
+    | { type: 'pong' }
+
+export type PythProStreamClientMessage
+  = | { type: 'subscribe' } & IPythProStreamSubscription
+    | { type: 'unsubscribe', subscriptionId: number }
+    | { type: 'ping' }
+
+export function hexToBytes(hex: string): Uint8Array {
+  const normalized = hex.startsWith('0x') ? hex.slice(2) : hex
+  const bytes = new Uint8Array(normalized.length / 2)
+  for (let i = 0; i < normalized.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(normalized.slice(i, i + 2), 16)
+  }
+  return bytes
+}
+
+/** Derive ws(s):// stream URL from kronos http(s) base URL. */
+export function apiBaseUrlToPythProWsUrl(baseUrl: string): string {
+  const url = new URL(baseUrl)
+  url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
+  url.pathname = '/pyth-pro/stream'
+  url.search = ''
+  url.hash = ''
+  return url.toString()
+}
+
+function normalizeBaseUrl(baseUrl: string): string {
+  return baseUrl.replace(/\/+$/, '')
+}
+
+function parseLatestPriceResponse(json: PythProLatestPriceResponse): PythProLatestPriceData {
+  if (!json.success || !json.data) {
+    throw new Error(json.message ?? 'Pyth Pro latest-price request failed')
+  }
+  return json.data
+}
+
+/**
+ * Fetch latest Pyth Pro prices from kronos REST (`GET` or `POST /pyth-pro/latest-price`).
+ */
+export async function getLatestPythProPrices(
+  baseUrl: string,
+  options: IGetLatestPythProPricesOptions,
+): Promise<PythProLatestPriceData> {
+  const { priceFeedIds, channel, includeEmaPrice, includeUpdateBytes } = options
+  if (priceFeedIds.length === 0) {
+    throw new Error('priceFeedIds is required')
+  }
+
+  const root = normalizeBaseUrl(baseUrl)
+
+  if (priceFeedIds.length <= 20) {
+    const params = new URLSearchParams()
+    params.set('priceFeedIds', priceFeedIds.join(','))
+    if (channel) {
+      params.set('channel', channel)
+    }
+    if (includeEmaPrice) {
+      params.set('includeEmaPrice', 'true')
+    }
+    if (includeUpdateBytes) {
+      params.set('includeUpdateBytes', 'true')
+    }
+
+    const res = await fetch(`${root}/pyth-pro/latest-price?${params}`)
+    const json = await res.json() as PythProLatestPriceResponse
+    if (!res.ok && json.message) {
+      throw new Error(json.message)
+    }
+    return parseLatestPriceResponse(json)
+  }
+
+  const res = await fetch(`${root}/pyth-pro/latest-price`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      priceFeedIds,
+      channel,
+      includeEmaPrice: includeEmaPrice ?? false,
+      includeUpdateBytes: includeUpdateBytes ?? false,
+    }),
+  })
+  const json = await res.json() as PythProLatestPriceResponse
+  if (!res.ok && json.message) {
+    throw new Error(json.message)
+  }
+  return parseLatestPriceResponse(json)
+}
+
+/**
+ * Fetch leEcdsa update bytes via kronos (for on-chain `parse_and_verify_le_ecdsa_update_v2`).
+ */
+export async function fetchPythProUpdateBytesFromKronos(
+  baseUrl: string,
+  feedIds: number[],
+  options?: Pick<IGetLatestPythProPricesOptions, 'channel' | 'includeEmaPrice'>,
+): Promise<Uint8Array> {
+  const data = await getLatestPythProPrices(baseUrl, {
+    priceFeedIds: feedIds,
+    channel: options?.channel,
+    includeEmaPrice: options?.includeEmaPrice,
+    includeUpdateBytes: true,
+  })
+  if (!data.leEcdsaHex) {
+    throw new Error('No leEcdsaHex in kronos Pyth Pro response (set includeUpdateBytes: true)')
+  }
+  return hexToBytes(data.leEcdsaHex)
+}
+
+export interface IPythProStreamClientOptions {
+  /** Defaults to apiBaseUrlToPythProWsUrl(baseUrl). */
+  wsUrl?: string
+  /** Reconnect after disconnect. Default true. */
+  autoReconnect?: boolean
+  /** Initial reconnect delay in ms. Default 1000. */
+  reconnectDelayMs?: number
+  /** Ping interval in ms. Default 30000. Set 0 to disable. */
+  pingIntervalMs?: number
+  /** Custom WebSocket constructor (Node test mocks, etc.). */
+  WebSocketImpl?: typeof WebSocket
+}
+
+type StreamUpdateHandler = (update: PythProStreamUpdate) => void
+type StreamMessageHandler = (message: PythProStreamServerMessage) => void
+
+/**
+ * WebSocket client for kronos `/pyth-pro/stream`.
+ * Multiplexes subscriptions and re-subscribes after reconnect.
+ */
+export class PythProStreamClient {
+  private readonly wsUrl: string
+  private readonly autoReconnect: boolean
+  private readonly reconnectDelayMs: number
+  private readonly pingIntervalMs: number
+  private readonly WebSocketImpl: typeof WebSocket
+
+  private ws: WebSocket | null = null
+  private connectPromise: Promise<void> | null = null
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  private pingTimer: ReturnType<typeof setInterval> | null = null
+  private closedByUser = false
+
+  private readonly subscriptions = new Map<number, IPythProStreamSubscription>()
+  private readonly updateHandlers = new Map<number, Set<StreamUpdateHandler>>()
+  private readonly messageHandlers = new Set<StreamMessageHandler>()
+
+  constructor(baseUrl: string, options?: IPythProStreamClientOptions) {
+    this.wsUrl = options?.wsUrl ?? apiBaseUrlToPythProWsUrl(baseUrl)
+    this.autoReconnect = options?.autoReconnect ?? true
+    this.reconnectDelayMs = options?.reconnectDelayMs ?? 1000
+    this.pingIntervalMs = options?.pingIntervalMs ?? 30_000
+    this.WebSocketImpl = options?.WebSocketImpl ?? WebSocket
+  }
+
+  /** Open the WebSocket and wait for the server `connected` message (or socket open). */
+  connect(): Promise<void> {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      return Promise.resolve()
+    }
+    if (this.connectPromise) {
+      return this.connectPromise
+    }
+
+    this.closedByUser = false
+    this.connectPromise = new Promise((resolve, reject) => {
+      const ws = new this.WebSocketImpl(this.wsUrl)
+      this.ws = ws
+
+      const onOpen = () => {
+        this.startPing()
+        this.resubscribeAll()
+        resolve()
+      }
+
+      const onError = (event: Event) => {
+        if (ws.readyState !== WebSocket.OPEN) {
+          reject(new Error(`Pyth Pro WebSocket connection failed: ${this.wsUrl}`))
+        }
+        this.emitMessage({ type: 'error', message: String(event) })
+      }
+
+      ws.addEventListener('open', onOpen, { once: true })
+      ws.addEventListener('error', onError, { once: true })
+      ws.addEventListener('message', (event) => {
+        this.handleMessage(String(event.data))
+      })
+      ws.addEventListener('close', () => {
+        this.stopPing()
+        this.ws = null
+        this.connectPromise = null
+        if (!this.closedByUser && this.autoReconnect) {
+          this.scheduleReconnect()
+        }
+      })
+    })
+
+    return this.connectPromise
+  }
+
+  disconnect(): void {
+    this.closedByUser = true
+    this.clearReconnect()
+    this.stopPing()
+    if (this.ws) {
+      this.ws.close()
+      this.ws = null
+    }
+    this.connectPromise = null
+  }
+
+  /**
+   * Subscribe to live price updates. Returns an unsubscribe function.
+   * `onUpdate` is called for each `streamUpdated` matching `subscriptionId`.
+   */
+  subscribe(
+    options: IPythProStreamSubscription,
+    onUpdate: StreamUpdateHandler,
+  ): () => void {
+    this.subscriptions.set(options.subscriptionId, options)
+
+    let handlers = this.updateHandlers.get(options.subscriptionId)
+    if (!handlers) {
+      handlers = new Set()
+      this.updateHandlers.set(options.subscriptionId, handlers)
+    }
+    handlers.add(onUpdate)
+
+    void this.connect().then(() => {
+      this.send({ type: 'subscribe', ...options })
+    })
+
+    return () => {
+      this.unsubscribe(options.subscriptionId, onUpdate)
+    }
+  }
+
+  /** Remove one handler or the whole subscription when `onUpdate` is omitted. */
+  unsubscribe(subscriptionId: number, onUpdate?: StreamUpdateHandler): void {
+    const handlers = this.updateHandlers.get(subscriptionId)
+    if (onUpdate && handlers) {
+      handlers.delete(onUpdate)
+      if (handlers.size > 0) {
+        return
+      }
+    }
+
+    this.updateHandlers.delete(subscriptionId)
+    this.subscriptions.delete(subscriptionId)
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.send({ type: 'unsubscribe', subscriptionId })
+    }
+  }
+
+  onMessage(handler: StreamMessageHandler): () => void {
+    this.messageHandlers.add(handler)
+    return () => {
+      this.messageHandlers.delete(handler)
+    }
+  }
+
+  private send(message: PythProStreamClientMessage): void {
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      return
+    }
+    this.ws.send(JSON.stringify(message))
+  }
+
+  private resubscribeAll(): void {
+    for (const sub of this.subscriptions.values()) {
+      this.send({ type: 'subscribe', ...sub })
+    }
+  }
+
+  private scheduleReconnect(): void {
+    if (this.reconnectTimer) {
+      return
+    }
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null
+      void this.connect().catch(() => {
+        this.scheduleReconnect()
+      })
+    }, this.reconnectDelayMs)
+  }
+
+  private clearReconnect(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer)
+      this.reconnectTimer = null
+    }
+  }
+
+  private startPing(): void {
+    if (this.pingIntervalMs <= 0) {
+      return
+    }
+    this.stopPing()
+    this.pingTimer = setInterval(() => {
+      this.send({ type: 'ping' })
+    }, this.pingIntervalMs)
+  }
+
+  private stopPing(): void {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer)
+      this.pingTimer = null
+    }
+  }
+
+  private emitMessage(message: PythProStreamServerMessage): void {
+    for (const handler of this.messageHandlers) {
+      handler(message)
+    }
+  }
+
+  private handleMessage(raw: string): void {
+    let message: PythProStreamServerMessage
+    try {
+      message = JSON.parse(raw) as PythProStreamServerMessage
+    }
+    catch {
+      this.emitMessage({ type: 'error', message: `Invalid JSON: ${raw}` })
+      return
+    }
+
+    this.emitMessage(message)
+
+    if (message.type === 'streamUpdated') {
+      const handlers = this.updateHandlers.get(message.subscriptionId)
+      if (handlers) {
+        for (const handler of handlers) {
+          handler({
+            subscriptionId: message.subscriptionId,
+            timestampUs: message.timestampUs,
+            priceFeeds: message.priceFeeds,
+            leEcdsaHex: message.leEcdsaHex,
+          })
+        }
+      }
+    }
+  }
+}