@injectivelabs/sdk-ts 1.17.6 → 1.17.8

package/dist/cjs/{StreamManagerV2-Dvfpwi5Z.cjs → StreamManagerV2-ocvGmGvp.cjs}

@@ -1,13 +1,17 @@
 const require_chunk = require('./chunk-CbDLau6x.cjs');
 const require_utils = require('./utils-D3XFGv8y.cjs');
-const require_defineProperty = require('./defineProperty-dyr5BsvG.cjs');
-const require_BaseGrpcConsumer = require('./BaseGrpcConsumer-Db3sCC6b.cjs');
-const require_BaseIndexerGrpcConsumer = require('./BaseIndexerGrpcConsumer-BBXxg_BR.cjs');
+const require_defineProperty = require('./defineProperty-DAtJs5JQ.cjs');
+const require_BaseGrpcConsumer = require('./BaseGrpcConsumer-B1hpRQJ-.cjs');
+const require_BaseIndexerGrpcConsumer = require('./BaseIndexerGrpcConsumer-rRYRp48i.cjs');
 const require_BaseRestConsumer = require('./BaseRestConsumer-CRkyjiSo.cjs');
-const require_IndexerGrpcWeb3GwApi = require('./IndexerGrpcWeb3GwApi-BxJoq1-k.cjs');
+const require_IndexerGrpcWeb3GwApi = require('./IndexerGrpcWeb3GwApi-wpbu-sy0.cjs');
 const require_types = require('./types-BSrt7JzM.cjs');
 let __injectivelabs_utils = require("@injectivelabs/utils");
 let __injectivelabs_exceptions = require("@injectivelabs/exceptions");
+let __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js = require("@injectivelabs/indexer-proto-ts-v2/generated/injective_rfqrpc_pb.js");
+let __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb = require("@injectivelabs/indexer-proto-ts-v2/generated/injective_rfqrpc_pb");
+__injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb = require_chunk.__toESM(__injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb);
+let __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_client = require("@injectivelabs/indexer-proto-ts-v2/generated/injective_rfqrpc_pb.client");
 let __injectivelabs_mito_proto_ts_v2_generated_goadesign_goagen_mito_api_pb_client = require("@injectivelabs/mito-proto-ts-v2/generated/goadesign_goagen_mito_api_pb.client");
 let __injectivelabs_mito_proto_ts_v2_generated_goadesign_goagen_mito_api_pb = require("@injectivelabs/mito-proto-ts-v2/generated/goadesign_goagen_mito_api_pb");
 __injectivelabs_mito_proto_ts_v2_generated_goadesign_goagen_mito_api_pb = require_chunk.__toESM(__injectivelabs_mito_proto_ts_v2_generated_goadesign_goagen_mito_api_pb);
@@ -55,6 +59,839 @@ __injectivelabs_indexer_proto_ts_v2_generated_injective_insurance_rpc_pb = requi
 let __injectivelabs_indexer_proto_ts_v2_generated_injective_insurance_rpc_pb_client = require("@injectivelabs/indexer-proto-ts-v2/generated/injective_insurance_rpc_pb.client");
 let eventemitter3 = require("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 = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.TakerStreamStreamingRequest.create({ messageType: "ping" });
+		return encodeGrpcFrame(__injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.TakerStreamStreamingRequest.toBinary(message));
+	},
+	encodeTakerRequest(input) {
+		const request = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.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 = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.TakerStreamStreamingRequest.create({
+			messageType: "request",
+			request
+		});
+		return encodeGrpcFrame(__injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.TakerStreamStreamingRequest.toBinary(message));
+	},
+	decodeTakerResponse(data) {
+		return decodeGrpcFrame(data instanceof ArrayBuffer ? new Uint8Array(data) : data, __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.TakerStreamResponse);
+	},
+	encodeMakerPing() {
+		const message = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.MakerStreamStreamingRequest.create({ messageType: "ping" });
+		return encodeGrpcFrame(__injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.MakerStreamStreamingRequest.toBinary(message));
+	},
+	encodeMakerQuote(input) {
+		const quote = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.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 = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.MakerStreamStreamingRequest.create({
+			messageType: "quote",
+			quote
+		});
+		return encodeGrpcFrame(__injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.MakerStreamStreamingRequest.toBinary(message));
+	},
+	decodeMakerResponse(data) {
+		return decodeGrpcFrame(data instanceof ArrayBuffer ? new Uint8Array(data) : data, __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_js.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) {
+		require_defineProperty._defineProperty(this, "config", void 0);
+		require_defineProperty._defineProperty(this, "ws", null);
+		require_defineProperty._defineProperty(this, "state", WsState.Idle);
+		require_defineProperty._defineProperty(this, "connectionTimeout", null);
+		require_defineProperty._defineProperty(this, "reconnectTimeout", null);
+		require_defineProperty._defineProperty(this, "reconnectAttempts", 0);
+		require_defineProperty._defineProperty(this, "currentReconnectDelay", void 0);
+		require_defineProperty._defineProperty(this, "isDestroyed", false);
+		require_defineProperty._defineProperty(this, "hasConnectedOnce", false);
+		require_defineProperty._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;
+		require_defineProperty._defineProperty(this, "transport", void 0);
+		require_defineProperty._defineProperty(this, "pingInterval", null);
+		require_defineProperty._defineProperty(this, "listeners", /* @__PURE__ */ new Map());
+		require_defineProperty._defineProperty(this, "isDestroyed", false);
+		require_defineProperty._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;
+		require_defineProperty._defineProperty(this, "transport", void 0);
+		require_defineProperty._defineProperty(this, "pingInterval", null);
+		require_defineProperty._defineProperty(this, "listeners", /* @__PURE__ */ new Map());
+		require_defineProperty._defineProperty(this, "isDestroyed", false);
+		require_defineProperty._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) {
@@ -852,6 +1689,25 @@ var IndexerCampaignTransformer = class IndexerCampaignTransformer {
 	}
 };
 
+//#endregion
+//#region src/client/indexer/transformers/IndexerRfqStreamTransformer.ts
+/**
+* @category Indexer Stream Transformer
+*/
+var IndexerRfqStreamTransformer = class {};
+require_defineProperty._defineProperty(IndexerRfqStreamTransformer, "requestStreamCallback", (response) => {
+	const request = response.request;
+	return { request: request ? IndexerGrpcRfqTransformer.grpcRfqRequestToRfqRequest(request) : void 0 };
+});
+require_defineProperty._defineProperty(IndexerRfqStreamTransformer, "quoteStreamCallback", (response) => {
+	const quote = response.quote;
+	return { quote: quote ? IndexerGrpcRfqTransformer.grpcRfqQuoteToRfqQuote(quote) : void 0 };
+});
+require_defineProperty._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 {
@@ -2841,6 +3697,73 @@ require_defineProperty._defineProperty(IndexerAccountPortfolioStreamTransformer,
 	};
 });
 
+//#endregion
+//#region src/client/indexer/grpc/IndexerGrpcRfqApi.ts
+/**
+* @category Indexer Grpc API
+*/
+var IndexerGrpcRFQApi = class extends require_BaseIndexerGrpcConsumer.BaseIndexerGrpcConsumer {
+	constructor(..._args) {
+		super(..._args);
+		require_defineProperty._defineProperty(this, "module", require_IndexerGrpcWeb3GwApi.IndexerModule.RFQ);
+	}
+	get client() {
+		return this.initClient(__injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_client.InjectiveRFQRPCClient);
+	}
+	async submitRequest({ rfqId, margin, expiry, status, height, marketId, quantity, direction, createdAt, updatedAt, worstPrice, requestAddress, transactionTime }) {
+		const request = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb.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 = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb.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 = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb.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 = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb.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 = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb.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
 /**
@@ -5535,6 +6458,41 @@ function createStreamSubscriptionV2(stream, handleResponse) {
 	return subscription;
 }
 
+//#endregion
+//#region src/client/indexer/grpc_stream/streamV2/IndexerGrpcRfqStreamV2.ts
+var IndexerGrpcRfqStreamV2 = class {
+	constructor(endpoint, metadata) {
+		require_defineProperty._defineProperty(this, "client", void 0);
+		require_defineProperty._defineProperty(this, "transport", void 0);
+		this.transport = new require_BaseGrpcConsumer.GrpcWebRpcTransport(endpoint, metadata);
+		this.client = new __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb_client.InjectiveRFQRPCClient(this.transport);
+	}
+	streamRequests({ marketIds, callback }) {
+		if (typeof callback !== "function") throw new Error("callback must be a function");
+		const request = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb.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 = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb.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 = __injectivelabs_indexer_proto_ts_v2_generated_injective_rfqrpc_pb.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 {
@@ -6343,12 +7301,36 @@ var StreamManagerV2 = class extends eventemitter3.EventEmitter {
 };
 
 //#endregion
+Object.defineProperty(exports, 'DEFAULT_RECONNECT_CONFIG', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_RECONNECT_CONFIG;
+  }
+});
+Object.defineProperty(exports, 'DEFAULT_TRANSPORT_CONFIG', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_TRANSPORT_CONFIG;
+  }
+});
 Object.defineProperty(exports, 'ExplorerStreamTransformer', {
   enumerable: true,
   get: function () {
     return ExplorerStreamTransformer;
   }
 });
+Object.defineProperty(exports, 'GrpcWebSocketCodec', {
+  enumerable: true,
+  get: function () {
+    return GrpcWebSocketCodec;
+  }
+});
+Object.defineProperty(exports, 'GrpcWebSocketTransport', {
+  enumerable: true,
+  get: function () {
+    return GrpcWebSocketTransport;
+  }
+});
 Object.defineProperty(exports, 'IndexerAccountPortfolioStreamTransformer', {
   enumerable: true,
   get: function () {
@@ -6619,6 +7601,12 @@ Object.defineProperty(exports, 'IndexerGrpcOracleTransformer', {
     return IndexerGrpcOracleTransformer;
   }
 });
+Object.defineProperty(exports, 'IndexerGrpcRFQApi', {
+  enumerable: true,
+  get: function () {
+    return IndexerGrpcRFQApi;
+  }
+});
 Object.defineProperty(exports, 'IndexerGrpcReferralApi', {
   enumerable: true,
   get: function () {
@@ -6631,6 +7619,18 @@ Object.defineProperty(exports, 'IndexerGrpcReferralTransformer', {
     return IndexerGrpcReferralTransformer;
   }
 });
+Object.defineProperty(exports, 'IndexerGrpcRfqStreamV2', {
+  enumerable: true,
+  get: function () {
+    return IndexerGrpcRfqStreamV2;
+  }
+});
+Object.defineProperty(exports, 'IndexerGrpcRfqTransformer', {
+  enumerable: true,
+  get: function () {
+    return IndexerGrpcRfqTransformer;
+  }
+});
 Object.defineProperty(exports, 'IndexerGrpcSpotApi', {
   enumerable: true,
   get: function () {
@@ -6715,12 +7715,30 @@ Object.defineProperty(exports, 'IndexerRestSpotChronosApi', {
     return IndexerRestSpotChronosApi;
   }
 });
+Object.defineProperty(exports, 'IndexerRfqStreamTransformer', {
+  enumerable: true,
+  get: function () {
+    return IndexerRfqStreamTransformer;
+  }
+});
 Object.defineProperty(exports, 'IndexerSpotStreamTransformer', {
   enumerable: true,
   get: function () {
     return IndexerSpotStreamTransformer;
   }
 });
+Object.defineProperty(exports, 'IndexerWsMakerStream', {
+  enumerable: true,
+  get: function () {
+    return IndexerWsMakerStream;
+  }
+});
+Object.defineProperty(exports, 'IndexerWsTakerStream', {
+  enumerable: true,
+  get: function () {
+    return IndexerWsTakerStream;
+  }
+});
 Object.defineProperty(exports, 'StreamManager', {
   enumerable: true,
   get: function () {
@@ -6733,6 +7751,18 @@ Object.defineProperty(exports, 'StreamManagerV2', {
     return StreamManagerV2;
   }
 });
+Object.defineProperty(exports, 'WsDisconnectReason', {
+  enumerable: true,
+  get: function () {
+    return WsDisconnectReason;
+  }
+});
+Object.defineProperty(exports, 'WsState', {
+  enumerable: true,
+  get: function () {
+    return WsState;
+  }
+});
 Object.defineProperty(exports, 'createStreamSubscription', {
   enumerable: true,
   get: function () {