@peerbit/canonical-client 0.0.0-e209d2e

package/dist/src/client.js

@@ -0,0 +1,709 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { deserialize, field, serialize, variant } from "@dao-xyz/borsh";
+import { CanonicalBootstrapRequest, CanonicalConnection, CanonicalControlRequest, CanonicalControlResponse, CanonicalLoadProgramRequest, CanonicalSignRequest, createMessagePortTransport as createControlTransport, createRpcTransport as createRpcTransportBase, } from "@peerbit/canonical-transport";
+import { PreHash, PublicSignKey, SignatureWithKey, } from "@peerbit/crypto";
+class RpcMessage {
+}
+let RpcRequestHeader = (() => {
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _method_decorators;
+    let _method_initializers = [];
+    let _method_extraInitializers = [];
+    return class RpcRequestHeader {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [field({ type: "u32" })];
+            _method_decorators = [field({ type: "string" })];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _method_decorators, { kind: "field", name: "method", static: false, private: false, access: { has: obj => "method" in obj, get: obj => obj.method, set: (obj, value) => { obj.method = value; } }, metadata: _metadata }, _method_initializers, _method_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        id = __runInitializers(this, _id_initializers, void 0);
+        method = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _method_initializers, void 0));
+        constructor(properties) {
+            __runInitializers(this, _method_extraInitializers);
+            this.id = properties.id;
+            this.method = properties.method;
+        }
+    };
+})();
+let RpcResponseHeader = (() => {
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _method_decorators;
+    let _method_initializers = [];
+    let _method_extraInitializers = [];
+    return class RpcResponseHeader {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [field({ type: "u32" })];
+            _method_decorators = [field({ type: "string" })];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _method_decorators, { kind: "field", name: "method", static: false, private: false, access: { has: obj => "method" in obj, get: obj => obj.method, set: (obj, value) => { obj.method = value; } }, metadata: _metadata }, _method_initializers, _method_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        id = __runInitializers(this, _id_initializers, void 0);
+        method = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _method_initializers, void 0));
+        constructor(properties) {
+            __runInitializers(this, _method_extraInitializers);
+            this.id = properties.id;
+            this.method = properties.method;
+        }
+    };
+})();
+let RpcRequest = (() => {
+    let _classDecorators = [variant(0)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = RpcMessage;
+    let _header_decorators;
+    let _header_initializers = [];
+    let _header_extraInitializers = [];
+    let _payload_decorators;
+    let _payload_initializers = [];
+    let _payload_extraInitializers = [];
+    var RpcRequest = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _header_decorators = [field({ type: RpcRequestHeader })];
+            _payload_decorators = [field({ type: Uint8Array })];
+            __esDecorate(null, null, _header_decorators, { kind: "field", name: "header", static: false, private: false, access: { has: obj => "header" in obj, get: obj => obj.header, set: (obj, value) => { obj.header = value; } }, metadata: _metadata }, _header_initializers, _header_extraInitializers);
+            __esDecorate(null, null, _payload_decorators, { kind: "field", name: "payload", static: false, private: false, access: { has: obj => "payload" in obj, get: obj => obj.payload, set: (obj, value) => { obj.payload = value; } }, metadata: _metadata }, _payload_initializers, _payload_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RpcRequest = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        header = __runInitializers(this, _header_initializers, void 0);
+        payload = (__runInitializers(this, _header_extraInitializers), __runInitializers(this, _payload_initializers, void 0));
+        constructor(properties) {
+            super();
+            __runInitializers(this, _payload_extraInitializers);
+            this.header = properties.header;
+            this.payload = properties.payload;
+        }
+    };
+    return RpcRequest = _classThis;
+})();
+let RpcOk = (() => {
+    let _classDecorators = [variant(1)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = RpcMessage;
+    let _header_decorators;
+    let _header_initializers = [];
+    let _header_extraInitializers = [];
+    let _payload_decorators;
+    let _payload_initializers = [];
+    let _payload_extraInitializers = [];
+    var RpcOk = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _header_decorators = [field({ type: RpcResponseHeader })];
+            _payload_decorators = [field({ type: Uint8Array })];
+            __esDecorate(null, null, _header_decorators, { kind: "field", name: "header", static: false, private: false, access: { has: obj => "header" in obj, get: obj => obj.header, set: (obj, value) => { obj.header = value; } }, metadata: _metadata }, _header_initializers, _header_extraInitializers);
+            __esDecorate(null, null, _payload_decorators, { kind: "field", name: "payload", static: false, private: false, access: { has: obj => "payload" in obj, get: obj => obj.payload, set: (obj, value) => { obj.payload = value; } }, metadata: _metadata }, _payload_initializers, _payload_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RpcOk = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        header = __runInitializers(this, _header_initializers, void 0);
+        payload = (__runInitializers(this, _header_extraInitializers), __runInitializers(this, _payload_initializers, void 0));
+        constructor(properties) {
+            super();
+            __runInitializers(this, _payload_extraInitializers);
+            this.header = properties.header;
+            this.payload = properties.payload;
+        }
+    };
+    return RpcOk = _classThis;
+})();
+let RpcErr = (() => {
+    let _classDecorators = [variant(2)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = RpcMessage;
+    let _header_decorators;
+    let _header_initializers = [];
+    let _header_extraInitializers = [];
+    let _message_decorators;
+    let _message_initializers = [];
+    let _message_extraInitializers = [];
+    var RpcErr = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _header_decorators = [field({ type: RpcResponseHeader })];
+            _message_decorators = [field({ type: "string" })];
+            __esDecorate(null, null, _header_decorators, { kind: "field", name: "header", static: false, private: false, access: { has: obj => "header" in obj, get: obj => obj.header, set: (obj, value) => { obj.header = value; } }, metadata: _metadata }, _header_initializers, _header_extraInitializers);
+            __esDecorate(null, null, _message_decorators, { kind: "field", name: "message", static: false, private: false, access: { has: obj => "message" in obj, get: obj => obj.message, set: (obj, value) => { obj.message = value; } }, metadata: _metadata }, _message_initializers, _message_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RpcErr = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        header = __runInitializers(this, _header_initializers, void 0);
+        message = (__runInitializers(this, _header_extraInitializers), __runInitializers(this, _message_initializers, void 0));
+        constructor(properties) {
+            super();
+            __runInitializers(this, _message_extraInitializers);
+            this.header = properties.header;
+            this.message = properties.message;
+        }
+    };
+    return RpcErr = _classThis;
+})();
+let RpcStream = (() => {
+    let _classDecorators = [variant(3)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = RpcMessage;
+    let _header_decorators;
+    let _header_initializers = [];
+    let _header_extraInitializers = [];
+    let _payload_decorators;
+    let _payload_initializers = [];
+    let _payload_extraInitializers = [];
+    var RpcStream = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _header_decorators = [field({ type: RpcResponseHeader })];
+            _payload_decorators = [field({ type: Uint8Array })];
+            __esDecorate(null, null, _header_decorators, { kind: "field", name: "header", static: false, private: false, access: { has: obj => "header" in obj, get: obj => obj.header, set: (obj, value) => { obj.header = value; } }, metadata: _metadata }, _header_initializers, _header_extraInitializers);
+            __esDecorate(null, null, _payload_decorators, { kind: "field", name: "payload", static: false, private: false, access: { has: obj => "payload" in obj, get: obj => obj.payload, set: (obj, value) => { obj.payload = value; } }, metadata: _metadata }, _payload_initializers, _payload_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RpcStream = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        header = __runInitializers(this, _header_initializers, void 0);
+        payload = (__runInitializers(this, _header_extraInitializers), __runInitializers(this, _payload_initializers, void 0));
+        constructor(properties) {
+            super();
+            __runInitializers(this, _payload_extraInitializers);
+            this.header = properties.header;
+            this.payload = properties.payload;
+        }
+    };
+    return RpcStream = _classThis;
+})();
+let RpcStreamEnd = (() => {
+    let _classDecorators = [variant(4)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = RpcMessage;
+    let _header_decorators;
+    let _header_initializers = [];
+    let _header_extraInitializers = [];
+    var RpcStreamEnd = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _header_decorators = [field({ type: RpcResponseHeader })];
+            __esDecorate(null, null, _header_decorators, { kind: "field", name: "header", static: false, private: false, access: { has: obj => "header" in obj, get: obj => obj.header, set: (obj, value) => { obj.header = value; } }, metadata: _metadata }, _header_initializers, _header_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RpcStreamEnd = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        header = __runInitializers(this, _header_initializers, void 0);
+        constructor(properties) {
+            super();
+            __runInitializers(this, _header_extraInitializers);
+            this.header = properties.header;
+        }
+    };
+    return RpcStreamEnd = _classThis;
+})();
+let RpcStreamErr = (() => {
+    let _classDecorators = [variant(5)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = RpcMessage;
+    let _header_decorators;
+    let _header_initializers = [];
+    let _header_extraInitializers = [];
+    let _message_decorators;
+    let _message_initializers = [];
+    let _message_extraInitializers = [];
+    var RpcStreamErr = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _header_decorators = [field({ type: RpcResponseHeader })];
+            _message_decorators = [field({ type: "string" })];
+            __esDecorate(null, null, _header_decorators, { kind: "field", name: "header", static: false, private: false, access: { has: obj => "header" in obj, get: obj => obj.header, set: (obj, value) => { obj.header = value; } }, metadata: _metadata }, _header_initializers, _header_extraInitializers);
+            __esDecorate(null, null, _message_decorators, { kind: "field", name: "message", static: false, private: false, access: { has: obj => "message" in obj, get: obj => obj.message, set: (obj, value) => { obj.message = value; } }, metadata: _metadata }, _message_initializers, _message_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RpcStreamErr = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        header = __runInitializers(this, _header_initializers, void 0);
+        message = (__runInitializers(this, _header_extraInitializers), __runInitializers(this, _message_initializers, void 0));
+        constructor(properties) {
+            super();
+            __runInitializers(this, _message_extraInitializers);
+            this.header = properties.header;
+            this.message = properties.message;
+        }
+    };
+    return RpcStreamErr = _classThis;
+})();
+const isMessagePort = (value) => typeof value.postMessage === "function";
+const toRpcMessage = (data) => {
+    try {
+        return deserialize(data, RpcMessage);
+    }
+    catch {
+        return undefined;
+    }
+};
+const createCloseAwareRpcTransport = (base, options) => {
+    const closeErrorMessage = options.closeErrorMessage ?? "RPC transport closed";
+    const handlers = new Set();
+    const inFlight = new Map();
+    let closed = false;
+    let offClose;
+    const ignoreTimeoutForMethod = options.ignoreTimeoutForMethod ??
+        ((method) => method.startsWith("$events:") ||
+            method.startsWith("$watch:") ||
+            method.startsWith("$presentWatch:"));
+    const resolveTimeoutMs = (method) => {
+        if (ignoreTimeoutForMethod(method))
+            return undefined;
+        const configured = options.requestTimeoutMs;
+        if (configured == null)
+            return undefined;
+        const value = typeof configured === "function" ? configured(method) : configured;
+        if (value == null || value <= 0)
+            return undefined;
+        return value;
+    };
+    const emit = (data) => {
+        for (const handler of handlers) {
+            try {
+                handler(data);
+            }
+            catch { }
+        }
+    };
+    const unsubscribeBase = base.onMessage((data) => {
+        const msg = toRpcMessage(data);
+        if (msg instanceof RpcOk ||
+            msg instanceof RpcErr ||
+            msg instanceof RpcStream ||
+            msg instanceof RpcStreamEnd ||
+            msg instanceof RpcStreamErr) {
+            const id = msg.header.id;
+            const entry = inFlight.get(id);
+            if (entry?.timeout) {
+                clearTimeout(entry.timeout);
+                entry.timeout = undefined;
+            }
+            if (msg instanceof RpcOk ||
+                msg instanceof RpcErr ||
+                msg instanceof RpcStreamEnd ||
+                msg instanceof RpcStreamErr) {
+                inFlight.delete(id);
+            }
+        }
+        emit(data);
+    });
+    const close = (message = closeErrorMessage) => {
+        if (closed)
+            return;
+        closed = true;
+        if (offClose)
+            offClose();
+        unsubscribeBase();
+        for (const [id, entry] of inFlight) {
+            if (entry.timeout)
+                clearTimeout(entry.timeout);
+            emit(serialize(new RpcErr({
+                header: new RpcResponseHeader({ id, method: entry.method }),
+                message,
+            })));
+        }
+        inFlight.clear();
+    };
+    if (options.onClose) {
+        offClose = options.onClose(() => close(closeErrorMessage));
+    }
+    return {
+        send: (data) => {
+            const msg = toRpcMessage(data);
+            if (closed) {
+                if (msg instanceof RpcRequest) {
+                    emit(serialize(new RpcErr({
+                        header: new RpcResponseHeader({
+                            id: msg.header.id,
+                            method: msg.header.method,
+                        }),
+                        message: closeErrorMessage,
+                    })));
+                }
+                return;
+            }
+            if (msg instanceof RpcRequest) {
+                const method = msg.header.method;
+                const timeoutMs = resolveTimeoutMs(method);
+                const id = msg.header.id;
+                const entry = {
+                    method,
+                    timeout: timeoutMs
+                        ? setTimeout(() => {
+                            const current = inFlight.get(id);
+                            if (!current)
+                                return;
+                            inFlight.delete(id);
+                            emit(serialize(new RpcErr({
+                                header: new RpcResponseHeader({
+                                    id,
+                                    method: current.method,
+                                }),
+                                message: `RPC request timeout (${current.method})`,
+                            })));
+                        }, timeoutMs)
+                        : undefined,
+                };
+                inFlight.set(id, entry);
+            }
+            base.send(data);
+        },
+        onMessage: (handler) => {
+            handlers.add(handler);
+            return () => {
+                handlers.delete(handler);
+            };
+        },
+        close,
+    };
+};
+export const createMessagePortTransport = (port, options) => {
+    const base = createRpcTransportBase(port);
+    const shouldWrap = typeof options?.requestTimeoutMs !== "undefined" ||
+        typeof options?.ignoreTimeoutForMethod === "function" ||
+        typeof options?.closeErrorMessage === "string";
+    if (isMessagePort(port)) {
+        if (!shouldWrap)
+            return base;
+        return createCloseAwareRpcTransport(base, {
+            requestTimeoutMs: options?.requestTimeoutMs,
+            ignoreTimeoutForMethod: options?.ignoreTimeoutForMethod,
+            closeErrorMessage: options?.closeErrorMessage,
+        });
+    }
+    const channel = port;
+    if (typeof channel.onClose !== "function") {
+        if (!shouldWrap)
+            return base;
+        return createCloseAwareRpcTransport(base, {
+            requestTimeoutMs: options?.requestTimeoutMs,
+            ignoreTimeoutForMethod: options?.ignoreTimeoutForMethod,
+            closeErrorMessage: options?.closeErrorMessage,
+        });
+    }
+    return createCloseAwareRpcTransport(base, {
+        onClose: (handler) => channel.onClose?.(handler) ?? (() => { }),
+        requestTimeoutMs: options?.requestTimeoutMs,
+        ignoreTimeoutForMethod: options?.ignoreTimeoutForMethod,
+        closeErrorMessage: options?.closeErrorMessage,
+    });
+};
+export class CanonicalClient {
+    nextId = 1;
+    pending = new Map();
+    connection;
+    unsubscribe;
+    keepAliveTimer;
+    keepAliveInFlight;
+    requestTimeoutMs;
+    cachedPeerId;
+    cachedPublicKey;
+    cachedMultiaddrs;
+    cachedIdentity;
+    constructor(control, options) {
+        const transport = typeof control.postMessage === "function"
+            ? createControlTransport(control)
+            : control;
+        this.connection = new CanonicalConnection(transport);
+        this.requestTimeoutMs = options?.requestTimeoutMs;
+        this.unsubscribe = this.connection.onControl((frame) => {
+            if (frame instanceof CanonicalControlResponse) {
+                this.onMessage(frame);
+            }
+        });
+    }
+    static async create(control, options) {
+        const client = new CanonicalClient(control, options);
+        await client.init();
+        return client;
+    }
+    async init() {
+        if (this.cachedPublicKey)
+            return;
+        await this.peerInfo();
+    }
+    close() {
+        if (this.keepAliveTimer) {
+            clearInterval(this.keepAliveTimer);
+            this.keepAliveTimer = undefined;
+        }
+        this.keepAliveInFlight = undefined;
+        this.unsubscribe();
+        this.connection.close();
+        for (const [id, p] of this.pending) {
+            if (p.timeout)
+                clearTimeout(p.timeout);
+            p.reject(new Error("CanonicalClient closed"));
+            this.pending.delete(id);
+        }
+    }
+    async peerId() {
+        if (this.cachedPeerId)
+            return this.cachedPeerId;
+        const resp = await this.request({ op: "peerId" });
+        if (!resp.peerId) {
+            throw new Error("Canonical peerId response missing peerId");
+        }
+        this.cachedPeerId = resp.peerId;
+        return resp.peerId;
+    }
+    async peerInfo() {
+        const resp = await this.request({ op: "peerInfo" });
+        if (!resp.peerId) {
+            throw new Error("Canonical peerInfo response missing peerId");
+        }
+        if (!resp.payload) {
+            throw new Error("Canonical peerInfo response missing payload");
+        }
+        const publicKey = deserialize(resp.payload, PublicSignKey);
+        const multiaddrs = resp.strings ?? [];
+        this.cachedPeerId = resp.peerId;
+        this.cachedPublicKey = publicKey;
+        this.cachedMultiaddrs = multiaddrs;
+        this.cachedIdentity = undefined;
+        return { peerId: resp.peerId, publicKey, multiaddrs };
+    }
+    async multiaddrs() {
+        if (this.cachedMultiaddrs)
+            return this.cachedMultiaddrs;
+        const info = await this.peerInfo();
+        return info.multiaddrs;
+    }
+    getMultiaddrs() {
+        return this.multiaddrs();
+    }
+    async dial(address) {
+        const value = typeof address === "string" ? address : address.toString();
+        await this.request({ op: "dial", name: value });
+        return true;
+    }
+    async hangUp(address) {
+        const value = typeof address === "string" ? address : address.toString();
+        await this.request({ op: "hangUp", name: value });
+    }
+    async start() {
+        await this.request({ op: "start" });
+    }
+    async stop() {
+        await this.request({ op: "stop" });
+    }
+    async bootstrap(addresses) {
+        const payload = addresses && addresses.length > 0
+            ? serialize(new CanonicalBootstrapRequest({ addresses }))
+            : undefined;
+        await this.request({ op: "bootstrap", payload });
+    }
+    async loadProgram(address, options) {
+        if (!address) {
+            throw new Error("Canonical loadProgram requires address to be set");
+        }
+        const payload = options?.timeoutMs != null
+            ? serialize(new CanonicalLoadProgramRequest({ timeoutMs: options.timeoutMs }))
+            : undefined;
+        const resp = await this.request({
+            op: "loadProgram",
+            name: address,
+            payload,
+        });
+        if (!resp.payload) {
+            throw new Error("Canonical loadProgram response missing payload");
+        }
+        return resp.payload;
+    }
+    async sign(data, prehash = PreHash.NONE) {
+        const resp = await this.request({
+            op: "sign",
+            payload: serialize(new CanonicalSignRequest({
+                data,
+                prehash,
+            })),
+        });
+        if (!resp.payload) {
+            throw new Error("Canonical sign response missing payload");
+        }
+        return deserialize(resp.payload, SignatureWithKey);
+    }
+    get identity() {
+        if (!this.cachedPublicKey) {
+            throw new Error("CanonicalClient not initialized (missing publicKey); call await CanonicalClient.create(...) or await client.init()");
+        }
+        if (this.cachedIdentity)
+            return this.cachedIdentity;
+        const publicKey = this.cachedPublicKey;
+        this.cachedIdentity = {
+            publicKey,
+            sign: (data, prehash) => this.sign(data, prehash ?? PreHash.NONE),
+            signer: (prehash = PreHash.NONE) => (data) => this.sign(data, prehash),
+        };
+        return this.cachedIdentity;
+    }
+    async openPort(name, payload) {
+        const resp = await this.request({
+            op: "open",
+            name,
+            payload,
+        });
+        if (resp.channelId == null) {
+            throw new Error("Canonical open response missing channelId");
+        }
+        return this.connection.createChannel(resp.channelId);
+    }
+    async ping() {
+        await this.request({ op: "ping" });
+    }
+    startKeepAlive(options) {
+        if (this.keepAliveTimer) {
+            clearInterval(this.keepAliveTimer);
+        }
+        const interval = Math.max(1000, options?.intervalMs ?? 30_000);
+        const timeoutMs = Math.max(1000, options?.timeoutMs ?? this.requestTimeoutMs ?? 10_000);
+        const closeOnFail = options?.closeOnFail ?? true;
+        const maxFailures = Math.max(1, options?.maxFailures ?? 2);
+        let failures = 0;
+        this.keepAliveTimer = setInterval(() => {
+            if (this.keepAliveInFlight)
+                return;
+            this.keepAliveInFlight = this.request({ op: "ping" }, { timeoutMs })
+                .then(() => {
+                failures = 0;
+            })
+                .catch(() => {
+                failures += 1;
+                if (closeOnFail && failures >= maxFailures) {
+                    this.close();
+                }
+            })
+                .finally(() => {
+                this.keepAliveInFlight = undefined;
+            });
+        }, interval);
+        return () => {
+            if (this.keepAliveTimer) {
+                clearInterval(this.keepAliveTimer);
+                this.keepAliveTimer = undefined;
+            }
+            this.keepAliveInFlight = undefined;
+        };
+    }
+    onMessage(message) {
+        const entry = this.pending.get(message.id);
+        if (!entry)
+            return;
+        this.pending.delete(message.id);
+        if (entry.timeout)
+            clearTimeout(entry.timeout);
+        if (message.ok === false) {
+            entry.reject(new Error(message.error ?? "Unknown error"));
+            return;
+        }
+        entry.resolve(message);
+    }
+    request(message, options) {
+        const id = this.nextId++;
+        const timeoutMs = options?.timeoutMs ?? this.requestTimeoutMs;
+        return new Promise((resolve, reject) => {
+            const entry = { resolve, reject };
+            if (timeoutMs && timeoutMs > 0) {
+                entry.timeout = setTimeout(() => {
+                    if (!this.pending.has(id))
+                        return;
+                    this.pending.delete(id);
+                    reject(new Error(`Canonical request timeout (${message.op})`));
+                }, timeoutMs);
+            }
+            this.pending.set(id, entry);
+            try {
+                this.connection.sendControl(new CanonicalControlRequest({
+                    id,
+                    op: message.op,
+                    ...("name" in message ? { name: message.name } : {}),
+                    ...("payload" in message ? { payload: message.payload } : {}),
+                }));
+            }
+            catch (e) {
+                if (entry.timeout)
+                    clearTimeout(entry.timeout);
+                this.pending.delete(id);
+                reject(e);
+            }
+        });
+    }
+}
+export const connectSharedWorker = async (worker, options) => {
+    return CanonicalClient.create(worker.port, options);
+};
+export const connectSharedWorkerPeerbit = async (worker, options) => {
+    const canonical = await connectSharedWorker(worker);
+    const { PeerbitCanonicalClient } = await import("./peerbit.js");
+    return PeerbitCanonicalClient.create(canonical, options);
+};
+//# sourceMappingURL=client.js.map