@usherlabs/cex-broker 0.2.11 → 0.2.13

package/dist/handlers/execute-action/context.d.ts

@@ -0,0 +1,40 @@
+import type * as grpc from "@grpc/grpc-js";
+import type { Metadata } from "@grpc/grpc-js";
+import type { Exchange } from "@usherlabs/ccxt";
+import type { z } from "zod";
+import type { BrokerAccount, BrokerPoolEntry } from "../../helpers";
+import type { Action as ActionType } from "../../helpers/constants";
+import type { OtelMetrics } from "../../helpers/otel";
+import type { PolicyConfig } from "../../types";
+import type { ActionRequest, ActionResponse } from "../types";
+export type ActionHandler = (ctx: ExecuteActionContext) => Promise<void>;
+export type ExecuteActionContext = {
+    call: grpc.ServerUnaryCall<ActionRequest, ActionResponse>;
+    wrappedCallback: grpc.sendUnaryData<ActionResponse>;
+    action: ActionType;
+    policy: PolicyConfig;
+    brokers: Record<string, BrokerPoolEntry>;
+    metadata: Metadata;
+    normalizedCex: string;
+    cex: string;
+    symbol?: string;
+    selectedBrokerAccount?: BrokerAccount;
+    broker: Exchange;
+    verity: {
+        proof: string;
+    };
+    applyVerityToBroker: (target: Exchange) => void;
+    useVerity: boolean;
+    verityProverUrl: string;
+    otelMetrics?: OtelMetrics;
+};
+export declare function requireSymbol(ctx: ExecuteActionContext, message?: string): ctx is ExecuteActionContext & {
+    symbol: string;
+};
+export declare function parsePayloadForAction<T>(ctx: ExecuteActionContext, schema: z.ZodType<T>): T | null;
+export declare function rejectWithGrpcError(ctx: ExecuteActionContext, error: unknown, options?: {
+    message?: string;
+    prefix?: string;
+    preferStableMessageOnly?: boolean;
+}): void;
+export declare function successWithProof(ctx: ExecuteActionContext, result: unknown): void;

package/dist/handlers/execute-action/deposit.d.ts

@@ -0,0 +1,2 @@
+import type { ExecuteActionContext } from "./context";
+export declare function handleDeposit(ctx: ExecuteActionContext): Promise<void>;

package/dist/handlers/execute-action/handler.d.ts

@@ -0,0 +1,14 @@
+import * as grpc from "@grpc/grpc-js";
+import { type BrokerPoolEntry } from "../../helpers/broker";
+import type { OtelMetrics } from "../../helpers/otel";
+import type { PolicyConfig } from "../../types";
+import type { ActionRequest, ActionResponse } from "../types";
+export type ExecuteActionDeps = {
+    policy: PolicyConfig;
+    brokers: Record<string, BrokerPoolEntry>;
+    whitelistIps: string[];
+    useVerity: boolean;
+    verityProverUrl: string;
+    otelMetrics?: OtelMetrics;
+};
+export declare function createExecuteActionHandler(deps: ExecuteActionDeps): (call: grpc.ServerUnaryCall<ActionRequest, ActionResponse>, callback: grpc.sendUnaryData<ActionResponse>) => Promise<void>;

package/dist/handlers/execute-action/index.d.ts

@@ -0,0 +1,10 @@
+export type { ActionHandler, ExecuteActionContext } from "./context";
+export { handleDeposit } from "./deposit";
+export { createExecuteActionHandler, type ExecuteActionDeps, } from "./handler";
+export { handleInternalTransfer } from "./internal-transfer";
+export { handleOrderBookCall } from "./order-book-call";
+export { handleOrders } from "./orders";
+export { handlePassThrough } from "./pass-through";
+export { ACTION_HANDLERS, dispatchExecuteAction } from "./registry";
+export { handleTreasuryCall } from "./treasury-call";
+export { handleWithdraw } from "./withdraw";

package/dist/handlers/execute-action/internal-transfer.d.ts

@@ -0,0 +1,2 @@
+import type { ExecuteActionContext } from "./context";
+export declare function handleInternalTransfer(ctx: ExecuteActionContext): Promise<void>;

package/dist/handlers/execute-action/order-book-call.d.ts

@@ -0,0 +1,3 @@
+import type { ExecuteActionContext } from "./context";
+/** Handles Action.Call order-book methods before generic broker dispatch. Returns true when fully handled. */
+export declare function handleOrderBookCall(ctx: ExecuteActionContext): Promise<boolean>;

package/dist/handlers/execute-action/orders.d.ts

@@ -0,0 +1,2 @@
+import type { ExecuteActionContext } from "./context";
+export declare function handleOrders(ctx: ExecuteActionContext): Promise<void>;

package/dist/handlers/execute-action/pass-through.d.ts

@@ -0,0 +1,2 @@
+import type { ExecuteActionContext } from "./context";
+export declare function handlePassThrough(ctx: ExecuteActionContext): Promise<void>;

package/dist/handlers/execute-action/perp-config.d.ts

@@ -0,0 +1,2 @@
+import type { ExecuteActionContext } from "./context";
+export declare function handlePerpConfig(ctx: ExecuteActionContext): Promise<void>;

package/dist/handlers/execute-action/registry.d.ts

@@ -0,0 +1,5 @@
+import { type Action as ActionType } from "../../helpers/constants";
+import type { ActionHandler, ExecuteActionContext } from "./context";
+/** Maps each ExecuteAction to its handler module. Cluster routers (orders, pass-through) are registered per action. */
+export declare const ACTION_HANDLERS: Partial<Record<ActionType, ActionHandler>>;
+export declare function dispatchExecuteAction(ctx: ExecuteActionContext): Promise<void>;

package/dist/handlers/execute-action/treasury-call.d.ts

@@ -0,0 +1,2 @@
+import type { ExecuteActionContext } from "./context";
+export declare function handleTreasuryCall(ctx: ExecuteActionContext): Promise<void>;

package/dist/handlers/execute-action/withdraw.d.ts

@@ -0,0 +1,2 @@
+import type { ExecuteActionContext } from "./context";
+export declare function handleWithdraw(ctx: ExecuteActionContext): Promise<void>;

package/dist/handlers/subscribe/handler.d.ts

@@ -0,0 +1,12 @@
+import * as grpc from "@grpc/grpc-js";
+import { type BrokerPoolEntry } from "../../helpers/broker";
+import type { OtelMetrics } from "../../helpers/otel";
+import type { SubscribeRequest, SubscribeResponse } from "../types";
+export type SubscribeDeps = {
+    brokers: Record<string, BrokerPoolEntry>;
+    whitelistIps: string[];
+    otelMetrics?: OtelMetrics;
+};
+type SubscribeCall = grpc.ServerWritableStream<SubscribeRequest, SubscribeResponse>;
+export declare function createSubscribeHandler(deps: SubscribeDeps): (call: SubscribeCall) => Promise<void>;
+export {};

package/dist/handlers/subscribe/index.d.ts

@@ -0,0 +1 @@
+export { createSubscribeHandler, type SubscribeDeps } from "./handler";

package/dist/handlers/types.d.ts

@@ -0,0 +1,23 @@
+import type { ActionName, Action as ActionType, SubscriptionTypeName, SubscriptionType as SubscriptionTypeValue } from "../helpers/constants";
+export type ActionRequest = {
+    action?: ActionType | ActionName;
+    payload?: Record<string, string>;
+    cex?: string;
+    symbol?: string;
+};
+export type ActionResponse = {
+    result: string;
+    proof?: string;
+};
+export type SubscribeRequest = {
+    cex?: string;
+    symbol?: string;
+    type?: SubscriptionTypeValue | SubscriptionTypeName;
+    options?: Record<string, string>;
+};
+export type SubscribeResponse = {
+    data: string;
+    timestamp: number;
+    symbol: string;
+    type: SubscriptionTypeValue;
+};

package/dist/helpers/auth.d.ts

@@ -0,0 +1,5 @@
+type GrpcPeerCall = {
+    getPeer(): string;
+};
+export declare function authenticateRequest(call: GrpcPeerCall, whitelistIps: string[]): boolean;
+export {};

package/dist/helpers/binance-user-data-stream.d.ts

@@ -0,0 +1,28 @@
+import type { Exchange } from "@usherlabs/ccxt";
+export declare const BINANCE_SPOT_WS_API_URL = "wss://ws-api.binance.com:443/ws-api/v3";
+export type BinanceUserDataEvent = {
+    subscriptionId: number;
+    event: Record<string, unknown>;
+};
+export declare function getBinanceSpotWsApiUrl(exchange: Exchange): string;
+export declare class BinanceSpotUserDataStream implements AsyncIterable<BinanceUserDataEvent> {
+    private readonly exchange;
+    private readonly ws;
+    private readonly requestId;
+    private readonly queue;
+    private readonly waiters;
+    private closed;
+    private closeError;
+    private subscriptionId;
+    constructor(exchange: Exchange);
+    [Symbol.asyncIterator](): AsyncIterator<BinanceUserDataEvent>;
+    close(): void;
+    private subscribe;
+    private handleMessage;
+    private push;
+    private nextEvent;
+    private fail;
+    private flushWaiters;
+}
+export declare function isBinanceBalanceUserDataEvent(event: Record<string, unknown>): boolean;
+export declare function isBinanceOrderUserDataEvent(event: Record<string, unknown>): boolean;

package/dist/helpers/broker.d.ts

@@ -0,0 +1,38 @@
+import type { Metadata } from "@grpc/grpc-js";
+import type { Exchange } from "@usherlabs/ccxt";
+import type { BrokerAccountRole, BrokerCredentials } from "../types";
+export type BrokerAccount = {
+    exchange: Exchange;
+    label: "primary" | `secondary:${number}`;
+    index?: number;
+    role?: BrokerAccountRole;
+    email?: string;
+    subAccountId?: string;
+    uid?: string;
+};
+export type BrokerPoolEntry = {
+    primary: BrokerAccount;
+    secondaryBrokers: BrokerAccount[];
+};
+export declare class BrokerAccountPreconditionError extends Error {
+    constructor(message: string);
+}
+export declare function requireDestinationEmail(dest: BrokerAccount, transferType: "sub-to-sub" | "primary-to-sub"): string;
+export declare function applyCommonExchangeConfig(exchange: Exchange): void;
+export declare function createBroker(cex: string, credsOrMetadata: {
+    apiKey: string;
+    apiSecret: string;
+} | Metadata): Exchange | null;
+export declare function createPublicBroker(cex: string): Exchange | null;
+type EnvConfigMap = Record<string, Partial<BrokerCredentials> & {
+    _secondaryMap?: Record<number, Partial<BrokerCredentials>>;
+}>;
+type ValidatedCredentialsMap = Record<string, BrokerCredentials & {
+    secondaryKeys: BrokerCredentials[];
+}>;
+export declare function createBrokerPool(cfg: EnvConfigMap | ValidatedCredentialsMap): Record<string, BrokerPoolEntry>;
+export declare function selectBroker(brokers: BrokerPoolEntry | undefined, metadata: Metadata): Exchange | null;
+export declare function getCurrentBrokerSelector(metadata: Metadata): string;
+export declare function resolveBrokerAccount(brokers: BrokerPoolEntry | undefined, selector: string): BrokerAccount | null;
+export declare function selectBrokerAccount(brokers: BrokerPoolEntry | undefined, metadata: Metadata): BrokerAccount | null;
+export {};

package/dist/helpers/constants.d.ts

@@ -14,6 +14,8 @@ export declare const Action: {
     readonly FetchAccountId: 11;
     readonly FetchFees: 12;
     readonly InternalTransfer: 13;
+    readonly GetPerpConfigState: 14;
+    readonly SetPerpConfigState: 15;
 };
 export declare const SubscriptionType: {
     readonly NO_ACTION: 0;
@@ -25,7 +27,10 @@ export declare const SubscriptionType: {
     readonly ORDERS: 6;
 };
 export type Action = (typeof Action)[keyof typeof Action];
+export type ActionName = keyof typeof Action;
 export type SubscriptionType = (typeof SubscriptionType)[keyof typeof SubscriptionType];
+export type SubscriptionTypeName = keyof typeof SubscriptionType;
 export declare function getActionName(action: unknown): string;
-export declare function getSubscriptionTypeName(subscriptionType: number): string;
-export declare function resolveSubscriptionType(type: SubscriptionType | undefined): SubscriptionType;
+export declare function getSubscriptionTypeName(subscriptionType: unknown): string;
+export declare function resolveAction(action: Action | ActionName | undefined): Action | undefined;
+export declare function resolveSubscriptionType(type: SubscriptionType | SubscriptionTypeName | undefined): SubscriptionType;

package/dist/helpers/deposit.d.ts

@@ -0,0 +1,5 @@
+export declare function depositField(deposit: Record<string, unknown>, fields: string[]): {} | undefined;
+export declare function normalizeDepositStatus(status: unknown): "unsupported" | "not_found" | "pending" | "credited" | "failed" | "timed_out";
+export declare function depositMatchesTransaction(deposit: Record<string, unknown>, transactionHash: string): boolean;
+export declare function stringAmountEquals(left: unknown, right: unknown): boolean;
+export declare function normalizeAddress(value: unknown): string | undefined;

package/dist/helpers/exchange-credentials.d.ts

@@ -0,0 +1,10 @@
+import type { Exchange } from "@usherlabs/ccxt";
+export type BrokerKeyPair = {
+    apiKey: string;
+    apiSecret: string;
+};
+type RequiredCredentials = Exchange["requiredCredentials"];
+export declare function getExchangeRequiredCredentials(cex: string): RequiredCredentials | null;
+export declare function isWalletBasedExchange(cex: string): boolean;
+export declare function buildCcxtConfig(cex: string, creds: BrokerKeyPair): Record<string, string> | null;
+export {};

package/dist/helpers/grpc/broker.d.ts

@@ -0,0 +1,5 @@
+import type { Metadata } from "@grpc/grpc-js";
+import type { Exchange } from "@usherlabs/ccxt";
+import { type BrokerAccount, type BrokerPoolEntry } from "../broker";
+export declare function resolveActionBroker(normalizedCex: string, brokers: Record<string, BrokerPoolEntry>, metadata: Metadata, selectedBrokerAccount?: BrokerAccount): Exchange | null;
+export declare function selectBrokerAccountForCex(normalizedCex: string, brokers: Record<string, BrokerPoolEntry>, metadata: Metadata): BrokerAccount | undefined;

package/dist/helpers/grpc/callbacks.d.ts

@@ -0,0 +1,9 @@
+import * as grpc from "@grpc/grpc-js";
+import type { z } from "zod";
+import { type ParsePayloadResult } from "./payload";
+export declare function invalidArgumentError(message: string): grpc.ServiceError;
+export declare function rejectInvalidPayload<T>(parsed: ParsePayloadResult<T>, callback: (error: grpc.ServiceError | null, value: null) => void): parsed is {
+    success: true;
+    data: T;
+};
+export declare function parseActionPayload<T>(schema: z.ZodType<T>, rawPayload: Record<string, string> | undefined, callback: (error: grpc.ServiceError | null, value: null) => void): T | null;

package/dist/helpers/grpc/payload.d.ts

@@ -0,0 +1,9 @@
+import type { z } from "zod";
+export type ParsePayloadResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    message: string;
+};
+export declare function parsePayload<T>(schema: z.ZodType<T>, rawPayload: Record<string, string> | undefined): ParsePayloadResult<T>;

package/dist/helpers/grpc/status.d.ts

@@ -0,0 +1,8 @@
+import * as grpc from "@grpc/grpc-js";
+export declare function stableGrpcErrorCode(message: string): grpc.status | undefined;
+/** Maps CCXT typed errors to appropriate gRPC status codes. Returns undefined for unrecognized errors. */
+export declare function mapCcxtErrorToGrpcStatus(error: unknown): grpc.status | undefined;
+export declare function resolveGrpcError(error: unknown, message?: string): {
+    code: grpc.status;
+    message: string;
+};

package/dist/helpers/index.d.ts

@@ -1,47 +1,15 @@
-import type { Metadata, ServerUnaryCall } from "@grpc/grpc-js";
-import type { Exchange, HttpClientOverride, HttpOverridePredicate } from "@usherlabs/ccxt";
-import type { BrokerAccountRole, BrokerCredentials, PolicyConfig } from "../types";
-export type BrokerAccount = {
-    exchange: Exchange;
-    label: "primary" | `secondary:${number}`;
-    index?: number;
-    role?: BrokerAccountRole;
-    email?: string;
-    subAccountId?: string;
-    uid?: string;
-};
-export type BrokerPoolEntry = {
-    primary: BrokerAccount;
-    secondaryBrokers: BrokerAccount[];
-};
-export declare class BrokerAccountPreconditionError extends Error {
-    constructor(message: string);
-}
-export declare function authenticateRequest<T, E>(call: ServerUnaryCall<T, E>, whitelistIps: string[]): boolean;
-export declare function createVerityHttpClientOverride(verityProverUrl: string, onProofCallback: (proof: string, notaryPubKey?: string) => void): (redact: string, proofTimeout: number) => HttpClientOverride;
-export declare function applyCommonExchangeConfig(exchange: Exchange): void;
-export declare function buildHttpClientOverrideFromMetadata(metadata: Metadata, verityProverUrl: string, onProofCallback: (proof: string, notaryPubKey?: string) => void): HttpClientOverride;
-export declare const verityHttpClientOverridePredicate: HttpOverridePredicate;
-export declare function createBroker(cex: string, credsOrMetadata: {
-    apiKey: string;
-    apiSecret: string;
-} | Metadata): Exchange | null;
-type EnvConfigMap = Record<string, Partial<BrokerCredentials> & {
-    _secondaryMap?: Record<number, Partial<BrokerCredentials>>;
-}>;
-type ValidatedCredentialsMap = Record<string, BrokerCredentials & {
-    secondaryKeys: BrokerCredentials[];
-}>;
-export declare function createBrokerPool(cfg: EnvConfigMap | ValidatedCredentialsMap): Record<string, BrokerPoolEntry>;
-export declare function selectBroker(brokers: BrokerPoolEntry | undefined, metadata: Metadata): Exchange | null;
-export declare function getCurrentBrokerSelector(metadata: Metadata): string;
-export declare function resolveBrokerAccount(brokers: BrokerPoolEntry | undefined, selector: string): BrokerAccount | null;
-export declare function selectBrokerAccount(brokers: BrokerPoolEntry | undefined, metadata: Metadata): BrokerAccount | null;
+import type { Exchange } from "@usherlabs/ccxt";
+import type { PolicyConfig } from "../types";
+import { type BrokerAccount } from "./broker";
+export { authenticateRequest } from "./auth";
+export { applyCommonExchangeConfig, type BrokerAccount, BrokerAccountPreconditionError, type BrokerPoolEntry, createBroker, createBrokerPool, createPublicBroker, getCurrentBrokerSelector, resolveBrokerAccount, selectBroker, selectBrokerAccount, } from "./broker";
+export { buildHttpClientOverrideFromMetadata, createVerityHttpClientOverride, verityHttpClientOverridePredicate, } from "./verity";
 /**
  * Loads and validates policy configuration
  */
 export declare function loadPolicy(policyPath: string): PolicyConfig;
 export declare function normalizePolicyConfig(policy: PolicyConfig): PolicyConfig;
+export declare function normalizeBrokerNetworkId(network: string): string;
 export declare function validateWithdraw(policy: PolicyConfig, exchange: string, network: string, recipientAddress: string, _amount: number, ticker: string): {
     valid: boolean;
     error?: string;
@@ -67,9 +35,8 @@ type OrderExecutionResolution = {
     limitsApplied?: boolean;
     matchedPatterns?: string[];
 };
-export declare function resolveOrderExecution(policy: PolicyConfig, broker: Exchange, cex: string, fromToken: string, toToken: string, amount: number, price: number): Promise<OrderExecutionResolution>;
+export declare function resolveOrderExecution(policy: PolicyConfig, broker: Exchange, cex: string, fromToken: string, toToken: string, amount: number, price: number, marketTypeInput?: unknown): Promise<OrderExecutionResolution>;
 export declare function validateDeposit(policy: PolicyConfig, exchange: string, network: string, ticker: string): {
     valid: boolean;
     error?: string;
 };
-export {};

package/dist/helpers/market-type.d.ts

@@ -0,0 +1,16 @@
+import type { Exchange } from "@usherlabs/ccxt";
+export type BrokerMarketType = "spot" | "swap" | "future";
+export type TradableSymbolMatch = {
+    symbol: string;
+    side: "buy" | "sell";
+    marketType: BrokerMarketType;
+};
+export declare function parseMarketType(value: unknown): BrokerMarketType;
+export declare function marketTypeToCcxtType(marketType: BrokerMarketType): "spot" | "swap" | "future";
+export declare function findTradableSymbol(broker: Exchange, fromToken: string, toToken: string, marketType?: BrokerMarketType): Promise<TradableSymbolMatch | null>;
+export declare function resolveSubscriptionSymbol(broker: Exchange, symbol: string, marketTypeInput: unknown): Promise<string>;
+export type ParsedMarketPattern = {
+    symbolPattern: string;
+    requiredMarketType?: BrokerMarketType;
+};
+export declare function parseMarketPattern(symbolPattern: string): ParsedMarketPattern;

package/dist/helpers/order-book.d.ts

@@ -0,0 +1,79 @@
+import type { Exchange } from "@usherlabs/ccxt";
+export declare const ORDER_BOOK_CALL_METHODS: {
+    readonly FETCH_CAPABILITY: "fetch_order_book_capability";
+    readonly FETCH_SNAPSHOT: "fetch_order_book_snapshot";
+    readonly FETCH_HISTORICAL_SNAPSHOTS: "fetch_historical_order_book_snapshots";
+};
+export type OrderBookCallMethod = (typeof ORDER_BOOK_CALL_METHODS)[keyof typeof ORDER_BOOK_CALL_METHODS];
+export declare const ORDER_BOOK_CONSTRUCTION_MODES: {
+    readonly SAMPLED_TOP_N_SNAPSHOT: "sampled_top_n_snapshot";
+    readonly EXACT_L2_RECONSTRUCTION: "exact_l2_reconstruction";
+};
+export type OrderBookConstructionMode = (typeof ORDER_BOOK_CONSTRUCTION_MODES)[keyof typeof ORDER_BOOK_CONSTRUCTION_MODES];
+export declare const HISTORICAL_ORDER_BOOK_PROVIDER_UNSUPPORTED = "historical_order_book_provider_unsupported";
+export type OrderBookCallPayload = {
+    method: OrderBookCallMethod;
+    exchange: string;
+    symbol: string;
+    depthLimit: number;
+    constructionMode: OrderBookConstructionMode;
+    start?: string;
+    end?: string;
+    cadence?: string;
+};
+export type OrderBookCallParseResult = {
+    kind: "not_order_book";
+} | {
+    kind: "error";
+    message: string;
+} | {
+    kind: "order_book";
+    payload: OrderBookCallPayload;
+};
+export type NormalizedOrderBookSnapshot = {
+    bids: number[][];
+    asks: number[][];
+    timestamp: number | string | boolean | null;
+    receivedTimestamp: number;
+    exchange: string;
+    symbol: string;
+    depthLimit: number;
+    sequence?: number | string | boolean;
+};
+export declare function isOrderBookCallMethod(value: unknown): value is OrderBookCallMethod;
+export declare function parseOrderBookCallPayload(payload: Record<string, string> | undefined, request: {
+    exchange?: string;
+    symbol?: string;
+}): OrderBookCallParseResult;
+export declare function parseOptionalDepthLimit(value: string | undefined): number | undefined;
+export declare function normalizeOrderBookSnapshot(orderBook: unknown, options: {
+    exchange: string;
+    symbol: string;
+    depthLimit: number;
+    receivedTimestamp?: number;
+}): NormalizedOrderBookSnapshot;
+export declare function buildOrderBookCapability(broker: Exchange, payload: Pick<OrderBookCallPayload, "exchange" | "symbol" | "depthLimit" | "constructionMode">): {
+    exchange: string;
+    symbol: string;
+    provider: string;
+    maxDepth: number;
+    timestampPrecision: string;
+    constructionMode: OrderBookConstructionMode;
+    supportsCurrentSnapshot: boolean;
+    supportsLiveStream: boolean;
+    supportsHistoricalSnapshots: boolean;
+    supportsSampledTopN: boolean;
+    supportsExactL2Reconstruction: boolean;
+};
+export declare function buildHistoricalOrderBookUnsupported(payload: OrderBookCallPayload): {
+    exchange: string;
+    symbol: string;
+    provider: string;
+    constructionMode: OrderBookConstructionMode;
+    depthLimit: number;
+    start: string | undefined;
+    end: string | undefined;
+    cadence: string | undefined;
+    unsupported: boolean;
+    unsupportedReason: string;
+};

package/dist/helpers/order-telemetry.d.ts

@@ -0,0 +1,48 @@
+import type { OtelMetrics } from "./otel";
+export type OrderTelemetryAction = "CreateOrder" | "GetOrderDetails";
+export type OrderTelemetryContext = {
+    action: OrderTelemetryAction;
+    cex: string;
+    accountLabel?: string;
+    symbol?: string;
+    side?: string;
+    orderType?: string;
+    requestedQuantity?: number;
+    requestedNotional?: number;
+    clientOrderId?: string;
+    idempotencyId?: string;
+    makerActionId?: string;
+    brokerObservedTimestamp?: string;
+};
+export type OrderExecutionTelemetry = {
+    event: "cex_market_action_execution";
+    action: OrderTelemetryAction;
+    cex: string;
+    accountLabel: string;
+    symbol: string;
+    side: string;
+    orderType: string;
+    orderId?: string;
+    clientOrderId?: string;
+    idempotencyId?: string;
+    makerActionId?: string;
+    status: string;
+    requestedQuantity?: number;
+    requestedNotional?: number;
+    executedBaseQuantity?: number;
+    executedQuoteQuantity?: number;
+    averageExecutionPrice?: number;
+    filledAmount?: number;
+    remainingAmount?: number;
+    feeAmount?: number;
+    feeCurrency?: string;
+    feeRate?: number;
+    exchangeTimestamp?: string;
+    brokerObservedTimestamp: string;
+    errorType?: string;
+    errorMessage?: string;
+};
+export declare function emitOrderExecutionTelemetry(otelMetrics: OtelMetrics | undefined, context: OrderTelemetryContext, order: unknown, error?: unknown): Promise<OrderExecutionTelemetry | undefined>;
+export declare function buildOrderExecutionTelemetry(context: OrderTelemetryContext, order: unknown, error?: unknown): OrderExecutionTelemetry;
+export declare function emitOrderExecutionTelemetryInBackground(otelMetrics: OtelMetrics | undefined, context: OrderTelemetryContext, order: unknown, error?: unknown): void;
+export declare function extractOrderTelemetryIds(params: Record<string, string | number> | undefined): Pick<OrderTelemetryContext, "clientOrderId" | "idempotencyId" | "makerActionId">;

package/dist/helpers/shared/errors.d.ts

@@ -0,0 +1,2 @@
+export declare function getErrorMessage(error: unknown): string;
+export declare function safeLogError(context: string, error: unknown): void;

package/dist/helpers/shared/guards.d.ts

@@ -0,0 +1,2 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function asRecord<T extends Record<string, unknown> = Record<string, unknown>>(value: unknown): T | undefined;

package/dist/helpers/transfer-network.d.ts

@@ -0,0 +1,12 @@
+import type { Exchange } from "@usherlabs/ccxt";
+export type TransferNetworkResolution = {
+    operatorAlias: string;
+    brokerNetworkId: string;
+    exchangeNetworkId: string;
+    networkKey: string | null;
+};
+export declare function buildTransferNetworkEvidence(currencyInfo: Record<string, unknown>): {
+    networks: Record<string, unknown>;
+    aliases: Record<string, TransferNetworkResolution>;
+};
+export declare function resolveTransferNetwork(broker: Exchange, assetCode: string, operatorAlias: string): Promise<TransferNetworkResolution>;

package/dist/helpers/treasury-discovery.d.ts

@@ -0,0 +1,17 @@
+import type { Exchange } from "@usherlabs/ccxt";
+export type ExchangeWithDiscovery = Exchange & {
+    has?: Record<string, unknown>;
+    markets?: Record<string, unknown>;
+    currencies?: Record<string, unknown>;
+    fetchMarkets?: (...args: unknown[]) => Promise<unknown>;
+    fetchCurrencies?: (...args: unknown[]) => Promise<Record<string, unknown>>;
+    fetchDeposits?: (code?: string, since?: number, limit?: number, params?: Record<string, unknown>) => Promise<Array<Record<string, unknown>>>;
+};
+export declare function callArgs(args: unknown[] | undefined, params: Record<string, unknown> | undefined): unknown[];
+export declare function handleTreasuryDiscoveryCall(broker: Exchange, functionName: string, args: unknown[], params: Record<string, unknown>): Promise<{
+    handled: true;
+    result: unknown;
+} | {
+    handled: false;
+}>;
+export declare function fetchCurrencyMetadata(broker: Exchange, assetCode: string): Promise<Record<string, unknown> | undefined>;

package/dist/helpers/verity.d.ts

@@ -0,0 +1,5 @@
+import type { Metadata } from "@grpc/grpc-js";
+import type { HttpClientOverride, HttpOverridePredicate } from "@usherlabs/ccxt";
+export declare function createVerityHttpClientOverride(verityProverUrl: string, onProofCallback: (proof: string, notaryPubKey?: string) => void): (redact: string, proofTimeout: number) => HttpClientOverride;
+export declare function buildHttpClientOverrideFromMetadata(metadata: Metadata, verityProverUrl: string, onProofCallback: (proof: string, notaryPubKey?: string) => void): HttpClientOverride;
+export declare const verityHttpClientOverridePredicate: HttpOverridePredicate;