@milaboratories/pl-client 2.17.6 → 2.17.8

package/dist/core/ll_client.js

@@ -1,523 +1,419 @@
-import { PlatformClient } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.client.js';
-import { compressionAlgorithms, ChannelCredentials, InterceptingCall, status } from '@grpc/grpc-js';
-import { plAddressToConfig, SUPPORTED_WIRE_PROTOCOLS } from './config.js';
-import { GrpcTransport } from '@protobuf-ts/grpc-transport';
-import { LLPlTransaction } from './ll_transaction.js';
-import { parsePlJwt } from '../util/pl.js';
-import { interceptors } from 'undici';
-import { inferAuthRefreshTime } from './auth.js';
-import { defaultHttpDispatcher } from '@milaboratories/pl-http';
-import { parseHttpAuth } from '@milaboratories/pl-model-common';
-import { createClient, parseResponseError } from '../proto-rest/index.js';
-import { notEmpty, retry, withTimeout } from '@milaboratories/ts-helpers';
-import { Code } from '../proto-grpc/google/rpc/code.js';
-import { WebSocketBiDiStream } from './websocket_stream.js';
-import { TxAPI_ClientMessage, TxAPI_ServerMessage } from '../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.js';
-import { isAbortedError } from './errors.js';
+import { TxAPI_ClientMessage, TxAPI_ServerMessage } from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.js";
+import { Code } from "../proto-grpc/google/rpc/code.js";
+import { isAbortedError } from "./errors.js";
+import { SUPPORTED_WIRE_PROTOCOLS, plAddressToConfig } from "./config.js";
+import { PlatformClient } from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api.client.js";
+import { LLPlTransaction } from "./ll_transaction.js";
+import { parsePlJwt } from "../util/pl.js";
+import { inferAuthRefreshTime } from "./auth.js";
+import { createClient, parseResponseError } from "../proto-rest/index.js";
+import { WebSocketBiDiStream } from "./websocket_stream.js";
+import { notEmpty, retry, withTimeout } from "@milaboratories/ts-helpers";
+import { ChannelCredentials, InterceptingCall, compressionAlgorithms, status } from "@grpc/grpc-js";
+import { GrpcTransport } from "@protobuf-ts/grpc-transport";
+import { interceptors } from "undici";
+import { defaultHttpDispatcher } from "@milaboratories/pl-http";
+import { parseHttpAuth } from "@milaboratories/pl-model-common";
 
-class WireClientProviderImpl {
-    wireOpts;
-    clientConstructor;
-    client = undefined;
-    constructor(wireOpts, clientConstructor) {
-        this.wireOpts = wireOpts;
-        this.clientConstructor = clientConstructor;
-    }
-    reset() {
-        this.client = undefined;
-    }
-    get() {
-        if (this.client === undefined)
-            this.client = this.clientConstructor(this.wireOpts());
-        return this.client;
-    }
-}
+//#region src/core/ll_client.ts
+var WireClientProviderImpl = class {
+	client = void 0;
+	constructor(wireOpts, clientConstructor) {
+		this.wireOpts = wireOpts;
+		this.clientConstructor = clientConstructor;
+	}
+	reset() {
+		this.client = void 0;
+	}
+	get() {
+		if (this.client === void 0) this.client = this.clientConstructor(this.wireOpts());
+		return this.client;
+	}
+};
 /** Abstract out low level networking and authorization details */
-class LLPlClient {
-    conf;
-    ops;
-    /** Initial authorization information */
-    authInformation;
-    /** Will be executed by the client when it is required */
-    onAuthUpdate;
-    /** Will be executed if auth-related error happens during normal client operation */
-    onAuthError;
-    /** Will be executed by the client when it is required */
-    onAuthRefreshProblem;
-    /** Threshold after which auth info refresh is required */
-    refreshTimestamp;
-    _status = "OK";
-    statusListener;
-    _wireProto = "grpc";
-    _wireConn;
-    _restInterceptors;
-    _restMiddlewares;
-    _grpcInterceptors;
-    providers = [];
-    clientProvider;
-    httpDispatcher;
-    static async build(configOrAddress, ops = {}) {
-        const conf = typeof configOrAddress === "string" ? plAddressToConfig(configOrAddress) : configOrAddress;
-        const pl = new LLPlClient(conf, ops);
-        // FIXME(rfiskov)[MILAB-5275]: Investigate why autodetect randomly fails; temporary turn it off.
-        if (ops.useAutoDetectWireProtocol) {
-            await pl.detectOptimalWireProtocol();
-        }
-        return pl;
-    }
-    constructor(conf, ops = {}) {
-        this.conf = conf;
-        this.ops = ops;
-        const { auth, statusListener } = ops;
-        if (auth !== undefined) {
-            this.refreshTimestamp = inferAuthRefreshTime(auth.authInformation, this.conf.authMaxRefreshSeconds);
-            this.authInformation = auth.authInformation;
-            this.onAuthUpdate = auth.onUpdate;
-            this.onAuthRefreshProblem = auth.onUpdateError;
-            this.onAuthError = auth.onAuthError;
-        }
-        this._restInterceptors = [];
-        this._restMiddlewares = [];
-        this._grpcInterceptors = [];
-        if (auth !== undefined) {
-            this._restInterceptors.push(this.createRestAuthInterceptor());
-            this._grpcInterceptors.push(this.createGrpcAuthInterceptor());
-        }
-        this._restInterceptors.push(interceptors.retry({ statusCodes: [] })); // Handle errors with openapi-fetch middleware.
-        this._restMiddlewares.push(this.createRestErrorMiddleware());
-        this._grpcInterceptors.push(this.createGrpcErrorInterceptor());
-        this.httpDispatcher = defaultHttpDispatcher(this.conf.httpProxy);
-        if (this.conf.wireProtocol) {
-            this._wireProto = this.conf.wireProtocol;
-        }
-        this.initWireConnection(this._wireProto);
-        if (statusListener !== undefined) {
-            this.statusListener = statusListener;
-            statusListener(this._status);
-        }
-        this.clientProvider = this.createWireClientProvider((wireConn) => {
-            if (wireConn.type === "grpc") {
-                return new PlatformClient(wireConn.Transport);
-            }
-            else {
-                return createClient({
-                    hostAndPort: wireConn.Config.hostAndPort,
-                    ssl: wireConn.Config.ssl,
-                    dispatcher: wireConn.Dispatcher,
-                    middlewares: wireConn.Middlewares,
-                });
-            }
-        });
-    }
-    initWireConnection(protocol) {
-        switch (protocol) {
-            case "rest":
-                this.initRestConnection();
-                return;
-            case "grpc":
-                this.initGrpcConnection(this.ops.shouldUseGzip ?? false);
-                return;
-            default:
-                ((v) => {
-                    throw new Error(`Unsupported wire protocol '${v}'. Use one of: ${SUPPORTED_WIRE_PROTOCOLS.join(", ")}`);
-                })(protocol);
-        }
-    }
-    initRestConnection() {
-        const dispatcher = defaultHttpDispatcher(this.conf.grpcProxy, this._restInterceptors);
-        this._replaceWireConnection({
-            type: "rest",
-            Config: this.conf,
-            Dispatcher: dispatcher,
-            Middlewares: this._restMiddlewares,
-        });
-    }
-    /**
-     * Initializes (or reinitializes) _grpcTransport
-     * @param gzip - whether to enable gzip compression
-     */
-    initGrpcConnection(gzip) {
-        const clientOptions = {
-            "grpc.keepalive_time_ms": 30_000, // 30 seconds
-            "grpc.service_config_disable_resolution": 1, // Disable DNS TXT lookups for service config
-            interceptors: this._grpcInterceptors,
-        };
-        if (gzip)
-            clientOptions["grpc.default_compression_algorithm"] = compressionAlgorithms.gzip;
-        //
-        // Leaving it here for now
-        // https://github.com/grpc/grpc-node/issues/2788
-        //
-        // We should implement message pooling algorithm to overcome hardcoded NO_DELAY behaviour
-        // of HTTP/2 and allow our small messages to batch together.
-        //
-        const grpcOptions = {
-            host: this.conf.hostAndPort,
-            timeout: this.conf.defaultRequestTimeout,
-            channelCredentials: this.conf.ssl
-                ? ChannelCredentials.createSsl()
-                : ChannelCredentials.createInsecure(),
-            clientOptions,
-        };
-        const grpcProxy = typeof this.conf.grpcProxy === "string" ? { url: this.conf.grpcProxy } : this.conf.grpcProxy;
-        if (grpcProxy?.url) {
-            const url = new URL(grpcProxy.url);
-            if (grpcProxy.auth) {
-                const parsed = parseHttpAuth(grpcProxy.auth);
-                if (parsed.scheme !== "Basic") {
-                    throw new Error(`Unsupported auth scheme: ${parsed.scheme}.`);
-                }
-                url.username = parsed.username;
-                url.password = parsed.password;
-            }
-            process.env.grpc_proxy = url.toString();
-        }
-        else {
-            delete process.env.grpc_proxy;
-        }
-        this._replaceWireConnection({ type: "grpc", Transport: new GrpcTransport(grpcOptions) });
-    }
-    _replaceWireConnection(newConn) {
-        const oldConn = this._wireConn;
-        this._wireConn = newConn;
-        this._wireProto = newConn.type;
-        // Reset all providers to let them reinitialize their clients
-        for (let i = 0; i < this.providers.length; i++) {
-            const provider = this.providers[i].deref();
-            if (provider === undefined) {
-                // at the same time we need to remove providers that are no longer valid
-                this.providers.splice(i, 1);
-                i--;
-            }
-            else {
-                provider.reset();
-            }
-        }
-        if (oldConn !== undefined && oldConn.type === "grpc")
-            oldConn.Transport.close();
-    }
-    providerCleanupCounter = 0;
-    /**
-     * Creates a provider for a grpc client. Returned provider will create fresh client whenever the underlying transport is reset.
-     *
-     * @param clientConstructor - a factory function that creates a grpc client
-     */
-    createWireClientProvider(clientConstructor) {
-        // We need to cleanup providers periodically to avoid memory leaks.
-        // This is a simple heuristic to avoid memory leaks.
-        // We could use a more sophisticated algorithm, but this is good enough for now.
-        this.providerCleanupCounter++;
-        if (this.providerCleanupCounter >= 16) {
-            for (let i = 0; i < this.providers.length; i++) {
-                const provider = this.providers[i].deref();
-                if (provider === undefined) {
-                    this.providers.splice(i, 1);
-                    i--;
-                }
-            }
-            this.providerCleanupCounter = 0;
-        }
-        const provider = new WireClientProviderImpl(() => this._wireConn, clientConstructor);
-        this.providers.push(new WeakRef(provider));
-        return provider;
-    }
-    get wireConnection() {
-        return this._wireConn;
-    }
-    get wireProtocol() {
-        return this._wireProto;
-    }
-    /** Returns true if client is authenticated. Even with anonymous auth information
-     * connection is considered authenticated. Unauthenticated clients are used for
-     * login and similar tasks, see {@link UnauthenticatedPlClient}. */
-    get authenticated() {
-        return this.authInformation !== undefined;
-    }
-    /** null means anonymous connection */
-    get authUser() {
-        if (!this.authenticated)
-            throw new Error("Client is not authenticated");
-        if (this.authInformation?.jwtToken)
-            return parsePlJwt(this.authInformation?.jwtToken).user.login;
-        else
-            return null;
-    }
-    updateStatus(newStatus) {
-        process.nextTick(() => {
-            if (this._status !== newStatus) {
-                this._status = newStatus;
-                if (this.statusListener !== undefined)
-                    this.statusListener(this._status);
-                if (newStatus === "Unauthenticated" && this.onAuthError !== undefined)
-                    this.onAuthError();
-            }
-        });
-    }
-    get status() {
-        return this._status;
-    }
-    authRefreshInProgress = false;
-    refreshAuthInformationIfNeeded() {
-        if (this.refreshTimestamp === undefined ||
-            Date.now() < this.refreshTimestamp ||
-            this.authRefreshInProgress ||
-            this._status === "Unauthenticated")
-            return;
-        // Running refresh in background`
-        this.authRefreshInProgress = true;
-        void (async () => {
-            try {
-                const token = await this.getJwtToken(BigInt(this.conf.authTTLSeconds));
-                this.authInformation = { jwtToken: token };
-                this.refreshTimestamp = inferAuthRefreshTime(this.authInformation, this.conf.authMaxRefreshSeconds);
-                if (this.onAuthUpdate)
-                    this.onAuthUpdate(this.authInformation);
-            }
-            catch (e) {
-                if (this.onAuthRefreshProblem)
-                    this.onAuthRefreshProblem(e);
-            }
-            finally {
-                this.authRefreshInProgress = false;
-            }
-        })();
-    }
-    /**
-     * Creates middleware that parses error responses and handles them centrally.
-     * This middleware runs before openapi-fetch parses the response, so we need to
-     * manually parse the response body for error responses.
-     */
-    createRestErrorMiddleware() {
-        return {
-            onResponse: async ({ request: _request, response, options: _options }) => {
-                const { body, ...resOptions } = response;
-                if ([502, 503, 504].includes(response.status)) {
-                    // Service unavailable, bad gateway, gateway timeout
-                    this.updateStatus("Disconnected");
-                    return new Response(body, { ...resOptions, status: response.status });
-                }
-                const respErr = await parseResponseError(response);
-                if (!respErr.error) {
-                    // No error: nice!
-                    return new Response(respErr.origBody ?? body, { ...resOptions, status: response.status });
-                }
-                if (typeof respErr.error === "string") {
-                    // Non-standard error or normal response: let later middleware to deal wit it.
-                    return new Response(respErr.error, { ...resOptions, status: response.status });
-                }
-                if (respErr.error.code === Code.UNAUTHENTICATED) {
-                    this.updateStatus("Unauthenticated");
-                }
-                // Let later middleware to deal with standard gRPC error.
-                return new Response(respErr.origBody, { ...resOptions, status: response.status });
-            },
-        };
-    }
-    /** Detects certain errors and update client status accordingly when using GRPC wire connection */
-    createGrpcErrorInterceptor() {
-        return (options, nextCall) => {
-            return new InterceptingCall(nextCall(options), {
-                start: (metadata, listener, next) => {
-                    next(metadata, {
-                        onReceiveStatus: (status$1, next) => {
-                            if (status$1.code == status.UNAUTHENTICATED)
-                                // (!!!) don't change to "==="
-                                this.updateStatus("Unauthenticated");
-                            if (status$1.code == status.UNAVAILABLE)
-                                // (!!!) don't change to "==="
-                                this.updateStatus("Disconnected");
-                            next(status$1);
-                        },
-                    });
-                },
-            });
-        };
-    }
-    createRestAuthInterceptor() {
-        return (dispatch) => {
-            return (options, handler) => {
-                if (this.authInformation?.jwtToken !== undefined) {
-                    // TODO: check this magic really works and gets called
-                    options.headers = {
-                        ...options.headers,
-                        authorization: "Bearer " + this.authInformation.jwtToken,
-                    };
-                    this.refreshAuthInformationIfNeeded();
-                }
-                return dispatch(options, handler);
-            };
-        };
-    }
-    /** Injects authentication information if needed */
-    createGrpcAuthInterceptor() {
-        return (options, nextCall) => {
-            return new InterceptingCall(nextCall(options), {
-                start: (metadata, listener, next) => {
-                    if (this.authInformation?.jwtToken !== undefined) {
-                        metadata.set("authorization", "Bearer " + this.authInformation.jwtToken);
-                        this.refreshAuthInformationIfNeeded();
-                        next(metadata, listener);
-                    }
-                    else {
-                        next(metadata, listener);
-                    }
-                },
-            });
-        };
-    }
-    async getJwtToken(ttlSeconds, options) {
-        const cl = this.clientProvider.get();
-        if (cl instanceof PlatformClient) {
-            const meta = {};
-            if (options?.authorization)
-                meta.authorization = options.authorization;
-            return (await cl.getJWTToken({ expiration: { seconds: ttlSeconds, nanos: 0 } }, { meta }).response).token;
-        }
-        else {
-            const headers = {};
-            if (options?.authorization)
-                headers.authorization = options.authorization;
-            const resp = cl.POST("/v1/auth/jwt-token", {
-                body: { expiration: `${ttlSeconds}s` },
-                headers,
-            });
-            return notEmpty((await resp).data, "REST: empty response for JWT token request").token;
-        }
-    }
-    async ping() {
-        const cl = this.clientProvider.get();
-        if (cl instanceof PlatformClient) {
-            return (await cl.ping({})).response;
-        }
-        else {
-            return notEmpty((await cl.GET("/v1/ping")).data, "REST: empty response for ping request");
-        }
-    }
-    /**
-     * Detects the best available wire protocol.
-     * If wireProtocol is explicitly configured, does nothing.
-     * Otherwise probes the current protocol via ping; if it fails, switches to the alternative.
-     */
-    async detectOptimalWireProtocol() {
-        if (this.conf.wireProtocol) {
-            return;
-        }
-        // Each retry is:
-        //  - ping request timeout (100 to 3_000ms)
-        //  - backoff delay (30 to 500ms)
-        //
-        // 30 attempts are ~43 seconds of overall waiting time.
-        // Think twice on overall time this thing takes to complete when changing these parameters.
-        // It may block UI when connecting to the server and loading projects list.
-        const pingTimeoutFactor = 1.3;
-        const maxPingTimeoutMs = 3_000;
-        const retryOptions = {
-            type: "exponentialBackoff",
-            maxAttempts: 30,
-            initialDelay: 30,
-            backoffMultiplier: 1.3,
-            jitter: 0.2,
-            maxDelay: 500,
-        };
-        let attempt = 1;
-        let pingTimeoutMs = 100;
-        await retry(() => withTimeout(this.ping(), pingTimeoutMs), retryOptions, (e) => {
-            if (isAbortedError(e)) {
-                this.ops.logger?.info(`Wire proto autodetect: ping timed out after ${pingTimeoutMs}ms: attempt=${attempt}, wire=${this._wireProto}`);
-                if (attempt % 2 === 0) {
-                    // We have 2 wire protocols to check. Increase timeout each 2 attempts.
-                    pingTimeoutMs = Math.min(Math.round(pingTimeoutMs * pingTimeoutFactor), maxPingTimeoutMs);
-                }
-            }
-            else {
-                this.ops.logger?.info(`Wire proto autodetect: ping failed: attempt=${attempt}, wire=${this._wireProto}, err=${String(e)}`);
-            }
-            attempt++;
-            const protocol = this._wireProto === "grpc" ? "rest" : "grpc";
-            this.ops.logger?.info(`Wire protocol autodetect next attempt: will try wire '${protocol}' with timeout ${pingTimeoutMs}ms`);
-            this.initWireConnection(protocol);
-            return true;
-        });
-    }
-    async license() {
-        const cl = this.clientProvider.get();
-        if (cl instanceof PlatformClient) {
-            return (await cl.license({})).response;
-        }
-        else {
-            const resp = notEmpty((await cl.GET("/v1/license")).data, "REST: empty response for license request");
-            return {
-                status: resp.status,
-                isOk: resp.isOk,
-                responseBody: Uint8Array.from(Buffer.from(resp.responseBody)),
-            };
-        }
-    }
-    async authMethods() {
-        const cl = this.clientProvider.get();
-        if (cl instanceof PlatformClient) {
-            return (await cl.authMethods({})).response;
-        }
-        else {
-            return notEmpty((await cl.GET("/v1/auth/methods")).data, "REST: empty response for auth methods request");
-        }
-    }
-    async txSync(txId) {
-        const cl = this.clientProvider.get();
-        if (cl instanceof PlatformClient) {
-            await cl.txSync({ txId: BigInt(txId) });
-        }
-        else {
-            await cl.POST("/v1/tx-sync", { body: { txId: txId.toString() } });
-        }
-    }
-    createTx(rw, ops = {}) {
-        return new LLPlTransaction((abortSignal) => {
-            let totalAbortSignal = abortSignal;
-            if (ops.abortSignal)
-                totalAbortSignal = AbortSignal.any([totalAbortSignal, ops.abortSignal]);
-            const timeout = ops.timeout ??
-                (rw ? this.conf.defaultRWTransactionTimeout : this.conf.defaultROTransactionTimeout);
-            const cl = this.clientProvider.get();
-            if (cl instanceof PlatformClient) {
-                return cl.tx({
-                    abort: totalAbortSignal,
-                    timeout,
-                });
-            }
-            const wireConn = this.wireConnection;
-            if (wireConn.type === "rest") {
-                // For REST/WebSocket protocol, timeout needs to be converted to AbortSignal
-                if (timeout !== undefined) {
-                    totalAbortSignal = AbortSignal.any([totalAbortSignal, AbortSignal.timeout(timeout)]);
-                }
-                // The gRPC transport has the auth interceptor that already handles it, but here we need to refresh the auth information to be safe.
-                this.refreshAuthInformationIfNeeded();
-                const wsUrl = this.conf.ssl
-                    ? `wss://${this.conf.hostAndPort}/v1/ws/tx`
-                    : `ws://${this.conf.hostAndPort}/v1/ws/tx`;
-                return new WebSocketBiDiStream(wsUrl, (msg) => TxAPI_ClientMessage.toBinary(msg), (data) => TxAPI_ServerMessage.fromBinary(new Uint8Array(data)), {
-                    abortSignal: totalAbortSignal,
-                    jwtToken: this.authInformation?.jwtToken,
-                    dispatcher: wireConn.Dispatcher,
-                    onComplete: async (stream) => stream.requests.send({
-                        // Ask server to gracefully close the stream on its side, if not done yet.
-                        requestId: 0,
-                        request: { oneofKind: "streamClose", streamClose: {} },
-                    }),
-                });
-            }
-            throw new Error(`transactions are not supported for wire protocol ${this._wireProto}`);
-        });
-    }
-    /** Closes underlying transport */
-    async close() {
-        if (this.wireConnection.type === "grpc") {
-            this.wireConnection.Transport.close();
-        }
-        await this.httpDispatcher.destroy();
-    }
-}
+var LLPlClient = class LLPlClient {
+	/** Initial authorization information */
+	authInformation;
+	/** Will be executed by the client when it is required */
+	onAuthUpdate;
+	/** Will be executed if auth-related error happens during normal client operation */
+	onAuthError;
+	/** Will be executed by the client when it is required */
+	onAuthRefreshProblem;
+	/** Threshold after which auth info refresh is required */
+	refreshTimestamp;
+	_status = "OK";
+	statusListener;
+	_wireProto = "grpc";
+	_wireConn;
+	_restInterceptors;
+	_restMiddlewares;
+	_grpcInterceptors;
+	providers = [];
+	clientProvider;
+	httpDispatcher;
+	static async build(configOrAddress, ops = {}) {
+		const pl = new LLPlClient(typeof configOrAddress === "string" ? plAddressToConfig(configOrAddress) : configOrAddress, ops);
+		if (ops.useAutoDetectWireProtocol) await pl.detectOptimalWireProtocol();
+		return pl;
+	}
+	constructor(conf, ops = {}) {
+		this.conf = conf;
+		this.ops = ops;
+		const { auth, statusListener } = ops;
+		if (auth !== void 0) {
+			this.refreshTimestamp = inferAuthRefreshTime(auth.authInformation, this.conf.authMaxRefreshSeconds);
+			this.authInformation = auth.authInformation;
+			this.onAuthUpdate = auth.onUpdate;
+			this.onAuthRefreshProblem = auth.onUpdateError;
+			this.onAuthError = auth.onAuthError;
+		}
+		this._restInterceptors = [];
+		this._restMiddlewares = [];
+		this._grpcInterceptors = [];
+		if (auth !== void 0) {
+			this._restInterceptors.push(this.createRestAuthInterceptor());
+			this._grpcInterceptors.push(this.createGrpcAuthInterceptor());
+		}
+		this._restInterceptors.push(interceptors.retry({ statusCodes: [] }));
+		this._restMiddlewares.push(this.createRestErrorMiddleware());
+		this._grpcInterceptors.push(this.createGrpcErrorInterceptor());
+		this.httpDispatcher = defaultHttpDispatcher(this.conf.httpProxy);
+		if (this.conf.wireProtocol) this._wireProto = this.conf.wireProtocol;
+		this.initWireConnection(this._wireProto);
+		if (statusListener !== void 0) {
+			this.statusListener = statusListener;
+			statusListener(this._status);
+		}
+		this.clientProvider = this.createWireClientProvider((wireConn) => {
+			if (wireConn.type === "grpc") return new PlatformClient(wireConn.Transport);
+			else return createClient({
+				hostAndPort: wireConn.Config.hostAndPort,
+				ssl: wireConn.Config.ssl,
+				dispatcher: wireConn.Dispatcher,
+				middlewares: wireConn.Middlewares
+			});
+		});
+	}
+	initWireConnection(protocol) {
+		switch (protocol) {
+			case "rest":
+				this.initRestConnection();
+				return;
+			case "grpc":
+				this.initGrpcConnection(this.ops.shouldUseGzip ?? false);
+				return;
+			default: ((v) => {
+				throw new Error(`Unsupported wire protocol '${v}'. Use one of: ${SUPPORTED_WIRE_PROTOCOLS.join(", ")}`);
+			})(protocol);
+		}
+	}
+	initRestConnection() {
+		const dispatcher = defaultHttpDispatcher(this.conf.grpcProxy, this._restInterceptors);
+		this._replaceWireConnection({
+			type: "rest",
+			Config: this.conf,
+			Dispatcher: dispatcher,
+			Middlewares: this._restMiddlewares
+		});
+	}
+	/**
+	* Initializes (or reinitializes) _grpcTransport
+	* @param gzip - whether to enable gzip compression
+	*/
+	initGrpcConnection(gzip) {
+		const clientOptions = {
+			"grpc.keepalive_time_ms": 3e4,
+			"grpc.service_config_disable_resolution": 1,
+			interceptors: this._grpcInterceptors
+		};
+		if (gzip) clientOptions["grpc.default_compression_algorithm"] = compressionAlgorithms.gzip;
+		const grpcOptions = {
+			host: this.conf.hostAndPort,
+			timeout: this.conf.defaultRequestTimeout,
+			channelCredentials: this.conf.ssl ? ChannelCredentials.createSsl() : ChannelCredentials.createInsecure(),
+			clientOptions
+		};
+		const grpcProxy = typeof this.conf.grpcProxy === "string" ? { url: this.conf.grpcProxy } : this.conf.grpcProxy;
+		if (grpcProxy?.url) {
+			const url = new URL(grpcProxy.url);
+			if (grpcProxy.auth) {
+				const parsed = parseHttpAuth(grpcProxy.auth);
+				if (parsed.scheme !== "Basic") throw new Error(`Unsupported auth scheme: ${parsed.scheme}.`);
+				url.username = parsed.username;
+				url.password = parsed.password;
+			}
+			process.env.grpc_proxy = url.toString();
+		} else delete process.env.grpc_proxy;
+		this._replaceWireConnection({
+			type: "grpc",
+			Transport: new GrpcTransport(grpcOptions)
+		});
+	}
+	_replaceWireConnection(newConn) {
+		const oldConn = this._wireConn;
+		this._wireConn = newConn;
+		this._wireProto = newConn.type;
+		for (let i = 0; i < this.providers.length; i++) {
+			const provider = this.providers[i].deref();
+			if (provider === void 0) {
+				this.providers.splice(i, 1);
+				i--;
+			} else provider.reset();
+		}
+		if (oldConn !== void 0 && oldConn.type === "grpc") oldConn.Transport.close();
+	}
+	providerCleanupCounter = 0;
+	/**
+	* Creates a provider for a grpc client. Returned provider will create fresh client whenever the underlying transport is reset.
+	*
+	* @param clientConstructor - a factory function that creates a grpc client
+	*/
+	createWireClientProvider(clientConstructor) {
+		this.providerCleanupCounter++;
+		if (this.providerCleanupCounter >= 16) {
+			for (let i = 0; i < this.providers.length; i++) if (this.providers[i].deref() === void 0) {
+				this.providers.splice(i, 1);
+				i--;
+			}
+			this.providerCleanupCounter = 0;
+		}
+		const provider = new WireClientProviderImpl(() => this._wireConn, clientConstructor);
+		this.providers.push(new WeakRef(provider));
+		return provider;
+	}
+	get wireConnection() {
+		return this._wireConn;
+	}
+	get wireProtocol() {
+		return this._wireProto;
+	}
+	/** Returns true if client is authenticated. Even with anonymous auth information
+	* connection is considered authenticated. Unauthenticated clients are used for
+	* login and similar tasks, see {@link UnauthenticatedPlClient}. */
+	get authenticated() {
+		return this.authInformation !== void 0;
+	}
+	/** null means anonymous connection */
+	get authUser() {
+		if (!this.authenticated) throw new Error("Client is not authenticated");
+		if (this.authInformation?.jwtToken) return parsePlJwt(this.authInformation?.jwtToken).user.login;
+		else return null;
+	}
+	updateStatus(newStatus) {
+		process.nextTick(() => {
+			if (this._status !== newStatus) {
+				this._status = newStatus;
+				if (this.statusListener !== void 0) this.statusListener(this._status);
+				if (newStatus === "Unauthenticated" && this.onAuthError !== void 0) this.onAuthError();
+			}
+		});
+	}
+	get status() {
+		return this._status;
+	}
+	authRefreshInProgress = false;
+	refreshAuthInformationIfNeeded() {
+		if (this.refreshTimestamp === void 0 || Date.now() < this.refreshTimestamp || this.authRefreshInProgress || this._status === "Unauthenticated") return;
+		this.authRefreshInProgress = true;
+		(async () => {
+			try {
+				this.authInformation = { jwtToken: await this.getJwtToken(BigInt(this.conf.authTTLSeconds)) };
+				this.refreshTimestamp = inferAuthRefreshTime(this.authInformation, this.conf.authMaxRefreshSeconds);
+				if (this.onAuthUpdate) this.onAuthUpdate(this.authInformation);
+			} catch (e) {
+				if (this.onAuthRefreshProblem) this.onAuthRefreshProblem(e);
+			} finally {
+				this.authRefreshInProgress = false;
+			}
+		})();
+	}
+	/**
+	* Creates middleware that parses error responses and handles them centrally.
+	* This middleware runs before openapi-fetch parses the response, so we need to
+	* manually parse the response body for error responses.
+	*/
+	createRestErrorMiddleware() {
+		return { onResponse: async ({ request: _request, response, options: _options }) => {
+			const { body, ...resOptions } = response;
+			if ([
+				502,
+				503,
+				504
+			].includes(response.status)) {
+				this.updateStatus("Disconnected");
+				return new Response(body, {
+					...resOptions,
+					status: response.status
+				});
+			}
+			const respErr = await parseResponseError(response);
+			if (!respErr.error) return new Response(respErr.origBody ?? body, {
+				...resOptions,
+				status: response.status
+			});
+			if (typeof respErr.error === "string") return new Response(respErr.error, {
+				...resOptions,
+				status: response.status
+			});
+			if (respErr.error.code === Code.UNAUTHENTICATED) this.updateStatus("Unauthenticated");
+			return new Response(respErr.origBody, {
+				...resOptions,
+				status: response.status
+			});
+		} };
+	}
+	/** Detects certain errors and update client status accordingly when using GRPC wire connection */
+	createGrpcErrorInterceptor() {
+		return (options, nextCall) => {
+			return new InterceptingCall(nextCall(options), { start: (metadata, listener, next) => {
+				next(metadata, { onReceiveStatus: (status$1, next) => {
+					if (status$1.code == status.UNAUTHENTICATED) this.updateStatus("Unauthenticated");
+					if (status$1.code == status.UNAVAILABLE) this.updateStatus("Disconnected");
+					next(status$1);
+				} });
+			} });
+		};
+	}
+	createRestAuthInterceptor() {
+		return (dispatch) => {
+			return (options, handler) => {
+				if (this.authInformation?.jwtToken !== void 0) {
+					options.headers = {
+						...options.headers,
+						authorization: "Bearer " + this.authInformation.jwtToken
+					};
+					this.refreshAuthInformationIfNeeded();
+				}
+				return dispatch(options, handler);
+			};
+		};
+	}
+	/** Injects authentication information if needed */
+	createGrpcAuthInterceptor() {
+		return (options, nextCall) => {
+			return new InterceptingCall(nextCall(options), { start: (metadata, listener, next) => {
+				if (this.authInformation?.jwtToken !== void 0) {
+					metadata.set("authorization", "Bearer " + this.authInformation.jwtToken);
+					this.refreshAuthInformationIfNeeded();
+					next(metadata, listener);
+				} else next(metadata, listener);
+			} });
+		};
+	}
+	async getJwtToken(ttlSeconds, options) {
+		const cl = this.clientProvider.get();
+		if (cl instanceof PlatformClient) {
+			const meta = {};
+			if (options?.authorization) meta.authorization = options.authorization;
+			return (await cl.getJWTToken({ expiration: {
+				seconds: ttlSeconds,
+				nanos: 0
+			} }, { meta }).response).token;
+		} else {
+			const headers = {};
+			if (options?.authorization) headers.authorization = options.authorization;
+			return notEmpty((await cl.POST("/v1/auth/jwt-token", {
+				body: { expiration: `${ttlSeconds}s` },
+				headers
+			})).data, "REST: empty response for JWT token request").token;
+		}
+	}
+	async ping() {
+		const cl = this.clientProvider.get();
+		if (cl instanceof PlatformClient) return (await cl.ping({})).response;
+		else return notEmpty((await cl.GET("/v1/ping")).data, "REST: empty response for ping request");
+	}
+	/**
+	* Detects the best available wire protocol.
+	* If wireProtocol is explicitly configured, does nothing.
+	* Otherwise probes the current protocol via ping; if it fails, switches to the alternative.
+	*/
+	async detectOptimalWireProtocol() {
+		if (this.conf.wireProtocol) return;
+		const pingTimeoutFactor = 1.3;
+		const maxPingTimeoutMs = 3e3;
+		const retryOptions = {
+			type: "exponentialBackoff",
+			maxAttempts: 30,
+			initialDelay: 30,
+			backoffMultiplier: 1.3,
+			jitter: .2,
+			maxDelay: 500
+		};
+		let attempt = 1;
+		let pingTimeoutMs = 100;
+		await retry(() => withTimeout(this.ping(), pingTimeoutMs), retryOptions, (e) => {
+			if (isAbortedError(e)) {
+				this.ops.logger?.info(`Wire proto autodetect: ping timed out after ${pingTimeoutMs}ms: attempt=${attempt}, wire=${this._wireProto}`);
+				if (attempt % 2 === 0) pingTimeoutMs = Math.min(Math.round(pingTimeoutMs * pingTimeoutFactor), maxPingTimeoutMs);
+			} else this.ops.logger?.info(`Wire proto autodetect: ping failed: attempt=${attempt}, wire=${this._wireProto}, err=${String(e)}`);
+			attempt++;
+			const protocol = this._wireProto === "grpc" ? "rest" : "grpc";
+			this.ops.logger?.info(`Wire protocol autodetect next attempt: will try wire '${protocol}' with timeout ${pingTimeoutMs}ms`);
+			this.initWireConnection(protocol);
+			return true;
+		});
+	}
+	async license() {
+		const cl = this.clientProvider.get();
+		if (cl instanceof PlatformClient) return (await cl.license({})).response;
+		else {
+			const resp = notEmpty((await cl.GET("/v1/license")).data, "REST: empty response for license request");
+			return {
+				status: resp.status,
+				isOk: resp.isOk,
+				responseBody: Uint8Array.from(Buffer.from(resp.responseBody))
+			};
+		}
+	}
+	async authMethods() {
+		const cl = this.clientProvider.get();
+		if (cl instanceof PlatformClient) return (await cl.authMethods({})).response;
+		else return notEmpty((await cl.GET("/v1/auth/methods")).data, "REST: empty response for auth methods request");
+	}
+	async txSync(txId) {
+		const cl = this.clientProvider.get();
+		if (cl instanceof PlatformClient) await cl.txSync({ txId: BigInt(txId) });
+		else await cl.POST("/v1/tx-sync", { body: { txId: txId.toString() } });
+	}
+	createTx(rw, ops = {}) {
+		return new LLPlTransaction((abortSignal) => {
+			let totalAbortSignal = abortSignal;
+			if (ops.abortSignal) totalAbortSignal = AbortSignal.any([totalAbortSignal, ops.abortSignal]);
+			const timeout = ops.timeout ?? (rw ? this.conf.defaultRWTransactionTimeout : this.conf.defaultROTransactionTimeout);
+			const cl = this.clientProvider.get();
+			if (cl instanceof PlatformClient) return cl.tx({
+				abort: totalAbortSignal,
+				timeout
+			});
+			const wireConn = this.wireConnection;
+			if (wireConn.type === "rest") {
+				if (timeout !== void 0) totalAbortSignal = AbortSignal.any([totalAbortSignal, AbortSignal.timeout(timeout)]);
+				this.refreshAuthInformationIfNeeded();
+				return new WebSocketBiDiStream(this.conf.ssl ? `wss://${this.conf.hostAndPort}/v1/ws/tx` : `ws://${this.conf.hostAndPort}/v1/ws/tx`, (msg) => TxAPI_ClientMessage.toBinary(msg), (data) => TxAPI_ServerMessage.fromBinary(new Uint8Array(data)), {
+					abortSignal: totalAbortSignal,
+					jwtToken: this.authInformation?.jwtToken,
+					dispatcher: wireConn.Dispatcher,
+					onComplete: async (stream) => stream.requests.send({
+						requestId: 0,
+						request: {
+							oneofKind: "streamClose",
+							streamClose: {}
+						}
+					})
+				});
+			}
+			throw new Error(`transactions are not supported for wire protocol ${this._wireProto}`);
+		});
+	}
+	/** Closes underlying transport */
+	async close() {
+		if (this.wireConnection.type === "grpc") this.wireConnection.Transport.close();
+		await this.httpDispatcher.destroy();
+	}
+};
 
+//#endregion
 export { LLPlClient };
-//# sourceMappingURL=ll_client.js.map
+//# sourceMappingURL=ll_client.js.map