@injectivelabs/sdk-ts 1.17.6 → 1.17.8

package/dist/esm/{StreamManagerV2-B_6ctbMb.js → StreamManagerV2-CbZamzIn.js}

@@ -1,12 +1,15 @@
 import { $t as uint8ArrayToString, a as grpcPagingToPagingV2, nn as bigIntToString, sn as isJsonString, tn as bigIntToNumber } from "./utils-CewUFGKA.js";
-import { t as _defineProperty } from "./defineProperty-Bq6QU9Te.js";
-import { n as GrpcWebRpcTransport } from "./BaseGrpcConsumer-a7fB9A_e.js";
-import { t as BaseIndexerGrpcConsumer } from "./BaseIndexerGrpcConsumer-CrwqSxDq.js";
+import { t as _defineProperty } from "./defineProperty-DuYPbdEg.js";
+import { n as GrpcWebRpcTransport } from "./BaseGrpcConsumer-lUDP-V1I.js";
+import { t as BaseIndexerGrpcConsumer } from "./BaseIndexerGrpcConsumer-ByGqwnv0.js";
 import { t as BaseRestConsumer } from "./BaseRestConsumer-DTvorEHL.js";
-import { r as IndexerModule } from "./IndexerGrpcWeb3GwApi-CX4ohUOk.js";
+import { r as IndexerModule } from "./IndexerGrpcWeb3GwApi-OwqVZsKE.js";
 import { a as TradeDirection, c as GrpcStatusCode, d as StreamState, i as OrderState, l as StreamDisconnectReason, m as TokenVerification, p as TokenType, t as StreamOperation, u as StreamEvent } from "./types-Cf4oVv93.js";
 import { BigNumber, toBigNumber, toHumanReadable } from "@injectivelabs/utils";
 import { GeneralException, HttpRequestException, UnspecifiedErrorCode } from "@injectivelabs/exceptions";
+import { MakerStreamResponse, MakerStreamStreamingRequest, RFQQuoteType, RFQRequestType, TakerStreamResponse, TakerStreamStreamingRequest } from "@injectivelabs/indexer-proto-ts-v2/generated/injective_rfqrpc_pb.js";
+import * as InjectiveRFQExchangeRpcPb from "@injectivelabs/indexer-proto-ts-v2/generated/injective_rfqrpc_pb";
+import { InjectiveRFQRPCClient } from "@injectivelabs/indexer-proto-ts-v2/generated/injective_rfqrpc_pb.client";
 import { MitoAPIClient } from "@injectivelabs/mito-proto-ts-v2/generated/goadesign_goagen_mito_api_pb.client";
 import * as GoadesignGoagenMitoApiPb from "@injectivelabs/mito-proto-ts-v2/generated/goadesign_goagen_mito_api_pb";
 import * as InjectiveMetaRpcPb from "@injectivelabs/indexer-proto-ts-v2/generated/injective_meta_rpc_pb";
@@ -39,6 +42,839 @@ import * as InjectiveInsuranceRpcPb from "@injectivelabs/indexer-proto-ts-v2/gen
 import { InjectiveInsuranceRPCClient } from "@injectivelabs/indexer-proto-ts-v2/generated/injective_insurance_rpc_pb.client";
 import { EventEmitter } from "eventemitter3";
 
+//#region src/client/indexer/ws/types.ts
+/**
+* WebSocket connection states
+*/
+const WsState = {
+	Idle: "idle",
+	Connecting: "connecting",
+	Connected: "connected",
+	Reconnecting: "reconnecting",
+	Disconnected: "disconnected"
+};
+/**
+* Reasons for WebSocket disconnection
+*/
+const WsDisconnectReason = {
+	UserStopped: "user-stopped",
+	ConnectionFailed: "connection-failed",
+	ConnectionTimeout: "connection-timeout",
+	ServerClosed: "server-closed",
+	MaxRetries: "max-retries",
+	Error: "error"
+};
+/**
+* Default reconnection configuration
+*/
+const DEFAULT_RECONNECT_CONFIG = {
+	enabled: true,
+	maxAttempts: 10,
+	initialDelayMs: 1e3,
+	maxDelayMs: 3e4,
+	backoffMultiplier: 2
+};
+/**
+* Default transport configuration values
+*/
+const DEFAULT_TRANSPORT_CONFIG = {
+	protocol: "grpc-ws",
+	connectionTimeoutMs: 1e4
+};
+/**
+* gRPC service paths for RFQ streams
+*/
+const RFQ_GRPC_PATHS = {
+	TakerStream: "/injective_rfqrpc.InjectiveRFQRPC/TakerStream",
+	MakerStream: "/injective_rfqrpc.InjectiveRFQRPC/MakerStream"
+};
+var GrpcDecodeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "GrpcDecodeError";
+	}
+};
+
+//#endregion
+//#region src/client/indexer/ws/GrpcWebSocketCodec.ts
+const COMPRESSION_FLAG_NONE = 0;
+const COMPRESSION_FLAG_TRAILER = 128;
+const GRPC_HEADER_SIZE = 5;
+/**
+* Codec for encoding/decoding gRPC-over-WebSocket messages for RFQ streams.
+*/
+const GrpcWebSocketCodec = {
+	encodeTakerPing() {
+		const message = TakerStreamStreamingRequest.create({ messageType: "ping" });
+		return encodeGrpcFrame(TakerStreamStreamingRequest.toBinary(message));
+	},
+	encodeTakerRequest(input) {
+		const request = RFQRequestType.create({
+			rfqId: BigInt(input.rfqId),
+			marketId: input.marketId,
+			direction: input.direction,
+			margin: input.margin,
+			quantity: input.quantity,
+			worstPrice: input.worstPrice,
+			requestAddress: input.requestAddress,
+			expiry: BigInt(input.expiry),
+			status: input.status,
+			createdAt: 0n,
+			updatedAt: 0n,
+			transactionTime: 0n,
+			height: 0n
+		});
+		const message = TakerStreamStreamingRequest.create({
+			messageType: "request",
+			request
+		});
+		return encodeGrpcFrame(TakerStreamStreamingRequest.toBinary(message));
+	},
+	decodeTakerResponse(data) {
+		return decodeGrpcFrame(data instanceof ArrayBuffer ? new Uint8Array(data) : data, TakerStreamResponse);
+	},
+	encodeMakerPing() {
+		const message = MakerStreamStreamingRequest.create({ messageType: "ping" });
+		return encodeGrpcFrame(MakerStreamStreamingRequest.toBinary(message));
+	},
+	encodeMakerQuote(input) {
+		const quote = RFQQuoteType.create({
+			chainId: input.chainId,
+			contractAddress: input.contractAddress,
+			marketId: input.marketId,
+			rfqId: BigInt(input.rfqId),
+			takerDirection: input.takerDirection,
+			margin: input.margin,
+			quantity: input.quantity,
+			price: input.price,
+			expiry: BigInt(input.expiry),
+			maker: input.maker,
+			taker: input.taker,
+			signature: input.signature,
+			status: input.status,
+			createdAt: 0n,
+			updatedAt: 0n,
+			height: 0n,
+			eventTime: 0n,
+			transactionTime: 0n
+		});
+		const message = MakerStreamStreamingRequest.create({
+			messageType: "quote",
+			quote
+		});
+		return encodeGrpcFrame(MakerStreamStreamingRequest.toBinary(message));
+	},
+	decodeMakerResponse(data) {
+		return decodeGrpcFrame(data instanceof ArrayBuffer ? new Uint8Array(data) : data, MakerStreamResponse);
+	},
+	isTrailerFrame(data) {
+		const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+		if (bytes.length < 1) return false;
+		return (bytes[0] & COMPRESSION_FLAG_TRAILER) !== 0;
+	},
+	getPayloadLength(data) {
+		const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+		if (bytes.length < GRPC_HEADER_SIZE) return -1;
+		return bytes[1] << 24 | bytes[2] << 16 | bytes[3] << 8 | bytes[4];
+	},
+	isCompleteFrame(data) {
+		const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+		if (bytes.length < GRPC_HEADER_SIZE) return false;
+		const payloadLength = this.getPayloadLength(bytes);
+		return bytes.length >= GRPC_HEADER_SIZE + payloadLength;
+	},
+	HEADER_SIZE: GRPC_HEADER_SIZE
+};
+function encodeGrpcFrame(payload) {
+	const frame = new Uint8Array(GRPC_HEADER_SIZE + payload.length);
+	frame[0] = COMPRESSION_FLAG_NONE;
+	new DataView(frame.buffer).setUint32(1, payload.length, false);
+	frame.set(payload, GRPC_HEADER_SIZE);
+	return frame;
+}
+function decodeGrpcFrame(data, messageType) {
+	if (data.byteLength < GRPC_HEADER_SIZE) throw new GrpcDecodeError(`Frame too short: expected at least ${GRPC_HEADER_SIZE} bytes, got ${data.byteLength}`);
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const compressionFlag = view.getUint8(0);
+	const isTrailer = (compressionFlag & COMPRESSION_FLAG_TRAILER) !== 0;
+	const totalLength = GRPC_HEADER_SIZE + view.getUint32(1, false);
+	if (data.byteLength < totalLength) throw new GrpcDecodeError(`Incomplete frame: expected ${totalLength} bytes, got ${data.byteLength}`);
+	const payload = data.subarray(GRPC_HEADER_SIZE, totalLength);
+	if (isTrailer) return {
+		isTrailer: true,
+		payload
+	};
+	if (compressionFlag !== COMPRESSION_FLAG_NONE) throw new GrpcDecodeError(`Unsupported compression flag: 0x${compressionFlag.toString(16)}`);
+	try {
+		return {
+			isTrailer: false,
+			message: messageType.fromBinary(payload),
+			payload
+		};
+	} catch (error) {
+		throw new GrpcDecodeError(`Failed to decode protobuf message: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
+//#endregion
+//#region src/client/indexer/ws/GrpcWebSocketTransport.ts
+/**
+* Low-level gRPC-over-WebSocket transport layer.
+*
+* Handles:
+* - WebSocket connection lifecycle
+* - Reconnection with exponential backoff
+* - State management
+* - Binary message framing
+*
+* This class does NOT handle protobuf encoding/decoding - use GrpcWebSocketCodec for that.
+*/
+var GrpcWebSocketTransport = class {
+	constructor(config) {
+		_defineProperty(this, "config", void 0);
+		_defineProperty(this, "ws", null);
+		_defineProperty(this, "state", WsState.Idle);
+		_defineProperty(this, "connectionTimeout", null);
+		_defineProperty(this, "reconnectTimeout", null);
+		_defineProperty(this, "reconnectAttempts", 0);
+		_defineProperty(this, "currentReconnectDelay", void 0);
+		_defineProperty(this, "isDestroyed", false);
+		_defineProperty(this, "hasConnectedOnce", false);
+		_defineProperty(this, "listeners", /* @__PURE__ */ new Map());
+		this.config = this.resolveConfig(config);
+		this.currentReconnectDelay = this.config.reconnect.initialDelayMs;
+	}
+	getState() {
+		return this.state;
+	}
+	/**
+	* Check if the transport is connected and ready to send
+	*/
+	isConnected() {
+		var _this$ws;
+		return this.state === WsState.Connected && ((_this$ws = this.ws) === null || _this$ws === void 0 ? void 0 : _this$ws.readyState) === 1;
+	}
+	async connect() {
+		if (this.isDestroyed) throw new Error("Transport has been destroyed");
+		if (this.state === WsState.Connected || this.state === WsState.Connecting) return;
+		try {
+			await this.createConnection();
+		} catch (error) {
+			const reason = WsDisconnectReason.ConnectionFailed;
+			if (this.shouldAttemptReconnect(reason)) {
+				this.setState(WsState.Reconnecting);
+				this.emit("disconnect", {
+					reason,
+					willRetry: true
+				});
+				this.scheduleReconnect();
+			} else this.cleanup(reason, false);
+			throw error;
+		}
+	}
+	disconnect() {
+		this.cleanup(WsDisconnectReason.UserStopped, false);
+	}
+	destroy() {
+		this.isDestroyed = true;
+		this.cleanup(WsDisconnectReason.UserStopped, false);
+		this.listeners.clear();
+	}
+	send(data) {
+		if (!this.isConnected()) throw new Error("Cannot send: WebSocket is not connected");
+		this.ws.send(data);
+	}
+	on(event, listener) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(listener);
+	}
+	off(event, listener) {
+		var _this$listeners$get;
+		(_this$listeners$get = this.listeners.get(event)) === null || _this$listeners$get === void 0 || _this$listeners$get.delete(listener);
+	}
+	emit(event, data) {
+		var _this$listeners$get2;
+		(_this$listeners$get2 = this.listeners.get(event)) === null || _this$listeners$get2 === void 0 || _this$listeners$get2.forEach((listener) => {
+			try {
+				listener(data);
+			} catch (error) {
+				console.error(`Error in ${event} listener:`, error);
+			}
+		});
+	}
+	async createConnection() {
+		return new Promise(async (resolve, reject) => {
+			const url = this.config.url;
+			this.connectionTimeout = setTimeout(() => {
+				this.handleConnectionTimeout(reject);
+			}, this.config.connectionTimeoutMs);
+			try {
+				this.ws = await this.createWebSocket(url, this.config.protocol, this.config.metadata);
+				if ("binaryType" in this.ws) this.ws.binaryType = "arraybuffer";
+				this.ws.onopen = () => {
+					this.handleOpen(resolve);
+				};
+				this.ws.onclose = (event) => {
+					this.handleClose(event, reject);
+				};
+				this.ws.onerror = (error) => {
+					this.handleError(error, reject);
+				};
+				this.ws.onmessage = (event) => {
+					this.handleMessage(event);
+				};
+			} catch (error) {
+				this.clearConnectionTimeout();
+				reject(error);
+			}
+		});
+	}
+	async createWebSocket(url, protocol, metadata) {
+		if (typeof WebSocket !== "undefined") {
+			const urlWithMetadata = this.addMetadataToUrl(url, metadata);
+			return new WebSocket(urlWithMetadata, protocol);
+		}
+		return new (await (import("ws"))).default(url, protocol, { headers: metadata || {} });
+	}
+	addMetadataToUrl(url, metadata) {
+		if (!metadata || Object.keys(metadata).length === 0) return url;
+		const params = new URLSearchParams(metadata);
+		return `${url}${url.includes("?") ? "&" : "?"}${params.toString()}`;
+	}
+	/**
+	* Handle WebSocket open event
+	*/
+	handleOpen(resolve) {
+		this.clearConnectionTimeout();
+		this.setState(WsState.Connected);
+		this.reconnectAttempts = 0;
+		this.currentReconnectDelay = this.config.reconnect.initialDelayMs;
+		const isReconnect = this.hasConnectedOnce;
+		this.hasConnectedOnce = true;
+		this.emit("connect", { isReconnect });
+		resolve();
+	}
+	handleClose(event, reject) {
+		if (this.state === WsState.Connecting) {
+			this.clearConnectionTimeout();
+			if (reject) reject(/* @__PURE__ */ new Error(`WebSocket closed before open: code=${event.code}, reason=${event.reason}`));
+			return;
+		}
+		if (this.state === WsState.Disconnected || this.isDestroyed) return;
+		const reason = this.determineDisconnectReason(event);
+		if (this.shouldAttemptReconnect(reason)) {
+			this.setState(WsState.Reconnecting);
+			this.scheduleReconnect();
+			this.emit("disconnect", {
+				reason,
+				willRetry: true
+			});
+		} else this.cleanup(reason, false);
+	}
+	handleError(error, reject) {
+		const errorObj = error instanceof Error ? error : /* @__PURE__ */ new Error("WebSocket error");
+		this.emit("error", errorObj);
+		if (this.state === WsState.Connecting && reject) {
+			this.clearConnectionTimeout();
+			reject(errorObj);
+		}
+	}
+	handleMessage(event) {
+		const data = event.data;
+		if (data instanceof ArrayBuffer) this.emit("message", data);
+		else if (typeof Blob !== "undefined" && data instanceof Blob) data.arrayBuffer().then((buffer) => {
+			this.emit("message", buffer);
+		});
+		else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+			const buffer = new Uint8Array(data).buffer;
+			this.emit("message", buffer);
+		}
+	}
+	handleConnectionTimeout(reject) {
+		var _this$ws2;
+		(_this$ws2 = this.ws) === null || _this$ws2 === void 0 || _this$ws2.close();
+		this.ws = null;
+		reject(/* @__PURE__ */ new Error("Connection timeout"));
+		if (this.shouldAttemptReconnect(WsDisconnectReason.ConnectionTimeout)) {
+			this.setState(WsState.Reconnecting);
+			this.scheduleReconnect();
+		} else this.cleanup(WsDisconnectReason.ConnectionTimeout, false);
+	}
+	clearConnectionTimeout() {
+		if (this.connectionTimeout) {
+			clearTimeout(this.connectionTimeout);
+			this.connectionTimeout = null;
+		}
+	}
+	clearReconnectTimeout() {
+		if (this.reconnectTimeout) {
+			clearTimeout(this.reconnectTimeout);
+			this.reconnectTimeout = null;
+		}
+	}
+	scheduleReconnect() {
+		this.clearReconnectTimeout();
+		this.reconnectTimeout = setTimeout(async () => {
+			if (this.isDestroyed || this.state === WsState.Disconnected) return;
+			this.reconnectAttempts++;
+			try {
+				await this.createConnection();
+			} catch (_unused) {}
+			this.currentReconnectDelay = Math.min(this.currentReconnectDelay * this.config.reconnect.backoffMultiplier, this.config.reconnect.maxDelayMs);
+		}, this.currentReconnectDelay);
+	}
+	shouldAttemptReconnect(reason) {
+		if (reason === WsDisconnectReason.UserStopped) return false;
+		if (!this.config.reconnect.enabled) return false;
+		if (this.config.reconnect.maxAttempts > 0 && this.reconnectAttempts >= this.config.reconnect.maxAttempts) return false;
+		return true;
+	}
+	determineDisconnectReason(event) {
+		if (event.code === 1e3) return WsDisconnectReason.ServerClosed;
+		if (event.code === 1001) return WsDisconnectReason.ServerClosed;
+		if (event.code === 1006) return WsDisconnectReason.ConnectionFailed;
+		return WsDisconnectReason.Error;
+	}
+	cleanup(reason, willRetry) {
+		this.clearConnectionTimeout();
+		this.clearReconnectTimeout();
+		if (this.ws) {
+			this.ws.onopen = null;
+			this.ws.onclose = null;
+			this.ws.onerror = null;
+			this.ws.onmessage = null;
+			if (this.ws.readyState === 0 || this.ws.readyState === 1) this.ws.close();
+			this.ws = null;
+		}
+		this.setState(WsState.Disconnected);
+		this.emit("disconnect", {
+			reason,
+			willRetry
+		});
+	}
+	setState(newState) {
+		if (this.state === newState) return;
+		const from = this.state;
+		this.state = newState;
+		this.emit("state_change", {
+			from,
+			to: newState
+		});
+	}
+	resolveConfig(config) {
+		var _config$protocol, _config$connectionTim;
+		const reconnect = {
+			...DEFAULT_RECONNECT_CONFIG,
+			...config.reconnect
+		};
+		return {
+			url: config.url,
+			protocol: (_config$protocol = config.protocol) !== null && _config$protocol !== void 0 ? _config$protocol : DEFAULT_TRANSPORT_CONFIG.protocol,
+			connectionTimeoutMs: (_config$connectionTim = config.connectionTimeoutMs) !== null && _config$connectionTim !== void 0 ? _config$connectionTim : DEFAULT_TRANSPORT_CONFIG.connectionTimeoutMs,
+			reconnect,
+			metadata: config.metadata
+		};
+	}
+};
+
+//#endregion
+//#region src/client/indexer/transformers/IndexerGrpcRfqTransformer.ts
+/**
+* @category Indexer Grpc Transformer
+*/
+var IndexerGrpcRfqTransformer = class IndexerGrpcRfqTransformer {
+	static grpcRfqRequestToRfqRequest(grpcRequest) {
+		return {
+			margin: grpcRequest.margin,
+			status: grpcRequest.status,
+			marketId: grpcRequest.marketId,
+			quantity: grpcRequest.quantity,
+			direction: grpcRequest.direction,
+			worstPrice: grpcRequest.worstPrice,
+			expiry: Number(grpcRequest.expiry),
+			height: Number(grpcRequest.height),
+			rfqId: grpcRequest.rfqId.toString(),
+			createdAt: Number(grpcRequest.createdAt),
+			updatedAt: Number(grpcRequest.updatedAt),
+			requestAddress: grpcRequest.requestAddress,
+			transactionTime: Number(grpcRequest.transactionTime)
+		};
+	}
+	static grpcRfqQuoteToRfqQuote(grpcQuote) {
+		return {
+			price: grpcQuote.price,
+			maker: grpcQuote.maker,
+			taker: grpcQuote.taker,
+			margin: grpcQuote.margin,
+			status: grpcQuote.status,
+			chainId: grpcQuote.chainId,
+			marketId: grpcQuote.marketId,
+			quantity: grpcQuote.quantity,
+			signature: grpcQuote.signature,
+			expiry: Number(grpcQuote.expiry),
+			height: Number(grpcQuote.height),
+			rfqId: grpcQuote.rfqId.toString(),
+			createdAt: Number(grpcQuote.createdAt),
+			updatedAt: Number(grpcQuote.updatedAt),
+			eventTime: Number(grpcQuote.eventTime),
+			takerDirection: grpcQuote.takerDirection,
+			contractAddress: grpcQuote.contractAddress,
+			transactionTime: Number(grpcQuote.transactionTime)
+		};
+	}
+	static grpcRfqSettlementToRfqSettlement(grpcSettlement) {
+		return {
+			taker: grpcSettlement.taker,
+			margin: grpcSettlement.margin,
+			marketId: grpcSettlement.marketId,
+			quantity: grpcSettlement.quantity,
+			direction: grpcSettlement.direction,
+			worstPrice: grpcSettlement.worstPrice,
+			height: Number(grpcSettlement.height),
+			rfqId: grpcSettlement.rfqId.toString(),
+			createdAt: Number(grpcSettlement.createdAt),
+			updatedAt: Number(grpcSettlement.updatedAt),
+			eventTime: Number(grpcSettlement.eventTime),
+			fallbackMargin: grpcSettlement.fallbackMargin,
+			fallbackQuantity: grpcSettlement.fallbackQuantity,
+			transactionTime: Number(grpcSettlement.transactionTime)
+		};
+	}
+	static openRequestsResponseToOpenRequests(response) {
+		return { requests: response.requests.map(IndexerGrpcRfqTransformer.grpcRfqRequestToRfqRequest) };
+	}
+	static pendingQuotesResponseToPendingQuotes(response) {
+		return { quotes: response.quotes.map(IndexerGrpcRfqTransformer.grpcRfqQuoteToRfqQuote) };
+	}
+	static listSettlementsResponseToSettlements(response) {
+		return {
+			settlements: response.settlements.map(IndexerGrpcRfqTransformer.grpcRfqSettlementToRfqSettlement),
+			total: Number(response.total)
+		};
+	}
+};
+
+//#endregion
+//#region src/client/indexer/ws/rfq/IndexerWsTakerStream.ts
+var IndexerWsTakerStream = class {
+	constructor(config) {
+		var _config$pingIntervalM;
+		_defineProperty(this, "transport", void 0);
+		_defineProperty(this, "pingInterval", null);
+		_defineProperty(this, "listeners", /* @__PURE__ */ new Map());
+		_defineProperty(this, "isDestroyed", false);
+		_defineProperty(this, "pingIntervalMs", void 0);
+		const fullUrl = this.buildUrl(config.url, RFQ_GRPC_PATHS.TakerStream);
+		this.pingIntervalMs = (_config$pingIntervalM = config.pingIntervalMs) !== null && _config$pingIntervalM !== void 0 ? _config$pingIntervalM : 1e3;
+		this.transport = new GrpcWebSocketTransport({
+			url: fullUrl,
+			connectionTimeoutMs: config.connectionTimeoutMs,
+			reconnect: config.reconnect,
+			metadata: { request_address: config.requestAddress }
+		});
+		this.setupTransportHandlers();
+	}
+	getState() {
+		return this.transport.getState();
+	}
+	isConnected() {
+		return this.transport.isConnected();
+	}
+	async connect() {
+		if (this.isDestroyed) throw new Error("Stream has been destroyed");
+		await this.transport.connect();
+	}
+	disconnect() {
+		this.stopPingInterval();
+		this.transport.disconnect();
+	}
+	destroy() {
+		this.isDestroyed = true;
+		this.stopPingInterval();
+		this.transport.destroy();
+		this.listeners.clear();
+	}
+	sendRequest(request) {
+		if (!this.isConnected()) throw new Error("Cannot send request: stream is not connected");
+		const encoded = GrpcWebSocketCodec.encodeTakerRequest(request);
+		this.transport.send(encoded);
+	}
+	on(event, listener) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(listener);
+	}
+	off(event, listener) {
+		var _this$listeners$get;
+		(_this$listeners$get = this.listeners.get(event)) === null || _this$listeners$get === void 0 || _this$listeners$get.delete(listener);
+	}
+	emit(event, data) {
+		var _this$listeners$get2;
+		(_this$listeners$get2 = this.listeners.get(event)) === null || _this$listeners$get2 === void 0 || _this$listeners$get2.forEach((listener) => {
+			try {
+				listener(data);
+			} catch (error) {
+				console.error(`Error in ${event} listener:`, error);
+			}
+		});
+	}
+	setupTransportHandlers() {
+		this.transport.on("connect", ({ isReconnect }) => {
+			this.startPingInterval();
+			this.emit("connect", { isReconnect });
+		});
+		this.transport.on("disconnect", ({ reason, willRetry }) => {
+			this.stopPingInterval();
+			this.emit("disconnect", {
+				reason,
+				willRetry
+			});
+		});
+		this.transport.on("state_change", ({ from, to }) => {
+			this.emit("state_change", {
+				from,
+				to
+			});
+		});
+		this.transport.on("message", (data) => {
+			this.handleMessage(data);
+		});
+		this.transport.on("error", (error) => {
+			this.emit("error", {
+				code: "TRANSPORT_ERROR",
+				message: error.message
+			});
+		});
+	}
+	handleMessage(data) {
+		try {
+			const frame = GrpcWebSocketCodec.decodeTakerResponse(data);
+			if (frame.isTrailer) return;
+			const response = frame.message;
+			if (!response) return;
+			switch (response.messageType) {
+				case "pong":
+					this.emit("pong", void 0);
+					break;
+				case "quote":
+					if (response.quote) {
+						const quote = IndexerGrpcRfqTransformer.grpcRfqQuoteToRfqQuote(response.quote);
+						this.emit("quote", { quote });
+					}
+					break;
+				case "request_ack":
+					if (response.requestAck) {
+						const ack = {
+							rfqId: response.requestAck.rfqId.toString(),
+							status: response.requestAck.status
+						};
+						this.emit("request_ack", ack);
+					}
+					break;
+				case "error":
+					if (response.error) {
+						const error = {
+							code: response.error.code,
+							message: response.error.message
+						};
+						this.emit("error", error);
+					}
+					break;
+				default: console.warn(`Unknown taker stream message type: ${response.messageType}`);
+			}
+		} catch (error) {
+			if (error instanceof GrpcDecodeError) this.emit("error", {
+				code: "DECODE_ERROR",
+				message: error.message
+			});
+			else this.emit("error", {
+				code: "UNKNOWN_ERROR",
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	startPingInterval() {
+		this.stopPingInterval();
+		this.pingInterval = setInterval(() => {
+			if (this.isConnected()) try {
+				const pingMessage = GrpcWebSocketCodec.encodeTakerPing();
+				this.transport.send(pingMessage);
+			} catch (error) {
+				console.error("Failed to send ping:", error);
+			}
+		}, this.pingIntervalMs);
+	}
+	stopPingInterval() {
+		if (this.pingInterval) {
+			clearInterval(this.pingInterval);
+			this.pingInterval = null;
+		}
+	}
+	buildUrl(baseUrl, grpcPath) {
+		return `${baseUrl.replace(/\/$/, "")}${grpcPath.startsWith("/") ? grpcPath : `/${grpcPath}`}`;
+	}
+};
+
+//#endregion
+//#region src/client/indexer/ws/rfq/IndexerWsMakerStream.ts
+var IndexerWsMakerStream = class {
+	constructor(config) {
+		var _config$pingIntervalM;
+		_defineProperty(this, "transport", void 0);
+		_defineProperty(this, "pingInterval", null);
+		_defineProperty(this, "listeners", /* @__PURE__ */ new Map());
+		_defineProperty(this, "isDestroyed", false);
+		_defineProperty(this, "pingIntervalMs", void 0);
+		const fullUrl = this.buildUrl(config.url, RFQ_GRPC_PATHS.MakerStream);
+		this.pingIntervalMs = (_config$pingIntervalM = config.pingIntervalMs) !== null && _config$pingIntervalM !== void 0 ? _config$pingIntervalM : 1e3;
+		this.transport = new GrpcWebSocketTransport({
+			url: fullUrl,
+			connectionTimeoutMs: config.connectionTimeoutMs,
+			reconnect: config.reconnect,
+			metadata: { maker_address: config.makerAddress }
+		});
+		this.setupTransportHandlers();
+	}
+	getState() {
+		return this.transport.getState();
+	}
+	isConnected() {
+		return this.transport.isConnected();
+	}
+	async connect() {
+		if (this.isDestroyed) throw new Error("Stream has been destroyed");
+		await this.transport.connect();
+	}
+	disconnect() {
+		this.stopPingInterval();
+		this.transport.disconnect();
+	}
+	destroy() {
+		this.isDestroyed = true;
+		this.stopPingInterval();
+		this.transport.destroy();
+		this.listeners.clear();
+	}
+	sendQuote(quote) {
+		if (!this.isConnected()) throw new Error("Cannot send quote: stream is not connected");
+		const encoded = GrpcWebSocketCodec.encodeMakerQuote(quote);
+		this.transport.send(encoded);
+	}
+	on(event, listener) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(listener);
+	}
+	off(event, listener) {
+		var _this$listeners$get;
+		(_this$listeners$get = this.listeners.get(event)) === null || _this$listeners$get === void 0 || _this$listeners$get.delete(listener);
+	}
+	emit(event, data) {
+		var _this$listeners$get2;
+		(_this$listeners$get2 = this.listeners.get(event)) === null || _this$listeners$get2 === void 0 || _this$listeners$get2.forEach((listener) => {
+			try {
+				listener(data);
+			} catch (error) {
+				console.error(`Error in ${event} listener:`, error);
+			}
+		});
+	}
+	setupTransportHandlers() {
+		this.transport.on("connect", ({ isReconnect }) => {
+			this.startPingInterval();
+			this.emit("connect", { isReconnect });
+		});
+		this.transport.on("disconnect", ({ reason, willRetry }) => {
+			this.stopPingInterval();
+			this.emit("disconnect", {
+				reason,
+				willRetry
+			});
+		});
+		this.transport.on("state_change", ({ from, to }) => {
+			this.emit("state_change", {
+				from,
+				to
+			});
+		});
+		this.transport.on("message", (data) => {
+			this.handleMessage(data);
+		});
+		this.transport.on("error", (error) => {
+			this.emit("error", {
+				code: "TRANSPORT_ERROR",
+				message: error.message
+			});
+		});
+	}
+	handleMessage(data) {
+		try {
+			const frame = GrpcWebSocketCodec.decodeMakerResponse(data);
+			if (frame.isTrailer) return;
+			const response = frame.message;
+			if (!response) return;
+			switch (response.messageType) {
+				case "pong":
+					this.emit("pong", void 0);
+					break;
+				case "request":
+					if (response.request) {
+						const request = IndexerGrpcRfqTransformer.grpcRfqRequestToRfqRequest(response.request);
+						this.emit("request", { request });
+					}
+					break;
+				case "quote_ack":
+					if (response.quoteAck) {
+						const ack = {
+							rfqId: response.quoteAck.rfqId.toString(),
+							status: response.quoteAck.status
+						};
+						this.emit("quote_ack", ack);
+					}
+					break;
+				case "error":
+					if (response.error) {
+						const error = {
+							code: response.error.code,
+							message: response.error.message
+						};
+						this.emit("error", error);
+					}
+					break;
+				default: console.warn(`Unknown maker stream message type: ${response.messageType}`);
+			}
+		} catch (error) {
+			if (error instanceof GrpcDecodeError) this.emit("error", {
+				code: "DECODE_ERROR",
+				message: error.message
+			});
+			else this.emit("error", {
+				code: "UNKNOWN_ERROR",
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	startPingInterval() {
+		this.stopPingInterval();
+		this.pingInterval = setInterval(() => {
+			if (this.isConnected()) try {
+				const pingMessage = GrpcWebSocketCodec.encodeMakerPing();
+				this.transport.send(pingMessage);
+			} catch (error) {
+				console.error("Failed to send ping:", error);
+			}
+		}, this.pingIntervalMs);
+	}
+	stopPingInterval() {
+		if (this.pingInterval) {
+			clearInterval(this.pingInterval);
+			this.pingInterval = null;
+		}
+	}
+	buildUrl(baseUrl, grpcPath) {
+		return `${baseUrl.replace(/\/$/, "")}${grpcPath.startsWith("/") ? grpcPath : `/${grpcPath}`}`;
+	}
+};
+
+//#endregion
 //#region src/client/indexer/transformers/IndexerCommonTransformer.ts
 var IndexerCommonTransformer = class {
 	static grpcCoinToCoin(coin) {
@@ -836,6 +1672,25 @@ var IndexerCampaignTransformer = class IndexerCampaignTransformer {
 	}
 };
 
+//#endregion
+//#region src/client/indexer/transformers/IndexerRfqStreamTransformer.ts
+/**
+* @category Indexer Stream Transformer
+*/
+var IndexerRfqStreamTransformer = class {};
+_defineProperty(IndexerRfqStreamTransformer, "requestStreamCallback", (response) => {
+	const request = response.request;
+	return { request: request ? IndexerGrpcRfqTransformer.grpcRfqRequestToRfqRequest(request) : void 0 };
+});
+_defineProperty(IndexerRfqStreamTransformer, "quoteStreamCallback", (response) => {
+	const quote = response.quote;
+	return { quote: quote ? IndexerGrpcRfqTransformer.grpcRfqQuoteToRfqQuote(quote) : void 0 };
+});
+_defineProperty(IndexerRfqStreamTransformer, "settlementStreamCallback", (response) => {
+	const settlement = response.settlement;
+	return { settlement: settlement ? IndexerGrpcRfqTransformer.grpcRfqSettlementToRfqSettlement(settlement) : void 0 };
+});
+
 //#endregion
 //#region src/client/indexer/transformers/IndexerGrpcOracleTransformer.ts
 var IndexerGrpcOracleTransformer = class IndexerGrpcOracleTransformer {
@@ -2825,6 +3680,73 @@ _defineProperty(IndexerAccountPortfolioStreamTransformer, "accountPortfolioStrea
 	};
 });
 
+//#endregion
+//#region src/client/indexer/grpc/IndexerGrpcRfqApi.ts
+/**
+* @category Indexer Grpc API
+*/
+var IndexerGrpcRFQApi = class extends BaseIndexerGrpcConsumer {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "module", IndexerModule.RFQ);
+	}
+	get client() {
+		return this.initClient(InjectiveRFQRPCClient);
+	}
+	async submitRequest({ rfqId, margin, expiry, status, height, marketId, quantity, direction, createdAt, updatedAt, worstPrice, requestAddress, transactionTime }) {
+		const request = InjectiveRFQExchangeRpcPb.RFQRequestType.create();
+		if (rfqId !== void 0) request.rfqId = rfqId;
+		if (marketId) request.marketId = marketId;
+		if (direction) request.direction = direction;
+		if (margin) request.margin = margin;
+		if (quantity) request.quantity = quantity;
+		if (worstPrice) request.worstPrice = worstPrice;
+		if (requestAddress) request.requestAddress = requestAddress;
+		if (expiry) request.expiry = expiry;
+		if (status) request.status = status;
+		if (createdAt) request.createdAt = createdAt;
+		if (updatedAt) request.updatedAt = updatedAt;
+		if (transactionTime) request.transactionTime = transactionTime;
+		if (height) request.height = height;
+		const requestMessage = InjectiveRFQExchangeRpcPb.RequestRequest.create();
+		requestMessage.request = request;
+		return { status: (await this.executeGrpcCall(requestMessage, this.client.request.bind(this.client))).status };
+	}
+	async submitQuote({ rfqId, price, maker, taker, margin, expiry, status, height, chainId, marketId, quantity, signature, createdAt, updatedAt, eventTime, takerDirection, contractAddress, transactionTime }) {
+		const request = InjectiveRFQExchangeRpcPb.RFQQuoteType.create();
+		if (chainId) request.chainId = chainId;
+		if (contractAddress) request.contractAddress = contractAddress;
+		if (marketId) request.marketId = marketId;
+		if (rfqId !== void 0) request.rfqId = rfqId;
+		if (takerDirection) request.takerDirection = takerDirection;
+		if (margin) request.margin = margin;
+		if (quantity) request.quantity = quantity;
+		if (price) request.price = price;
+		if (expiry) request.expiry = expiry;
+		if (maker) request.maker = maker;
+		if (taker) request.taker = taker;
+		if (signature) request.signature = signature;
+		if (status) request.status = status;
+		if (createdAt) request.createdAt = createdAt;
+		if (updatedAt) request.updatedAt = updatedAt;
+		if (height) request.height = height;
+		if (eventTime) request.eventTime = eventTime;
+		if (transactionTime) request.transactionTime = transactionTime;
+		const quoteMessage = InjectiveRFQExchangeRpcPb.QuoteRequest.create();
+		quoteMessage.quote = request;
+		return { status: (await this.executeGrpcCall(quoteMessage, this.client.quote.bind(this.client))).status };
+	}
+	async fetchSettlements(params) {
+		const { addresses, pagination } = params || {};
+		const request = InjectiveRFQExchangeRpcPb.ListSettlementRequest.create();
+		if (addresses && addresses.length > 0) request.addresses = addresses;
+		if (pagination === null || pagination === void 0 ? void 0 : pagination.skip) request.skip = BigInt(pagination.skip);
+		if (pagination === null || pagination === void 0 ? void 0 : pagination.limit) request.limit = BigInt(pagination.limit);
+		const response = await this.executeGrpcCall(request, this.client.listSettlement.bind(this.client));
+		return IndexerGrpcRfqTransformer.listSettlementsResponseToSettlements(response);
+	}
+};
+
 //#endregion
 //#region src/client/indexer/grpc/IndexerGrpcMitoApi.ts
 /**
@@ -5519,6 +6441,41 @@ function createStreamSubscriptionV2(stream, handleResponse) {
 	return subscription;
 }
 
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcRfqStreamV2.ts
+var IndexerGrpcRfqStreamV2 = class {
+	constructor(endpoint, metadata) {
+		_defineProperty(this, "client", void 0);
+		_defineProperty(this, "transport", void 0);
+		this.transport = new GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new InjectiveRFQRPCClient(this.transport);
+	}
+	streamRequests({ marketIds, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveRFQExchangeRpcPb.StreamRequestRequest.create();
+		if (marketIds && marketIds.length > 0) request.marketIds = marketIds;
+		return createStreamSubscriptionV2(this.client.streamRequest(request), (response) => {
+			callback(IndexerRfqStreamTransformer.requestStreamCallback(response));
+		});
+	}
+	streamQuotes({ addresses, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveRFQExchangeRpcPb.StreamQuoteRequest.create();
+		if (addresses && addresses.length > 0) request.addresses = addresses;
+		return createStreamSubscriptionV2(this.client.streamQuote(request), (response) => {
+			callback(IndexerRfqStreamTransformer.quoteStreamCallback(response));
+		});
+	}
+	streamSettlements({ addresses, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = InjectiveRFQExchangeRpcPb.StreamSettlementRequest.create();
+		if (addresses && addresses.length > 0) request.addresses = addresses;
+		return createStreamSubscriptionV2(this.client.streamSettlement(request), (response) => {
+			callback(IndexerRfqStreamTransformer.settlementStreamCallback(response));
+		});
+	}
+};
+
 //#endregion
 //#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcSpotStreamV2.ts
 var IndexerGrpcSpotStreamV2 = class {
@@ -6327,4 +7284,4 @@ var StreamManagerV2 = class extends EventEmitter {
 };
 
 //#endregion
-export { IndexerGrpcMegaVaultTransformer as $, IndexerGrpcInsuranceFundApi as A, IndexerGrpcAccountApi as B, IndexerGrpcSpotStream as C, IndexerRestMarketChronosApi as D, IndexerRestDerivativesChronosApi as E, IndexerGrpcArchiverApi as F, IndexerAccountPortfolioStreamTransformer as G, IndexerGrpcSpotApi as H, IndexerGrpcCampaignApi as I, IndexerGrpcAccountPortfolioTransformer as J, IndexerGrpcInsuranceFundTransformer as K, IndexerGrpcExplorerApi as L, IndexerGrpcDerivativesApi as M, IndexerGrpcMegaVaultApi as N, IndexerRestSpotChronosApi as O, IndexerGrpcReferralApi as P, IndexerArchiverStreamTransformer as Q, IndexerGrpcTradingApi as R, IndexerGrpcMitoStream as S, IndexerRestLeaderboardChronosApi as T, IndexerGrpcMetaApi as U, IndexerGrpcOracleApi as V, IndexerGrpcMitoApi as W, IndexerGrpcDerivativeTransformer as X, IndexerGrpcMitoStreamTransformer as Y, ExplorerStreamTransformer as Z, IndexerGrpcArchiverStream as _, IndexerGrpcArchiverStreamV2 as a, IndexerGrpcExplorerTransformer as at, IndexerGrpcAccountStream as b, IndexerGrpcAccountStreamV2 as c, IndexerGrpcAccountTransformer as ct, IndexerGrpcSpotStreamV2 as d, IndexerCampaignTransformer as dt, IndexerAuctionStreamTransformer as et, createStreamSubscriptionV2 as f, IndexerGrpcSpotTransformer as ft, IndexerGrpcExplorerStream as g, IndexerGrpcDerivativesStream as h, IndexerGrpcExplorerStreamV2 as i, IndexerGrpcReferralTransformer as it, IndexerGrpcAccountPortfolioApi as j, IndexerRestExplorerApi as k, IndexerGrpcOracleStreamV2 as l, IndexerSpotStreamTransformer as lt, IndexerGrpcAccountPortfolioStream as m, IndexerGrpcAccountPortfolioStreamV2 as n, IndexerRestExplorerTransformer as nt, IndexerGrpcTradingStreamV2 as o, IndexerGrpcArchiverTransformer as ot, StreamManager as p, IndexerGrpcMitoTransformer as pt, IndexerDerivativeStreamTransformer as q, IndexerGrpcDerivativesStreamV2 as r, IndexerOracleStreamTransformer as rt, IndexerGrpcAuctionStreamV2 as s, IndexerGrpcAuctionTransformer as st, StreamManagerV2 as t, IndexerAccountStreamTransformer as tt, IndexerGrpcMitoStreamV2 as u, IndexerGrpcOracleTransformer as ut, IndexerGrpcTradingStream as v, createStreamSubscription as w, IndexerGrpcOracleStream as x, IndexerGrpcAuctionStream as y, IndexerGrpcAuctionApi as z };
+export { ExplorerStreamTransformer as $, IndexerRestExplorerApi as A, IndexerGrpcAuctionApi as B, IndexerGrpcMitoStream as C, DEFAULT_TRANSPORT_CONFIG as Ct, IndexerRestDerivativesChronosApi as D, IndexerRestLeaderboardChronosApi as E, IndexerGrpcReferralApi as F, IndexerGrpcMitoApi as G, IndexerGrpcOracleApi as H, IndexerGrpcArchiverApi as I, IndexerGrpcInsuranceFundTransformer as J, IndexerGrpcRFQApi as K, IndexerGrpcCampaignApi as L, IndexerGrpcAccountPortfolioApi as M, IndexerGrpcDerivativesApi as N, IndexerRestMarketChronosApi as O, IndexerGrpcMegaVaultApi as P, IndexerGrpcDerivativeTransformer as Q, IndexerGrpcExplorerApi as R, IndexerGrpcOracleStream as S, DEFAULT_RECONNECT_CONFIG as St, createStreamSubscription as T, WsState as Tt, IndexerGrpcSpotApi as U, IndexerGrpcAccountApi as V, IndexerGrpcMetaApi as W, IndexerGrpcAccountPortfolioTransformer as X, IndexerDerivativeStreamTransformer as Y, IndexerGrpcMitoStreamTransformer as Z, IndexerGrpcExplorerStream as _, IndexerWsMakerStream as _t, IndexerGrpcArchiverStreamV2 as a, IndexerOracleStreamTransformer as at, IndexerGrpcAuctionStream as b, GrpcWebSocketTransport as bt, IndexerGrpcAccountStreamV2 as c, IndexerGrpcArchiverTransformer as ct, IndexerGrpcSpotStreamV2 as d, IndexerSpotStreamTransformer as dt, IndexerArchiverStreamTransformer as et, IndexerGrpcRfqStreamV2 as f, IndexerGrpcOracleTransformer as ft, IndexerGrpcDerivativesStream as g, IndexerGrpcMitoTransformer as gt, IndexerGrpcAccountPortfolioStream as h, IndexerGrpcSpotTransformer as ht, IndexerGrpcExplorerStreamV2 as i, IndexerRestExplorerTransformer as it, IndexerGrpcInsuranceFundApi as j, IndexerRestSpotChronosApi as k, IndexerGrpcOracleStreamV2 as l, IndexerGrpcAuctionTransformer as lt, StreamManager as m, IndexerCampaignTransformer as mt, IndexerGrpcAccountPortfolioStreamV2 as n, IndexerAuctionStreamTransformer as nt, IndexerGrpcTradingStreamV2 as o, IndexerGrpcReferralTransformer as ot, createStreamSubscriptionV2 as p, IndexerRfqStreamTransformer as pt, IndexerAccountPortfolioStreamTransformer as q, IndexerGrpcDerivativesStreamV2 as r, IndexerAccountStreamTransformer as rt, IndexerGrpcAuctionStreamV2 as s, IndexerGrpcExplorerTransformer as st, StreamManagerV2 as t, IndexerGrpcMegaVaultTransformer as tt, IndexerGrpcMitoStreamV2 as u, IndexerGrpcAccountTransformer as ut, IndexerGrpcArchiverStream as v, IndexerWsTakerStream as vt, IndexerGrpcSpotStream as w, WsDisconnectReason as wt, IndexerGrpcAccountStream as x, GrpcWebSocketCodec as xt, IndexerGrpcTradingStream as y, IndexerGrpcRfqTransformer as yt, IndexerGrpcTradingApi as z };