@urnetwork/sdk 2026.9.17-1048676710

package/dist/index.js

@@ -0,0 +1,1462 @@
+let wasmInitialized = false;
+let wasmInitPromise = null;
+const runtimeGlobal = globalThis;
+const isNode = () => Boolean(globalThis.process?.versions?.node);
+async function readNodeFile(url) {
+    const moduleName = "node:fs/promises";
+    const fs = await import(moduleName);
+    return fs.readFile(new URL(url));
+}
+function packagedUrl(name) {
+    const rel = `../wasm/${name}`;
+    return new URL(rel, import.meta.url).href;
+}
+async function loadWasmExec(url) {
+    if (typeof runtimeGlobal.Go !== "undefined") {
+        return;
+    }
+    const wasmExecUrl = url || packagedUrl("wasm_exec.js");
+    if (isNode()) {
+        if (wasmExecUrl.startsWith("file:")) {
+            await import(wasmExecUrl);
+        }
+        else {
+            const response = await fetch(wasmExecUrl);
+            if (!response.ok)
+                throw new Error("Could not load wasm_exec.js: HTTP " + response.status);
+            const moduleName = "node:vm";
+            const vm = await import(moduleName);
+            vm.runInThisContext(await response.text(), { filename: wasmExecUrl });
+        }
+        return;
+    }
+    return new Promise((resolve, reject) => {
+        const script = document.createElement("script");
+        script.src = wasmExecUrl;
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error(`Failed to load wasm_exec.js from ${wasmExecUrl}`));
+        document.head.appendChild(script);
+    });
+}
+async function instantiateWasm(wasmUrl, go) {
+    let result;
+    if (isNode() && wasmUrl.startsWith("file:")) {
+        result = await WebAssembly.instantiate(await readNodeFile(wasmUrl), go.importObject);
+        return result.instance;
+    }
+    const response = await fetch(wasmUrl);
+    if (!response.ok)
+        throw new Error(`Could not load WASM: HTTP ${response.status}`);
+    if (WebAssembly.instantiateStreaming) {
+        try {
+            result = await WebAssembly.instantiateStreaming(response.clone(), go.importObject);
+            return result.instance;
+        }
+        catch (e) {
+            console.warn("Streaming instantiation failed, falling back to fetch:", e);
+        }
+    }
+    const wasmBuffer = await response.arrayBuffer();
+    result = await WebAssembly.instantiate(wasmBuffer, go.importObject);
+    return result.instance;
+}
+async function initWasm(options = {}) {
+    if (wasmInitPromise) {
+        return wasmInitPromise;
+    }
+    if (wasmInitialized) {
+        return;
+    }
+    wasmInitPromise = (async () => {
+        try {
+            await loadWasmExec(options.wasmExecUrl);
+            const go = new runtimeGlobal.Go();
+            const previousGlobals = new Set(Object.keys(globalThis));
+            let registeredGlobals = [];
+            const originalExit = go.exit;
+            go.exit = (code) => {
+                for (const timer of go._scheduledTimeouts?.values() || [])
+                    clearTimeout(timer);
+                go._scheduledTimeouts?.clear();
+                wasmInitialized = false;
+                wasmInitPromise = null;
+                for (const key of registeredGlobals)
+                    delete globalThis[key];
+                originalExit(code);
+            };
+            const wasmUrl = options.wasmUrl || packagedUrl("sdk.wasm");
+            const wasmInstance = await instantiateWasm(wasmUrl, go);
+            await new Promise((resolve, reject) => {
+                let ready = false;
+                let timer;
+                const expires = Date.now() + 30000;
+                const check = () => {
+                    if (typeof runtimeGlobal.URnetworkNewPlatformDeviceRemote === "function" &&
+                        typeof runtimeGlobal.URnetworkClose === "function") {
+                        ready = true;
+                        registeredGlobals = Object.keys(globalThis).filter(key => key.startsWith("URnetwork") && !previousGlobals.has(key));
+                        resolve();
+                    }
+                    else if (Date.now() >= expires) {
+                        reject(new Error("Go runtime did not register its SDK exports"));
+                    }
+                    else {
+                        timer = setTimeout(check, 5);
+                    }
+                };
+                Promise.resolve(go.run(wasmInstance)).then(() => {
+                    clearTimeout(timer);
+                    if (!ready)
+                        reject(new Error("Go runtime exited before registering SDK exports"));
+                }, error => { clearTimeout(timer); reject(error); });
+                check();
+            });
+            wasmInitialized = true;
+        }
+        catch (error) {
+            wasmInitPromise = null;
+            throw new Error(`Failed to initialize URnetwork WASM: ${error}`);
+        }
+    })();
+    return wasmInitPromise;
+}
+function isWasmInitialized() {
+    return wasmInitialized;
+}
+function getWasmGlobals() {
+    if (!wasmInitialized) {
+        throw new Error("WASM not initialized. Call initWasm() first.");
+    }
+    return {
+        URnetworkNewProxyDeviceWithDefaults: runtimeGlobal.URnetworkNewProxyDeviceWithDefaults,
+        URnetworkNewPlatformDeviceRemote: runtimeGlobal.URnetworkNewPlatformDeviceRemote,
+        URnetworkNewExtensionDeviceRemote: runtimeGlobal.URnetworkNewExtensionDeviceRemote,
+        URnetworkNewLocationsViewController: runtimeGlobal.URnetworkNewLocationsViewController,
+        URnetworkNewAccountHost: runtimeGlobal.URnetworkNewAccountHost,
+        URnetworkColorHex: runtimeGlobal.URnetworkColorHex,
+        URnetworkClose: runtimeGlobal.URnetworkClose,
+    };
+}
+
+function bytes(value) {
+    if (!(value instanceof Uint8Array))
+        throw new TypeError("Expected Uint8Array");
+    return value.slice();
+}
+function deadline(value) {
+    const millis = value === null ? 0 : Number(value);
+    if (!Number.isSafeInteger(millis))
+        throw new RangeError("Expected epoch milliseconds or null");
+    return millis;
+}
+class Conn {
+    constructor(bridge, handle, network) {
+        this.released = false;
+        this.eof = false;
+        this.writes = Promise.resolve();
+        this.bridge = bridge;
+        this.handle = handle;
+        this.network = network;
+        this.readable = new ReadableStream({
+            pull: async (controller) => { const data = await this.read(); if (data === null)
+                controller.close();
+            else
+                controller.enqueue(data); },
+            cancel: async () => { if (network.startsWith("udp"))
+                await this.close();
+            else
+                await this.closeRead(); },
+        }, { highWaterMark: 0 });
+        this.writable = new WritableStream({
+            write: async (data) => { await this.write(data); },
+            close: async () => { if (network.startsWith("udp"))
+                await this.close();
+            else
+                await this.closeWrite(); },
+            abort: async () => { await this.close(); },
+        });
+    }
+    call(op, arg = null) {
+        if (this.released)
+            return Promise.reject(new Error("Socket is closed"));
+        return this.bridge.socketOperation(op, this.handle.id, arg);
+    }
+    waitClosed() { return this.call("socketClosed"); }
+    get localAddr() { return this.handle.localAddr ?? ""; }
+    get remoteAddr() { return this.handle.remoteAddr ?? ""; }
+    async read(maxBytes = 65535) {
+        if (!Number.isInteger(maxBytes) || maxBytes < 1 || maxBytes > 65535)
+            throw new RangeError("read size must be between 1 and 65535");
+        if (this.eof)
+            return null;
+        if (this.readError) {
+            const error = this.readError;
+            this.readError = undefined;
+            throw error;
+        }
+        const result = await this.call("read", maxBytes);
+        this.eof = result.eof;
+        if (result.error)
+            this.readError = new Error(result.error);
+        if (this.network === "udp")
+            Object.assign(this.handle, await this.call("addresses"));
+        return result.eof && result.data.length === 0 ? null : result.data;
+    }
+    async write(value) {
+        const data = bytes(value);
+        if (this.network.startsWith("udp") && data.length > 65507)
+            throw new RangeError("UDP datagram exceeds 65507 bytes");
+        const operation = this.writes.then(() => this.writeBytes(data));
+        this.writes = operation.catch(() => { });
+        return operation;
+    }
+    async writeBytes(data) {
+        let written = 0;
+        do {
+            const chunk = data.subarray(written, written + 65535);
+            let result;
+            try {
+                result = await this.call("write", chunk);
+            }
+            catch (error) {
+                throw Object.assign(error instanceof Error ? error : new Error(String(error)), { bytesWritten: written });
+            }
+            const n = typeof result === "number" ? result : result.bytesWritten;
+            written += n;
+            if (result.error)
+                throw Object.assign(new Error(result.error), { bytesWritten: written });
+            if (n !== chunk.length)
+                throw Object.assign(new Error("Short socket write"), { bytesWritten: written });
+        } while (written < data.length);
+        return written;
+    }
+    setDeadline(t) { return this.call("deadline", deadline(t)); }
+    setReadDeadline(t) { return this.call("readDeadline", deadline(t)); }
+    setWriteDeadline(t) { return this.call("writeDeadline", deadline(t)); }
+    closeRead() { return this.call("closeRead"); }
+    closeWrite() { return this.call("closeWrite"); }
+    async close() {
+        if (this.released)
+            return;
+        this.released = true;
+        await this.bridge.socketOperation("release", this.handle.id, null);
+    }
+}
+function attachSocketAPI(device) {
+    const bridge = device;
+    const dial = async (op, network, address, tls, options = {}) => {
+        if (!/^(tcp|udp)[46]?$/.test(network))
+            throw new TypeError("Unsupported socket network");
+        validateDialOptions(options);
+        options.signal?.throwIfAborted();
+        const handle = await bridge.socketOperation(op, 0, { network, address, tls, ...options });
+        if (options.signal?.aborted) {
+            await bridge.socketOperation("release", handle.id, null);
+            options.signal.throwIfAborted();
+        }
+        return new Conn(bridge, handle, network);
+    };
+    const result = Object.assign(device, {
+        dial: (network, address, options) => dial("dial", network, address, undefined, options),
+        dialTls: (network, address, tls, options) => dial("dialTls", network, address, tls, options),
+    });
+    return Object.assign(result, { directSockets: createDirectSockets(result) });
+}
+function validateDialOptions(options) {
+    if (options.timeoutMillis !== undefined && (!Number.isSafeInteger(options.timeoutMillis) || options.timeoutMillis < 0 || options.timeoutMillis > 2147483647))
+        throw new RangeError("timeoutMillis must be between 0 and 2147483647");
+}
+function invalidState(message) { return new DOMException(message, "InvalidStateError"); }
+function unsupported(message) { throw new DOMException(message, "NotSupportedError"); }
+function networkError(cause) {
+    return new DOMException(cause instanceof Error ? cause.message : String(cause), "NetworkError");
+}
+function uint(value, max, field) {
+    const n = Math.trunc(Number(value));
+    if (!Number.isFinite(n) || n < 0 || n > max)
+        throw new TypeError(field + " is out of range");
+    return n;
+}
+function destination(host, port) {
+    if (typeof host !== "string" || !host || /[\s/\[\]?#@]/.test(host))
+        throw new TypeError("Expected a hostname or unbracketed IP address");
+    const n = uint(port, 65535, "remotePort");
+    if (!n)
+        throw new TypeError("remotePort must be nonzero");
+    if (/^(?:22[4-9]|23\d)\./.test(host) || /^ff[\da-f]{0,2}:/i.test(host))
+        unsupported("Multicast sockets are not supported");
+    return (host.includes(":") ? "[" + host + "]" : host) + ":" + n;
+}
+function network(protocol, options) {
+    if (options.dnsQueryType !== undefined && options.dnsQueryType !== "ipv4" && options.dnsQueryType !== "ipv6")
+        throw new TypeError("Invalid dnsQueryType");
+    for (const field of ["sendBufferSize", "receiveBufferSize"]) {
+        if (options[field] !== undefined) {
+            if (!uint(options[field], 0xffffffff, field))
+                throw new TypeError(field + " must be nonzero");
+            unsupported("Per-socket " + field + " is not supported by the Device");
+        }
+    }
+    return (protocol + (options.dnsQueryType === "ipv4" ? "4" : options.dnsQueryType === "ipv6" ? "6" : ""));
+}
+function copyBuffer(value) {
+    if (!(value instanceof ArrayBuffer) && !ArrayBuffer.isView(value))
+        throw new TypeError("Expected BufferSource");
+    const view = ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : new Uint8Array(value);
+    if (!(view.buffer instanceof ArrayBuffer))
+        throw new TypeError("Shared buffers are not supported");
+    return view.slice();
+}
+function endpoint(address) {
+    const split = address.lastIndexOf(":");
+    let host = address.slice(0, split);
+    if (host.startsWith("[") && host.endsWith("]"))
+        host = host.slice(1, -1);
+    const port = Number(address.slice(split + 1));
+    if (split < 1 || !host || !Number.isInteger(port) || port < 0 || port > 65535)
+        throw new Error("Device returned an invalid socket address");
+    return { address: host, port };
+}
+class DirectSocket {
+    constructor(device, protocol, address, udp) {
+        this.readDone = false;
+        this.writeDone = false;
+        this.readStopped = false;
+        this.writeStopped = false;
+        this.reading = false;
+        this.writing = false;
+        this.failed = false;
+        this.settled = false;
+        this.udp = udp;
+        this.closed = new Promise((resolve, reject) => { this.resolveClosed = resolve; this.rejectClosed = reject; });
+        void this.closed.catch(() => { });
+        this.opened = Promise.resolve().then(() => device.dial(protocol, address)).then(async (conn) => {
+            this.conn = conn;
+            try {
+                this.info = this.streams();
+                void conn.waitClosed().then(() => {
+                    if (!this.finishing)
+                        this.fail(networkError("Socket closed by its Device"));
+                }, error => { if (!this.finishing)
+                    this.fail(networkError(error)); });
+                return this.info;
+            }
+            catch (error) {
+                await conn.close();
+                throw error;
+            }
+        }).catch(error => {
+            const failure = networkError(error);
+            this.settled = true;
+            this.rejectClosed(failure);
+            throw failure;
+        });
+        void this.opened.catch(() => { });
+    }
+    streams() {
+        const conn = this.conn;
+        const readable = this.udp
+            ? new ReadableStream({
+                start: c => { this.readController = c; },
+                pull: c => this.pull(c), cancel: () => this.stopRead(),
+            }, { highWaterMark: 0 })
+            : new ReadableStream({
+                type: "bytes", autoAllocateChunkSize: 65535,
+                start: c => { this.readController = c; },
+                pull: c => this.pull(c), cancel: () => this.stopRead(),
+            }, { highWaterMark: 0 });
+        const writable = new WritableStream({
+            start: c => {
+                this.writeController = c;
+                c.signal.addEventListener("abort", () => { void this.stopWrite().catch(error => this.fail(networkError(error))); }, { once: true });
+            },
+            write: value => this.write(value),
+            close: () => this.stopWrite(),
+            abort: () => this.stopWrite(),
+        });
+        return {
+            readable, writable,
+            get remoteAddress() { return endpoint(conn.remoteAddr).address; },
+            get remotePort() { return endpoint(conn.remoteAddr).port; },
+            get localAddress() { return endpoint(conn.localAddr).address; },
+            get localPort() { return endpoint(conn.localAddr).port; },
+        };
+    }
+    async pull(controller) {
+        if (this.readDone)
+            return;
+        this.reading = true;
+        try {
+            const request = "byobRequest" in controller ? controller.byobRequest : null;
+            const data = await this.conn.read(Math.min(request?.view?.byteLength ?? 65535, 65535));
+            if (this.readDone)
+                return;
+            if (data === null) {
+                this.readDone = true;
+                this.readStopped = true;
+                controller.close();
+                if (request)
+                    request.respond(0);
+                await this.finish();
+            }
+            else if ("byobRequest" in controller) {
+                if (!data.length)
+                    return;
+                if (request?.view) {
+                    new Uint8Array(request.view.buffer, request.view.byteOffset, request.view.byteLength).set(data);
+                    request.respond(data.length);
+                }
+                else
+                    controller.enqueue(data.slice());
+            }
+            else
+                controller.enqueue({ data: data.slice() });
+        }
+        catch (error) {
+            if (!this.readDone)
+                this.fail(networkError(error));
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async write(value) {
+        let data;
+        try {
+            if (this.udp) {
+                const message = value;
+                if (!message || typeof message !== "object")
+                    throw new TypeError("Expected UDPMessage");
+                if (message.remoteAddress !== undefined || message.remotePort !== undefined || message.dnsQueryType !== undefined)
+                    throw new TypeError("Connected UDP messages must not specify a destination");
+                data = copyBuffer(message.data);
+            }
+            else
+                data = copyBuffer(value);
+        }
+        catch (error) {
+            this.failed = true;
+            this.failure = error;
+            await this.stopWrite();
+            throw error;
+        }
+        this.writing = true;
+        try {
+            await this.conn.write(data);
+        }
+        catch (error) {
+            if (this.writeController.signal.aborted)
+                throw this.writeController.signal.reason;
+            const failure = networkError(error);
+            if (error && typeof error === "object" && "bytesWritten" in error)
+                Object.assign(failure, { bytesWritten: error.bytesWritten });
+            this.fail(failure);
+            throw failure;
+        }
+        finally {
+            this.writing = false;
+        }
+    }
+    stopRead() {
+        if (this.readStop)
+            return this.readStop;
+        if (this.readDone)
+            return this.finish();
+        this.readDone = true;
+        this.readStop = (async () => {
+            if (!this.udp)
+                await this.conn.closeRead();
+            else if (this.reading)
+                await this.conn.setReadDeadline(1);
+        })().then(() => { this.readStopped = true; return this.finish(); }, error => this.fail(networkError(error)));
+        return this.readStop;
+    }
+    stopWrite() {
+        if (this.writeStop)
+            return this.writeStop;
+        if (this.writeDone)
+            return this.finish();
+        this.writeDone = true;
+        this.writeStop = (async () => {
+            if (!this.udp)
+                await this.conn.closeWrite();
+            else if (this.writing)
+                await this.conn.setWriteDeadline(1);
+        })().then(() => { this.writeStopped = true; return this.finish(); }, error => this.fail(networkError(error)));
+        return this.writeStop;
+    }
+    fail(error) {
+        if (this.finishing)
+            return;
+        this.failed = true;
+        this.failure = error;
+        this.readDone = true;
+        this.writeDone = true;
+        this.readStopped = true;
+        this.writeStopped = true;
+        this.readController?.error(error);
+        this.writeController?.error(error);
+        void this.finish();
+    }
+    finish() {
+        if (!this.readDone || !this.writeDone || !this.readStopped || !this.writeStopped)
+            return Promise.resolve();
+        if (!this.finishing) {
+            this.finishing = Promise.resolve().then(() => this.conn.close()).then(() => {
+                this.settled = true;
+                if (this.failed)
+                    this.rejectClosed(this.failure);
+                else
+                    this.resolveClosed();
+            }, error => { this.settled = true; this.rejectClosed(networkError(error)); });
+        }
+        return this.finishing;
+    }
+    close() {
+        if (!this.info)
+            return Promise.reject(invalidState("Socket has not opened"));
+        if (this.settled)
+            return this.closed;
+        if (this.info.readable.locked || this.info.writable.locked)
+            return Promise.reject(invalidState("Release the reader and writer locks before closing the socket"));
+        void this.info.readable.cancel().catch(() => { });
+        void this.info.writable.abort().catch(() => { });
+        return this.closed;
+    }
+}
+function createDirectSockets(device) {
+    return Object.freeze({
+        TCPSocket: class TCPSocket extends DirectSocket {
+            constructor(remoteAddress, remotePort, options = {}) {
+                const protocol = network("tcp", options);
+                if (options.keepAliveDelay !== undefined) {
+                    if (uint(options.keepAliveDelay, 0xffffffff, "keepAliveDelay") < 1000)
+                        throw new TypeError("keepAliveDelay must be at least 1000 ms");
+                    unsupported("Per-socket TCP keep-alive is not supported by the Device");
+                }
+                if (options.noDelay !== undefined)
+                    unsupported("Per-socket noDelay is not supported by the Device");
+                super(device, protocol, destination(remoteAddress, remotePort), false);
+            }
+        },
+        UDPSocket: class UDPSocket extends DirectSocket {
+            constructor(options = {}) {
+                const protocol = network("udp", options);
+                if ((options.remoteAddress === undefined) !== (options.remotePort === undefined))
+                    throw new TypeError("remoteAddress and remotePort must be specified together");
+                if (options.localPort !== undefined && (options.localAddress === undefined || !uint(options.localPort, 65535, "localPort")))
+                    throw new TypeError("localPort requires localAddress and must be nonzero");
+                if (options.localAddress !== undefined) {
+                    if (options.remoteAddress !== undefined)
+                        throw new TypeError("Local and remote binding options cannot be combined");
+                    unsupported("Bound UDP sockets are reserved for the future listener API");
+                }
+                if (options.remoteAddress === undefined)
+                    throw new TypeError("Connected UDP requires remoteAddress and remotePort");
+                if (options.ipv6Only !== undefined)
+                    throw new TypeError("ipv6Only is only valid for bound UDP");
+                if (options.multicastTimeToLive !== undefined || options.multicastLoopback !== undefined || options.multicastAllowAddressSharing !== undefined)
+                    unsupported("Multicast sockets are not supported");
+                super(device, protocol, destination(options.remoteAddress, options.remotePort), true);
+            }
+        },
+    });
+}
+
+class SubprotocolSubscription {
+    constructor(bridge, handle, id, listener) {
+        this.active = true;
+        this.bridge = bridge;
+        this.handle = handle;
+        this.subprotocolId = id;
+        this.closed = this.receive(listener);
+        void this.closed.catch(() => { });
+    }
+    async receive(listener) {
+        try {
+            while (this.active) {
+                const message = await this.bridge.subprotocolOperation("receive", this.handle, null);
+                if (!this.active)
+                    break;
+                if (!(message.bytes instanceof Uint8Array))
+                    throw new TypeError("Invalid subprotocol frame from WASM");
+                await listener({ subprotocolId: this.subprotocolId, sourceClientId: message.sourceClientId, bytes: message.bytes.slice() });
+            }
+        }
+        catch (error) {
+            if (this.active)
+                throw error;
+        }
+        finally {
+            await this.close();
+        }
+    }
+    requireActive() {
+        if (!this.active)
+            throw new Error("Subprotocol subscription is closed");
+    }
+    async send(destinationClientId, bytes) {
+        this.requireActive();
+        if (!(bytes instanceof Uint8Array))
+            throw new TypeError("Expected Uint8Array");
+        if (bytes.length > 65535)
+            throw new RangeError("Subprotocol frame exceeds 65535 bytes");
+        return this.bridge.subprotocolOperation("send", this.handle, { destinationClientId, bytes: bytes.slice() });
+    }
+    async querySubprotocols(destinationClientId, timeoutMillis = 10000) {
+        this.requireActive();
+        if (!Number.isSafeInteger(timeoutMillis) || timeoutMillis < 1 || timeoutMillis > 60000)
+            throw new RangeError("timeoutMillis must be between 1 and 60000");
+        return this.bridge.subprotocolOperation("query", this.handle, { destinationClientId, timeoutMillis });
+    }
+    close() {
+        this.active = false;
+        this.release ?? (this.release = this.bridge.subprotocolOperation("release", this.handle, null));
+        return this.release;
+    }
+}
+function attachSubprotocolAPI(device) {
+    const bridge = device;
+    return Object.assign(device, {
+        async enableSubprotocol(id, listener) {
+            if (!Number.isInteger(id) || id < 1024 || id > 65535)
+                throw new RangeError("Application subprotocol id must be between 1024 and 65535");
+            if (typeof listener !== "function")
+                throw new TypeError("Expected subprotocol listener");
+            if (typeof bridge.subprotocolOperation !== "function")
+                throw new Error("Loaded WASM lacks subprotocol RPC support; rebuild the SDK");
+            const handle = await bridge.subprotocolOperation("open", 0, id);
+            return new SubprotocolSubscription(bridge, handle.id, id, listener);
+        },
+    });
+}
+
+const PointsLeaderboardTier = {
+    Unknown: 0,
+    Top1: 1,
+    Top5: 2,
+    Top10: 3,
+    Top25: 4,
+    Top50: 5,
+    Rest: 6,
+};
+
+const abortError = (signal) => {
+    if (signal.reason !== undefined) {
+        return signal.reason;
+    }
+    if (typeof DOMException !== "undefined") {
+        return new DOMException("This operation was aborted", "AbortError");
+    }
+    const error = new Error("This operation was aborted");
+    error.name = "AbortError";
+    return error;
+};
+const sleep = (millis, signal) => new Promise((resolve, reject) => {
+    if (!signal) {
+        setTimeout(resolve, millis);
+        return;
+    }
+    if (signal.aborted) {
+        reject(abortError(signal));
+        return;
+    }
+    const onAbort = () => {
+        clearTimeout(timer);
+        reject(abortError(signal));
+    };
+    const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+    }, millis);
+    signal.addEventListener("abort", onAbort, { once: true });
+});
+async function fetchWithGetRetry(input, init, options) {
+    const fetchImpl = globalThis.fetch;
+    const request = typeof Request !== "undefined" && input instanceof Request
+        ? input
+        : undefined;
+    const method = (init?.method ?? request?.method ?? "GET").toUpperCase();
+    if (method !== "GET") {
+        return fetchImpl(input, init);
+    }
+    const signal = init?.signal ?? request?.signal ?? undefined;
+    const retryCount = 1;
+    const retryStatusCodes = [502, 503];
+    const retryMinTimeoutMillis = 100;
+    const retryMaxTimeoutMillis = 1000;
+    const maxAttempt = Math.max(0, retryCount);
+    let lastResponse;
+    let lastError;
+    for (let attempt = 0; attempt <= maxAttempt; attempt += 1) {
+        if (0 < attempt) {
+            const jitter = retryMinTimeoutMillis +
+                Math.random() *
+                    Math.max(0, retryMaxTimeoutMillis - retryMinTimeoutMillis);
+            await sleep(jitter, signal);
+        }
+        try {
+            const response = await fetchImpl(input, init);
+            if (!retryStatusCodes.includes(response.status)) {
+                return response;
+            }
+            lastResponse = response;
+            lastError = undefined;
+            if (attempt < maxAttempt) {
+                try {
+                    await response.body?.cancel();
+                }
+                catch {
+                }
+            }
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    if (lastError !== undefined) {
+        throw lastError;
+    }
+    return lastResponse;
+}
+
+class URNetworkAPI {
+    constructor(config) {
+        this.baseURL = config?.baseURL || "https://api.bringyour.com";
+    }
+    async safeJsonParse(response) {
+        const contentType = response.headers.get("content-type");
+        if (response.status === 204) {
+            return {};
+        }
+        if (contentType && contentType.includes("application/json")) {
+            try {
+                const text = await response.text();
+                if (!text || text.trim() === "") {
+                    return {};
+                }
+                return JSON.parse(text);
+            }
+            catch (error) {
+                console.error("JSON parse error:", error);
+                throw new Error("Failed to parse response as JSON");
+            }
+        }
+        const text = await response.text();
+        throw new Error(`Expected JSON response but got: ${text.substring(0, 100)}`);
+    }
+    async authLogin(params) {
+        try {
+            const response = await fetch(`${this.baseURL}/auth/login`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    user_auth: params.user_auth,
+                    auth_jwt_type: params.auth_jwt_type,
+                    auth_jwt: params.auth_jwt,
+                    wallet_auth: params.wallet_auth,
+                }),
+            });
+            if (!response.ok) {
+                console.error("Password login failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    error: {
+                        message: `HTTP error! status: ${response.status}`,
+                    },
+                };
+            }
+            const data = await this.safeJsonParse(response);
+            return data;
+        }
+        catch (error) {
+            console.error("Login error:", error);
+            return {
+                error: {
+                    message: error instanceof Error ? error.message : "Authentication failed",
+                },
+            };
+        }
+    }
+    async authLoginWithPassword(params) {
+        try {
+            const response = await fetch(`${this.baseURL}/auth/login-with-password`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    user_auth: params.user_auth,
+                    password: params.password,
+                }),
+            });
+            if (!response.ok) {
+                console.error("Password login failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    error: {
+                        message: `HTTP error! status: ${response.status}`,
+                    },
+                };
+            }
+            const data = await this.safeJsonParse(response);
+            return data;
+        }
+        catch (error) {
+            console.error("Password login error:", error);
+            return {
+                error: {
+                    message: error instanceof Error
+                        ? error.message
+                        : "Password authentication failed",
+                },
+            };
+        }
+    }
+    async networkCheck(params) {
+        try {
+            const response = await fetch(`${this.baseURL}/auth/network-check`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    network_name: params.network_name,
+                }),
+            });
+            if (!response.ok) {
+                console.error("Network check failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return undefined;
+            }
+            return await this.safeJsonParse(response);
+        }
+        catch (error) {
+            console.error("Network check error:", error);
+            return undefined;
+        }
+    }
+    async networkCreate(params) {
+        try {
+            if (!params.terms) {
+                return {
+                    error: {
+                        message: "Terms must be accepted to create a network.",
+                    },
+                };
+            }
+            let requestParams = {
+                terms: params.terms,
+                guest_mode: false,
+            };
+            if (params.user_auth && params.password) {
+                requestParams.user_auth = params.user_auth;
+                requestParams.password = params.password;
+            }
+            if (params.auth_jwt && params.auth_jwt_type) {
+                requestParams.auth_jwt = params.auth_jwt;
+                requestParams.auth_jwt_type = params.auth_jwt_type;
+            }
+            if (params.wallet_auth) {
+                requestParams.wallet_auth = params.wallet_auth;
+            }
+            const response = await fetch(`${this.baseURL}/network/create`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(requestParams),
+            });
+            if (!response.ok) {
+                console.error("Network creation failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    error: {
+                        message: `HTTP error! status: ${response.status}`,
+                    },
+                };
+            }
+            const data = await this.safeJsonParse(response);
+            return data;
+        }
+        catch (error) {
+            console.error("Network creation error:", error);
+            return {
+                error: {
+                    message: error instanceof Error ? error.message : "Network creation failed",
+                },
+            };
+        }
+    }
+    async authCodeLogin(params) {
+        try {
+            const response = await fetch(`${this.baseURL}/auth/code-login`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(params),
+            });
+            if (!response.ok) {
+                console.error("Auth code login failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    by_jwt: "",
+                    error: {
+                        message: errorData,
+                    },
+                };
+            }
+            return await this.safeJsonParse(response);
+        }
+        catch (error) {
+            console.error("Network check error:", error);
+            return {
+                by_jwt: "",
+                error: {
+                    message: error instanceof Error ? error.message : "Auth code login failed",
+                },
+            };
+        }
+    }
+    async networkProviderLocations() {
+        try {
+            const response = await fetchWithGetRetry(`${this.baseURL}/network/provider-locations`, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            });
+            if (!response.ok) {
+                console.error("/network/provider-locations failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                throw new Error(`Failed to fetch provider locations: ${response.status} ${response.statusText}`);
+            }
+            const data = await this.safeJsonParse(response);
+            return data;
+        }
+        catch (error) {
+            console.error("User auth verification error:", error);
+            throw error;
+        }
+    }
+    async searchProviderLocations(params) {
+        try {
+            const response = await fetch(`${this.baseURL}/network/find-provider-locations`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(params),
+            });
+            if (!response.ok) {
+                console.error("network/find-provider-locations failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                throw new Error(`Failed to search provider locations: ${response.status} ${response.statusText}`);
+            }
+            return await this.safeJsonParse(response);
+        }
+        catch (error) {
+            console.error("network/find-provider-locations error:", error);
+            throw error;
+        }
+    }
+    async verifyUserAuth(params, adminToken) {
+        try {
+            const response = await fetch(`${this.baseURL}/auth/verify`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${adminToken}`,
+                },
+                body: JSON.stringify({
+                    user_auth: params.user_auth,
+                    verify_code: params.verify_code,
+                }),
+            });
+            if (!response.ok) {
+                console.error("User auth verification failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    error: {
+                        message: `HTTP error! status: ${response.status}`,
+                    },
+                };
+            }
+            const data = await this.safeJsonParse(response);
+            return data;
+        }
+        catch (error) {
+            console.error("User auth verification error:", error);
+            return {
+                error: {
+                    message: error instanceof Error ? error.message : "Verification failed",
+                },
+            };
+        }
+    }
+    async authNetworkClient(params, token, signal) {
+        try {
+            const response = await fetch(`${this.baseURL}/network/auth-client`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(params),
+                signal,
+            });
+            if (!response.ok) {
+                console.error("Auth network client failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    proxy_config_result: null,
+                    error: {
+                        message: `HTTP error! status: ${response.status}`,
+                        client_limit_exceeded: false,
+                    },
+                };
+            }
+            return await this.safeJsonParse(response);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                console.log("Auth network client request was cancelled");
+                throw error;
+            }
+            console.error("Auth network client error:", error);
+            return {
+                proxy_config_result: null,
+                error: {
+                    message: error instanceof Error
+                        ? error.message
+                        : "Auth network client failed",
+                    client_limit_exceeded: false,
+                },
+            };
+        }
+    }
+    async removeNetworkClient(params, token) {
+        try {
+            const response = await fetch(`${this.baseURL}/network/remove-client`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(params),
+            });
+            if (!response.ok) {
+                console.error("Network removed client failed failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    error: {
+                        message: `HTTP error! status: ${response.status}`,
+                    },
+                };
+            }
+            const data = await this.safeJsonParse(response);
+            return data;
+        }
+        catch (error) {
+            console.error("Remove network client error:", error);
+            return {
+                error: {
+                    message: error instanceof Error
+                        ? error.message
+                        : "Remove network client failed",
+                },
+            };
+        }
+    }
+    async createApiKey(params, token) {
+        try {
+            const response = await fetch(`${this.baseURL}/account/api-key`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(params),
+            });
+            if (!response.ok) {
+                console.error("Create API key failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    error: {
+                        message: `HTTP error! status: ${response.status}`,
+                    },
+                };
+            }
+            return await this.safeJsonParse(response);
+        }
+        catch (error) {
+            console.error("Create API key error:", error);
+            return {
+                error: {
+                    message: error instanceof Error ? error.message : "Create API key failed",
+                },
+            };
+        }
+    }
+    async listApiKeys(token) {
+        try {
+            const response = await fetchWithGetRetry(`${this.baseURL}/account/api-keys`, {
+                method: "GET",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            if (!response.ok) {
+                console.error("List API keys failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    error: {
+                        message: `HTTP error! status: ${response.status}`,
+                    },
+                };
+            }
+            const data = await this.safeJsonParse(response);
+            return data;
+        }
+        catch (error) {
+            console.error("List API keys error:", error);
+            return {
+                error: {
+                    message: error instanceof Error ? error.message : "List API keys failed",
+                },
+            };
+        }
+    }
+    async deleteApiKey(params, token) {
+        try {
+            const response = await fetch(`${this.baseURL}/account/api-key/remove`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(params),
+            });
+            if (!response.ok) {
+                console.error("Delete API key failed:", response.status, response.statusText);
+                const errorData = await response.text();
+                console.error("Error response:", errorData);
+                return {
+                    error: {
+                        message: `HTTP error! status: ${response.status}`,
+                    },
+                };
+            }
+            return await this.safeJsonParse(response);
+        }
+        catch (error) {
+            console.error("Delete API key error:", error);
+            return {
+                error: {
+                    message: error instanceof Error ? error.message : "Delete API key failed",
+                },
+            };
+        }
+    }
+}
+
+function parseByJwtClientId(byJwt) {
+    try {
+        const parts = byJwt.split(".");
+        if (parts.length !== 3) {
+            throw new Error("Invalid JWT format: expected 3 parts separated by dots");
+        }
+        const payload = parts[1];
+        const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+        const jsonPayload = decodeURIComponent(atob(base64)
+            .split("")
+            .map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2))
+            .join(""));
+        const claims = JSON.parse(jsonPayload);
+        if (!claims.client_id) {
+            throw new Error("byJwt does not contain claim client_id");
+        }
+        if (typeof claims.client_id !== "string") {
+            throw new Error(`byJwt have invalid type for client_id: ${typeof claims.client_id}`);
+        }
+        if (!isValidUUID(claims.client_id)) {
+            throw new Error(`client_id is not a valid UUID: ${claims.client_id}`);
+        }
+        return claims.client_id;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new Error(`Failed to parse JWT: ${String(error)}`);
+    }
+}
+function isValidUUID(str) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(str);
+}
+function parseJWTClaims(jwt) {
+    try {
+        const parts = jwt.split(".");
+        if (parts.length !== 3) {
+            throw new Error("Invalid JWT format: expected 3 parts separated by dots");
+        }
+        const payload = parts[1];
+        const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+        const jsonPayload = decodeURIComponent(atob(base64)
+            .split("")
+            .map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2))
+            .join(""));
+        return JSON.parse(jsonPayload);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw new Error(`Failed to parse JWT: ${String(error)}`);
+    }
+}
+
+const SOLANA_PAY_REFERENCE_BYTES = 32;
+const B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function encodeBase58(bytes) {
+    if (bytes.length === 0)
+        return "";
+    const digits = [0];
+    for (const byte of bytes) {
+        let carry = byte;
+        for (let i = 0; i < digits.length; i++) {
+            carry += digits[i] << 8;
+            digits[i] = carry % 58;
+            carry = (carry / 58) | 0;
+        }
+        while (carry > 0) {
+            digits.push(carry % 58);
+            carry = (carry / 58) | 0;
+        }
+    }
+    while (digits.length > 0 && digits[digits.length - 1] === 0)
+        digits.pop();
+    let out = "";
+    for (let i = 0; i < bytes.length && bytes[i] === 0; i++)
+        out += B58_ALPHABET[0];
+    for (let i = digits.length - 1; i >= 0; i--)
+        out += B58_ALPHABET[digits[i]];
+    return out;
+}
+function decodeBase58(s) {
+    if (s.length === 0)
+        return new Uint8Array(0);
+    const bytes = [0];
+    for (const ch of s) {
+        const value = B58_ALPHABET.indexOf(ch);
+        if (value < 0)
+            return null;
+        let carry = value;
+        for (let i = 0; i < bytes.length; i++) {
+            carry += bytes[i] * 58;
+            bytes[i] = carry & 0xff;
+            carry >>= 8;
+        }
+        while (carry > 0) {
+            bytes.push(carry & 0xff);
+            carry >>= 8;
+        }
+    }
+    while (bytes.length > 0 && bytes[bytes.length - 1] === 0)
+        bytes.pop();
+    let leadingZeros = 0;
+    for (let i = 0; i < s.length && s[i] === B58_ALPHABET[0]; i++)
+        leadingZeros++;
+    const out = new Uint8Array(leadingZeros + bytes.length);
+    for (let i = 0; i < bytes.length; i++)
+        out[leadingZeros + i] = bytes[bytes.length - 1 - i];
+    return out;
+}
+function createPaymentReference() {
+    const bytes = new Uint8Array(SOLANA_PAY_REFERENCE_BYTES);
+    crypto.getRandomValues(bytes);
+    return encodeBase58(bytes);
+}
+function isValidPaymentReference(s) {
+    if (!s)
+        return false;
+    const decoded = decodeBase58(s);
+    return decoded !== null && decoded.length === SOLANA_PAY_REFERENCE_BYTES;
+}
+function isBase58Address(s) {
+    if (!s)
+        return false;
+    const decoded = decodeBase58(s);
+    return decoded !== null && decoded.length === SOLANA_PAY_REFERENCE_BYTES;
+}
+function buildSolanaPaymentUrl(args) {
+    if (!args)
+        throw new Error("solana pay: no arguments");
+    if (!isBase58Address(args.recipient)) {
+        throw new Error("solana pay: recipient is not a base58 address");
+    }
+    if (!isBase58Address(args.splTokenMint)) {
+        throw new Error("solana pay: spl token mint is not a base58 address");
+    }
+    if (!isValidPaymentReference(args.reference)) {
+        throw new Error(`solana pay: reference must be base58 that decodes to ${SOLANA_PAY_REFERENCE_BYTES} bytes`);
+    }
+    if (!Number.isFinite(args.amountUsd) || args.amountUsd <= 0) {
+        throw new Error(`solana pay: amount must be positive, got ${args.amountUsd}`);
+    }
+    const params = new URLSearchParams({
+        amount: formatAmount(args.amountUsd),
+        "spl-token": args.splTokenMint,
+        reference: args.reference,
+    });
+    if (args.label)
+        params.set("label", args.label);
+    if (args.message)
+        params.set("message", args.message);
+    if (args.memo)
+        params.set("memo", args.memo);
+    return `solana:${args.recipient}?${params.toString()}`;
+}
+function formatAmount(n) {
+    const s = String(n);
+    if (!/[eE]/.test(s))
+        return s;
+    const [mantissa, expPart] = s.split(/[eE]/);
+    const exp = parseInt(expPart, 10);
+    const negative = mantissa.startsWith("-");
+    const unsigned = negative ? mantissa.slice(1) : mantissa;
+    const dot = unsigned.indexOf(".");
+    const digits = unsigned.replace(".", "");
+    const pointPos = (dot < 0 ? unsigned.length : dot) + exp;
+    let out;
+    if (pointPos <= 0) {
+        out = "0." + "0".repeat(-pointPos) + digits;
+    }
+    else if (pointPos >= digits.length) {
+        out = digits + "0".repeat(pointPos - digits.length);
+    }
+    else {
+        out = digits.slice(0, pointPos) + "." + digits.slice(pointPos);
+    }
+    return (negative ? "-" : "") + out;
+}
+
+class URNetwork {
+    constructor() { }
+    static async init(options = {}) {
+        if (URNetwork.instance) {
+            return URNetwork.instance;
+        }
+        await initWasm(options);
+        const instance = new URNetwork();
+        URNetwork.instance = instance;
+        return instance;
+    }
+    static getInstance() {
+        if (!URNetwork.instance) {
+            throw new Error("SDK not initialized. Call URNetwork.init() first.");
+        }
+        return URNetwork.instance;
+    }
+    createProxyDevice(config, setupCallback) {
+        const { URnetworkNewProxyDeviceWithDefaults } = getWasmGlobals();
+        const proxy = URnetworkNewProxyDeviceWithDefaults(config, setupCallback
+            ? (device, result) => setupCallback(attachSocketAPI(device), result)
+            : undefined);
+        const getDevice = proxy.getDevice.bind(proxy);
+        proxy.getDevice = () => attachSocketAPI(getDevice());
+        return proxy;
+    }
+    createPlatformDeviceRemote(options) {
+        const { URnetworkNewPlatformDeviceRemote } = getWasmGlobals();
+        if (typeof URnetworkNewPlatformDeviceRemote !== "function") {
+            throw new Error("URnetworkNewPlatformDeviceRemote is not exported by the loaded wasm. Rebuild the sdk wasm.");
+        }
+        const device = URnetworkNewPlatformDeviceRemote(options.apiUrl, options.platformUrl, options.byJwt, options.proxyUrl, options.signedProxyId, options.instanceId);
+        if (!device) {
+            throw new Error("Could not create the device remote.");
+        }
+        if (device.error) {
+            throw new Error(String(device.error));
+        }
+        return attachSubprotocolAPI(attachSocketAPI(device));
+    }
+    createLocationsViewController(options) {
+        const { URnetworkNewLocationsViewController } = getWasmGlobals();
+        if (typeof URnetworkNewLocationsViewController !== "function") {
+            throw new Error("URnetworkNewLocationsViewController is not exported by the loaded wasm. Rebuild the sdk wasm.");
+        }
+        const vc = URnetworkNewLocationsViewController(options.apiUrl, options.platformUrl, options.byJwt);
+        if (!vc) {
+            throw new Error("Could not open the locations view controller.");
+        }
+        if (vc.error) {
+            throw new Error(String(vc.error));
+        }
+        return vc;
+    }
+    createAccountHost(options) {
+        const { URnetworkNewAccountHost } = getWasmGlobals();
+        if (typeof URnetworkNewAccountHost !== "function") {
+            throw new Error("URnetworkNewAccountHost is not exported by the loaded wasm. Rebuild the sdk wasm.");
+        }
+        const host = URnetworkNewAccountHost(options.apiUrl, options.platformUrl, options.byJwt);
+        if (!host) {
+            throw new Error("Could not open the account host.");
+        }
+        if (host.error) {
+            throw new Error(String(host.error));
+        }
+        return host;
+    }
+    colorHex(code) {
+        const { URnetworkColorHex } = getWasmGlobals();
+        if (typeof URnetworkColorHex !== "function") {
+            return "";
+        }
+        return String(URnetworkColorHex(code) || "");
+    }
+    createExtensionDeviceRemote(options) {
+        const { URnetworkNewExtensionDeviceRemote } = getWasmGlobals();
+        if (typeof URnetworkNewExtensionDeviceRemote !== "function") {
+            throw new Error("URnetworkNewExtensionDeviceRemote is not exported by the loaded wasm. Rebuild the sdk wasm.");
+        }
+        const device = URnetworkNewExtensionDeviceRemote(options.apiUrl, options.platformUrl, options.byJwt, options.instanceId, options.transport);
+        if (!device) {
+            throw new Error("Could not create the extension device remote.");
+        }
+        if (device.error) {
+            throw new Error(String(device.error));
+        }
+        return attachSubprotocolAPI(attachSocketAPI(device));
+    }
+    close() {
+        const { URnetworkClose } = getWasmGlobals();
+        URnetworkClose();
+        URNetwork.instance = null;
+    }
+    isInitialized() {
+        return isWasmInitialized();
+    }
+}
+URNetwork.instance = null;
+
+export { Conn, PointsLeaderboardTier, SOLANA_PAY_REFERENCE_BYTES, SubprotocolSubscription, URNetwork, URNetworkAPI, attachSocketAPI, attachSubprotocolAPI, buildSolanaPaymentUrl, createDirectSockets, createPaymentReference, decodeBase58, URNetwork as default, encodeBase58, isBase58Address, isValidPaymentReference, parseByJwtClientId, parseJWTClaims };
+//# sourceMappingURL=index.js.map