@usherlabs/cex-broker 0.2.49 → 0.2.51

package/dist/helpers/market-data-vendor-backfill/promotion.d.ts

@@ -1,5 +1,6 @@
 import { type BackfillArchiveRow, type PromotionReceipt, type PromotionReceiptWire } from "./contracts";
 export type StablePromotionReceipt = Omit<PromotionReceipt, "receiptId" | "verificationTimeMs">;
+export declare function promotionReceiptMatchesCurrentPolicies(receipt: PromotionReceiptWire): boolean;
 export declare function promotionReceiptId(receipt: StablePromotionReceipt): string;
 type UnfinalizedPromotionReceiptWire = Omit<PromotionReceiptWire, "receipt_id" | "promotion_identity_sha256"> & Partial<Pick<PromotionReceiptWire, "receipt_id" | "promotion_identity_sha256">>;
 export declare function finalizePromotionReceipt(receipt: UnfinalizedPromotionReceiptWire): PromotionReceiptWire;

package/dist/helpers/source-tape-sandbox.d.ts

@@ -0,0 +1,82 @@
+import type { ArchiveQueryClient } from "./market-data-vendor-backfill/archive-reader";
+import type { ArchiveSelectionWire, ForwarderBatch, MarketDataVendorBackfillRequest, ProviderObjectEvidence } from "./market-data-vendor-backfill/contracts";
+import type { CandidateVerification } from "./market-data-vendor-backfill/core";
+import { SOURCE_TAPE_CONSTRUCTION_MODE, SOURCE_TAPE_SANDBOX_TARGET, type SourceTapeArchiveSinkResult } from "./source-tape";
+export declare function verifySourceTapeArchive(input: {
+    request: MarketDataVendorBackfillRequest;
+    sinkResult: SourceTapeArchiveSinkResult;
+    client: ArchiveQueryClient;
+}): Promise<CandidateVerification>;
+export type SourceTapeExportArtifact = {
+    file_name: string;
+    rows: number;
+    bytes: number;
+    sha256: string;
+    projection_schema_id: string;
+    projection_schema_sha256: string;
+};
+export type SourceTapeExportResult = {
+    promotionReceiptIds: string[];
+    levels: SourceTapeExportArtifact;
+    summary: SourceTapeExportArtifact;
+};
+export type SourceTapeSandboxEvidence = {
+    schema_id: "market-data-source-tape-sandbox-evidence/v1";
+    archive_target: typeof SOURCE_TAPE_SANDBOX_TARGET;
+    construction_mode: typeof SOURCE_TAPE_CONSTRUCTION_MODE;
+    normal_archive_path: true;
+    tape_capability: {
+        policy_id: string;
+        policy_sha256: string;
+    };
+    state_count: number;
+    promotion: {
+        receipt_id: string;
+        promotion_identity_sha256: string;
+        qualification_event_id: string;
+    };
+    selection: {
+        selection_sha256: string;
+        receipt_ids: string[];
+    };
+    export: {
+        levels: SourceTapeExportArtifact;
+        summary: SourceTapeExportArtifact;
+    };
+    projection_schema_pins: readonly {
+        schema_id: string;
+        schema_sha256: string;
+    }[];
+};
+export declare function promoteAndExportSourceTapeSandbox(input: {
+    request: MarketDataVendorBackfillRequest;
+    sinkResult: SourceTapeArchiveSinkResult;
+    verification: CandidateVerification;
+    datasetObjects: ProviderObjectEvidence[];
+    vendorSemanticDigest: string;
+    verifiedAt: string;
+    forwarder: {
+        submit(batch: ForwarderBatch): Promise<{
+            ok: boolean;
+            inserted: number;
+        }>;
+    };
+    archive: {
+        resolveSelection(request: MarketDataVendorBackfillRequest): Promise<ArchiveSelectionWire>;
+    };
+    exporter: {
+        export(request: {
+            schema_id: "https://schemas.usher.so/cex-canonical-orderbook-export-request/v1";
+            request_id: string;
+            target: {
+                environment: string;
+                cluster: string;
+            };
+            selection: ArchiveSelectionWire;
+            depth: 100;
+            construction_mode: typeof SOURCE_TAPE_CONSTRUCTION_MODE;
+            canonical_schema_version: string;
+            checksum_algorithm: "sha256-canonical-json-v1";
+        }): Promise<SourceTapeExportResult>;
+    };
+}): Promise<SourceTapeSandboxEvidence>;

package/dist/helpers/source-tape.d.ts

@@ -0,0 +1,165 @@
+import type { BackfillArchiveRow, ForwarderBatch } from "./market-data-vendor-backfill/contracts";
+import { type PolicyNeutralCryptoHftBookState, type PolicyNeutralTapeSink } from "./market-data-vendor-backfill/cryptohftdata";
+export declare const SOURCE_TAPE_CAPABILITY: Readonly<{
+    policy_id: string;
+    provider: string;
+    adapter_version: string;
+    acquisition_policy_id: string;
+    exchange: string;
+    market_type: string;
+    feed: string;
+    trading_pairs: string[];
+    construction_mode: string;
+    canonical_schema_id: string;
+    depth: number;
+    source_window_scan: string;
+    provider_object_inventory: string;
+    state_emission: string;
+    state_window: string;
+    archive_target: {
+        environment: string;
+        cluster: string;
+    };
+    archive_path: string;
+    submission_bounds: {
+        max_states_per_yield: number;
+        max_rows_per_batch: number;
+        max_bytes_per_batch: number;
+        max_in_flight: number;
+    };
+    clickhouse_image: string;
+    clickhouse_server_version: string;
+    projection_schema_ids: string[];
+    policy_sha256: string;
+}>;
+export declare const SOURCE_TAPE_CAPABILITY_ID: string;
+export declare const SOURCE_TAPE_CONSTRUCTION_MODE: "policy_neutral_top_n_state_change_tape/v1";
+export declare const SOURCE_TAPE_DEPTH: 100;
+export declare const SOURCE_TAPE_MAX_STATES_PER_YIELD: 4;
+export declare const SOURCE_TAPE_MAX_BATCH_ROWS = 1000;
+export declare const SOURCE_TAPE_MAX_BATCH_BYTES: number;
+export declare const SOURCE_TAPE_MAX_IN_FLIGHT: 1;
+export declare const SOURCE_TAPE_SANDBOX_TARGET: Readonly<{
+    environment: "sandbox";
+    cluster: "cex-archive-local";
+}>;
+export declare const SOURCE_TAPE_PROJECTION_PINS: readonly Readonly<{
+    schema_id: string;
+    schema_sha256: string;
+}>[];
+export type SourceTapeProviderObjectInventory = {
+    expected_identities: string[];
+    observed_identities: string[];
+    complete: boolean;
+};
+export declare function sourceTapeCaptureBundleId(input: {
+    idempotencyKey: string;
+    tradingPair: "ARB-USDC" | "ARB-USDT";
+    window: {
+        startTimeMs: number;
+        endTimeMs: number;
+    };
+    expectedObjectIdentities: readonly string[];
+}): string;
+/**
+ * `production` is the stable forwarder mutation-authorization class. It is not
+ * an environment assertion: source-tape qualification remains sandbox-local.
+ */
+export declare function assertSourceTapeSandboxAuthorization(input: {
+    requestAuthorizationId: string;
+    requestTarget: {
+        environment: string;
+        cluster: string;
+    };
+    preflight: {
+        authorizationId: string;
+        scope: "production";
+        environment: string;
+        cluster: string;
+        credentialValidated: boolean;
+    };
+}): void;
+export type SourceTapeArchiveSinkResult = {
+    capture_bundle_id: string;
+    state_count: number;
+    level_row_count: number;
+    summary_row_count: number;
+    forwarder_batch_count: number;
+    forwarder_batch_identity_sha256: string;
+    initializer: {
+        canonical_snapshot_id: string;
+        source_time_ms: number;
+        sequence: string;
+        semantic_stream_position: 0;
+    };
+    expected_semantic_digest: string;
+    first_state_descriptor_sha256: string;
+    last_state_descriptor_sha256: string;
+    provider_object_inventory_complete: true;
+    max_states_per_yield: typeof SOURCE_TAPE_MAX_STATES_PER_YIELD;
+    max_batch_rows: typeof SOURCE_TAPE_MAX_BATCH_ROWS;
+    max_batch_bytes: typeof SOURCE_TAPE_MAX_BATCH_BYTES;
+    max_in_flight_submissions: typeof SOURCE_TAPE_MAX_IN_FLIGHT;
+};
+export type SourceTapeSemanticStateDescriptor = {
+    state_kind: "initialization" | "change";
+    semantic_stream_position: number;
+    canonical_snapshot_id: string;
+    source_time_ms: number;
+    sequence: string;
+    canonical_rows_sha256: string;
+};
+export declare class SourceTapeSemanticDigestAccumulator {
+    private readonly hash;
+    private count;
+    constructor();
+    append(descriptor: SourceTapeSemanticStateDescriptor): void;
+    digest(): string;
+}
+export declare function sourceTapeSemanticStateDescriptor(input: {
+    stateKind: "initialization" | "change";
+    semanticStreamPosition: number;
+    rows: readonly BackfillArchiveRow[];
+}): SourceTapeSemanticStateDescriptor;
+export type SourceTapeArchiveSink = PolicyNeutralTapeSink & {
+    result(): SourceTapeArchiveSinkResult;
+};
+/**
+ * Streams canonical tape rows to the existing archive-forwarder admission
+ * tables. Promotion, selection and exporter-v2 finalization remain later
+ * gates; this sink never creates a receipt or a success manifest by itself.
+ */
+export declare function createSourceTapeArchiveSink(input: {
+    captureBundleId: string;
+    tradingPair: "ARB-USDC" | "ARB-USDT";
+    window: {
+        startTimeMs: number;
+        endTimeMs: number;
+    };
+    forwarder: {
+        submit(batch: ForwarderBatch): Promise<{
+            ok: boolean;
+            inserted: number;
+        }>;
+    };
+}): SourceTapeArchiveSink;
+export declare function providerObjectInventoryIsComplete(inventory: SourceTapeProviderObjectInventory): boolean;
+export declare function evaluateSourceTapeEligibility(input: {
+    source_enumeration_eligible: boolean;
+    provider_object_inventory: SourceTapeProviderObjectInventory;
+    tape_complete: boolean;
+    capability_id: string;
+    capability_sha256: string;
+    construction_mode: string;
+    projection_schema_pins: readonly {
+        schema_id: string;
+        schema_sha256: string;
+    }[];
+    artifact_sha256s: readonly string[];
+    tape_manifest_sha256: string;
+}): boolean;
+export declare function normalizeSourceTapeStates(input: {
+    tape: readonly PolicyNeutralCryptoHftBookState[];
+    capture_bundle_id: string;
+    trading_pair: "ARB-USDC" | "ARB-USDT";
+}): BackfillArchiveRow[];

package/dist/helpers/trace-context.d.ts

@@ -0,0 +1,8 @@
+import type { Metadata } from "@grpc/grpc-js";
+/** gRPC metadata key for lightweight operational correlation with callers. */
+export declare const TRACE_METADATA_KEY = "x-trace-id";
+/**
+ * Returns a validated caller correlation ID without mutating inbound metadata.
+ * Invalid values are deliberately discarded before they can reach telemetry.
+ */
+export declare function extractTraceId(metadata: Metadata): string | undefined;

package/dist/index.js

@@ -294125,7 +294125,7 @@ function commonEvidenceFields(context2, rawCapture, input) {
     source_time_ms: input.eventTimeMs,
     received_time_ms: input.receivedTimeMs,
     snapshot_id: input.snapshotId,
-    construction_mode: "sampled_top_n_snapshot",
+    construction_mode: input.constructionMode,
     gap_policy: "record_gap",
     depth_limit: input.depthLimit,
     sequence: input.sequence,
@@ -294179,7 +294179,8 @@ function buildCanonicalOrderBookRows(input) {
     sequence,
     depthLimit: input.depthLimit,
     eventTimeMs,
-    receivedTimeMs
+    receivedTimeMs,
+    constructionMode: input.constructionMode ?? "sampled_top_n_snapshot"
   });
   const levels = [
     ["bid", bids],
@@ -310668,6 +310669,24 @@ function selectBrokerAccountForCex(normalizedCex, brokers, metadata) {
   return selectBrokerAccount(brokers[normalizedCex], metadata) ?? undefined;
 }
 
+// src/helpers/trace-context.ts
+var TRACE_METADATA_KEY = "x-trace-id";
+var MAX_TRACE_METADATA_LENGTH = 128;
+var OTEL_TRACE_ID_PATTERN = /^[0-9a-f]{32}$/;
+var UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var ZERO_OTEL_TRACE_ID = "00000000000000000000000000000000";
+function extractTraceId(metadata) {
+  const raw = metadata.get(TRACE_METADATA_KEY)[0];
+  if (typeof raw !== "string" || raw.length > MAX_TRACE_METADATA_LENGTH) {
+    return;
+  }
+  const traceId = raw.trim();
+  if (OTEL_TRACE_ID_PATTERN.test(traceId) && traceId !== ZERO_OTEL_TRACE_ID || UUID_V4_PATTERN.test(traceId)) {
+    return traceId;
+  }
+  return;
+}
+
 // src/handlers/execute-action/order-book-call.ts
 import * as grpc4 from "@grpc/grpc-js";
 async function handleOrderBookCall(ctx) {
@@ -311971,6 +311990,15 @@ function isPublicMarketDataAction(action, payload) {
     return false;
   return isOrderBookCallMethod(payload?.method ?? payload?.functionName);
 }
+function grpcStatusName(error48) {
+  if (!error48) {
+    return "OK";
+  }
+  if (typeof error48.code !== "number") {
+    return "UNKNOWN";
+  }
+  return grpc12.status[error48.code] ?? "UNKNOWN";
+}
 function createExecuteActionHandler(deps) {
   const {
     policy,
@@ -311987,12 +312015,28 @@ function createExecuteActionHandler(deps) {
     const startTime = Date.now();
     const { action: rawAction, cex: cex3, symbol: symbol2 } = call.request;
     const action = resolveAction(rawAction);
+    const actionName = getActionName(action);
+    const operationalCex = cex3?.trim().toLowerCase() || "unknown";
+    const traceId = extractTraceId(call.metadata);
+    const traceFields = traceId === undefined ? {} : { trace_id: traceId };
     let actionCompleted = false;
     const wrappedCallback = (error48, value) => {
       if (!actionCompleted) {
         actionCompleted = true;
         const latency = Date.now() - startTime;
-        const actionName = getActionName(action);
+        const terminalFields = {
+          action: actionName,
+          cex: operationalCex,
+          latency_ms: latency,
+          outcome: error48 ? "error" : "success",
+          grpc_status: grpcStatusName(error48),
+          ...traceFields
+        };
+        if (error48) {
+          log.withMetadata(terminalFields).error("ExecuteAction failed");
+        } else {
+          log.withMetadata(terminalFields).info("ExecuteAction completed");
+        }
         otelMetrics?.recordHistogram("execute_action_duration_ms", latency, {
           action: actionName,
           cex: cex3 || "unknown"
@@ -312013,9 +312057,13 @@ function createExecuteActionHandler(deps) {
       callback(error48, value);
     };
     try {
-      log.info(`Request - ExecuteAction:`, { action, cex: cex3, symbol: symbol2 });
+      log.withMetadata({
+        action: actionName,
+        cex: operationalCex,
+        ...traceFields
+      }).info("ExecuteAction started");
       otelMetrics?.recordCounter("execute_action_requests_total", 1, {
-        action: getActionName(action),
+        action: actionName,
         cex: cex3 || "unknown"
       });
       if (!authenticateRequest(call, whitelistIps)) {
@@ -312253,6 +312301,9 @@ async function writeSubscribeError(call, isClosed, frame) {
     call.end();
   }
 }
+function grpcStatusName2(status14) {
+  return typeof status14 === "number" ? grpc13.status[status14] ?? "UNKNOWN" : "UNKNOWN";
+}
 function getBinanceEventMarketId(event) {
   const value = event.s;
   return typeof value === "string" ? value : null;
@@ -312385,6 +312436,24 @@ function createSubscribeHandler(deps) {
   });
   return async (call) => {
     const subscribeStartTime = Date.now();
+    const request = call.request;
+    const { cex: cex3, symbol: symbol2, type: type2 } = request;
+    const metadata = call.metadata;
+    const traceId = extractTraceId(metadata);
+    const traceFields = traceId === undefined ? {} : { trace_id: traceId };
+    const operationalCex = cex3?.trim().toLowerCase() || "unknown";
+    const operationalSymbol = symbol2?.trim() || "unknown";
+    const subscriptionType2 = resolveSubscriptionType(type2);
+    const subscriptionTypeName = getSubscriptionTypeName(subscriptionType2);
+    const operationalFields = {
+      cex: operationalCex,
+      symbol: operationalSymbol,
+      subscription_type: subscriptionTypeName,
+      ...traceFields
+    };
+    let terminalLogged = false;
+    let terminalOutcome = "completed";
+    let terminalGrpcStatus = "OK";
     let streamClosed = false;
     let ownedBroker = null;
     let ownedBrokerClosePromise;
@@ -312407,12 +312476,41 @@ function createSubscribeHandler(deps) {
     const closeOwnedBrokerOnCallEnd = () => {
       closeOwnedBroker();
     };
-    call.once("cancelled", markStreamClosed);
+    const logTerminalOutcome = (outcome) => {
+      if (terminalLogged) {
+        return;
+      }
+      terminalLogged = true;
+      const fields = {
+        ...operationalFields,
+        duration_ms: Date.now() - subscribeStartTime,
+        outcome,
+        grpc_status: outcome === "cancelled" ? "CANCELLED" : terminalGrpcStatus
+      };
+      if (outcome === "error") {
+        log.withMetadata(fields).error("Subscribe failed");
+      } else if (outcome === "cancelled") {
+        log.withMetadata(fields).info("Subscribe cancelled");
+      } else {
+        log.withMetadata(fields).info("Subscribe ended");
+      }
+    };
+    const writeTerminalError = async (frame, status14 = grpc13.status.UNKNOWN) => {
+      terminalOutcome = "error";
+      terminalGrpcStatus = grpcStatusName2(status14);
+      await writeSubscribeError(call, isStreamClosed, frame);
+    };
+    log.withMetadata(operationalFields).info("Subscribe started");
+    call.once("cancelled", () => {
+      terminalGrpcStatus = "CANCELLED";
+      markStreamClosed();
+      logTerminalOutcome("cancelled");
+    });
     call.once("cancelled", closeOwnedBrokerOnCallEnd);
     call.once("error", closeOwnedBrokerOnCallEnd);
     call.once("end", () => {
       markStreamClosed();
-      log.info("Subscribe stream ended");
+      logTerminalOutcome(terminalOutcome);
       const duration3 = Date.now() - subscribeStartTime;
       otelMetrics?.recordHistogram("subscribe_duration_ms", duration3, {
         cex: call.request?.cex || "unknown",
@@ -312421,12 +312519,16 @@ function createSubscribeHandler(deps) {
     });
     call.once("error", (error48) => {
       markStreamClosed();
-      log.error("Subscribe stream error:", error48);
+      terminalOutcome = "error";
+      terminalGrpcStatus = grpcStatusName2(typeof error48 === "object" && error48 !== null && "code" in error48 ? error48.code : undefined);
+      logTerminalOutcome(call.cancelled ? "cancelled" : "error");
       otelMetrics?.recordCounter("subscribe_errors_total", 1, {
         error_type: error48 instanceof Error ? error48.message : "unknown"
       });
     });
     if (!authenticateRequest(call, whitelistIps)) {
+      terminalOutcome = "error";
+      terminalGrpcStatus = "PERMISSION_DENIED";
       otelMetrics?.recordCounter("subscribe_errors_total", 1, {
         error_type: "permission_denied"
       });
@@ -312437,32 +312539,22 @@ function createSubscribeHandler(deps) {
       call.destroy(new Error("Access denied: Unauthorized IP"));
       return;
     }
-    const metadata = call.metadata;
-    let subscriptionType2 = SubscriptionType.ORDERBOOK;
     try {
-      const request = call.request;
-      const { cex: cex3, symbol: symbol2, type: type2, options } = request;
-      subscriptionType2 = resolveSubscriptionType(type2);
-      log.info(`Request - Subscribe:`, {
-        cex: request.cex,
-        symbol: request.symbol,
-        type: subscriptionType2
-      });
-      const subscriptionTypeName = getSubscriptionTypeName(subscriptionType2);
+      const { options } = request;
       otelMetrics?.recordCounter("subscribe_requests_total", 1, {
         cex: cex3 || "unknown",
         symbol: symbol2 || "unknown",
         type: subscriptionTypeName
       });
       if (!cex3 || !symbol2) {
-        await writeSubscribeError(call, isStreamClosed, {
+        await writeTerminalError({
           data: JSON.stringify({
             error: "cex, symbol, and type are required"
           }),
           timestamp: Date.now(),
           symbol: symbol2 || "",
           type: subscriptionType2
-        });
+        }, grpc13.status.INVALID_ARGUMENT);
         return;
       }
       if (isPublicMarketDataSubscription(subscriptionType2)) {
@@ -312491,7 +312583,7 @@ function createSubscribeHandler(deps) {
         } catch (error48) {
           const message = getErrorMessage(error48);
           if (!isStreamClosed()) {
-            await writeSubscribeError(call, isStreamClosed, {
+            await writeTerminalError({
               data: JSON.stringify({ error: message }),
               timestamp: Date.now(),
               symbol: symbol2,
@@ -312512,14 +312604,14 @@ function createSubscribeHandler(deps) {
       const selectedBroker = selectedBrokerAccount?.exchange ?? createBroker(normalizedCex, metadata);
       const broker = selectedBroker ?? createPublicBroker(normalizedCex);
       if (!broker) {
-        await writeSubscribeError(call, isStreamClosed, {
+        await writeTerminalError({
           data: JSON.stringify({
             error: "Exchange not registered and no API metadata found"
           }),
           timestamp: Date.now(),
           symbol: symbol2,
           type: subscriptionType2
-        });
+        }, grpc13.status.NOT_FOUND);
         return;
       }
       if (!selectedBrokerAccount) {
@@ -312547,28 +312639,28 @@ function createSubscribeHandler(deps) {
       if (isBinanceSpotAccountSubscription(normalizedCex, subscriptionType2, options?.marketType)) {
         const accountBroker = selectedBrokerAccount?.exchange ?? selectedBroker;
         if (!accountBroker) {
-          await writeSubscribeError(call, isStreamClosed, {
+          await writeTerminalError({
             data: JSON.stringify({
               error: "Binance account subscriptions require API credentials"
             }),
             timestamp: Date.now(),
             symbol: resolvedSymbol,
             type: subscriptionType2
-          });
+          }, grpc13.status.FAILED_PRECONDITION);
           return;
         }
         const marketId = subscriptionType2 === SubscriptionType.ORDERS ? await getBinanceMarketId(accountBroker, resolvedSymbol) : undefined;
         let userDataSource;
         if (selectedBrokerAccount) {
           if (!userDataStreamSupervisor) {
-            await writeSubscribeError(call, isStreamClosed, {
+            await writeTerminalError({
               data: JSON.stringify({
                 error: "Configured account user-data supervisor is unavailable"
               }),
               timestamp: Date.now(),
               symbol: resolvedSymbol,
               type: subscriptionType2
-            });
+            }, grpc13.status.FAILED_PRECONDITION);
             return;
           }
           userDataSource = userDataStreamSupervisor.subscribe({
@@ -312591,7 +312683,7 @@ function createSubscribeHandler(deps) {
           } catch (error48) {
             const message = getErrorMessage(error48);
             log.error(`Error fetching balance for ${cex3}:`, error48);
-            await writeSubscribeError(call, isStreamClosed, {
+            await writeTerminalError({
               data: JSON.stringify({
                 error: `Failed to fetch balance: ${message}`
               }),
@@ -312610,7 +312702,7 @@ function createSubscribeHandler(deps) {
           } catch (error48) {
             log.error(`Error fetching orders for ${resolvedSymbol} on ${cex3}:`, error48);
             const message = getErrorMessage(error48);
-            await writeSubscribeError(call, isStreamClosed, {
+            await writeTerminalError({
               data: JSON.stringify({
                 error: `Failed to fetch orders: ${message}`
               }),
@@ -312621,26 +312713,27 @@ function createSubscribeHandler(deps) {
           }
           break;
         default:
-          await writeSubscribeError(call, isStreamClosed, {
+          await writeTerminalError({
             data: JSON.stringify({ error: "Invalid subscription type" }),
             timestamp: Date.now(),
             symbol: symbol2,
             type: subscriptionType2
-          });
+          }, grpc13.status.INVALID_ARGUMENT);
       }
     } catch (error48) {
       log.error("Error in Subscribe stream:", error48);
       const message = getErrorMessage(error48);
-      await writeSubscribeError(call, isStreamClosed, {
+      await writeTerminalError({
         data: JSON.stringify({ error: `Internal server error: ${message}` }),
         timestamp: Date.now(),
         symbol: "",
         type: subscriptionType2
-      });
+      }, grpc13.status.INTERNAL);
     } finally {
       call.off("cancelled", closeOwnedBrokerOnCallEnd);
       call.off("error", closeOwnedBrokerOnCallEnd);
       await closeOwnedBroker();
+      logTerminalOutcome(call.cancelled ? "cancelled" : terminalOutcome);
     }
   };
 }
@@ -313252,4 +313345,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=D97F25782E1185C764756E2164756E21
+//# debugId=298884FD1F08284464756E2164756E21