@byoky/sdk 0.3.0 → 0.4.1

package/dist/index.d.cts

@@ -23,16 +23,31 @@ interface ByokySession extends ConnectResponse {
 }
 interface ByokyOptions {
     timeout?: number;
+    /** Relay server URL for mobile wallet pairing. Default: wss://relay.byoky.com */
+    relayUrl?: string;
 }
 declare class Byoky {
     private timeout;
+    private relayUrl;
     constructor(options?: ByokyOptions);
-    connect(request?: ConnectRequest): Promise<ByokySession>;
+    /**
+     * Connect to a Byoky wallet. Tries the browser extension first.
+     * If no extension is found and `onPairingReady` is provided,
+     * falls back to relay mode — pairing with a mobile wallet app.
+     */
+    connect(request?: ConnectRequest & {
+        /** Called with a pairing code when no extension is detected. Show as QR or text. */
+        onPairingReady?: (pairingCode: string) => void;
+        /** Skip extension detection and go directly to relay pairing. */
+        useRelay?: boolean;
+    }): Promise<ByokySession>;
     /**
      * Reconnect to an existing session using previously stored response data.
      * Returns null if the session is no longer valid.
      */
     reconnect(savedResponse: ConnectResponse): Promise<ByokySession | null>;
+    private connectViaRelay;
+    private buildRelaySession;
     private buildSession;
     private sendConnectRequest;
     private sendDisconnect;

package/dist/index.d.ts

@@ -23,16 +23,31 @@ interface ByokySession extends ConnectResponse {
 }
 interface ByokyOptions {
     timeout?: number;
+    /** Relay server URL for mobile wallet pairing. Default: wss://relay.byoky.com */
+    relayUrl?: string;
 }
 declare class Byoky {
     private timeout;
+    private relayUrl;
     constructor(options?: ByokyOptions);
-    connect(request?: ConnectRequest): Promise<ByokySession>;
+    /**
+     * Connect to a Byoky wallet. Tries the browser extension first.
+     * If no extension is found and `onPairingReady` is provided,
+     * falls back to relay mode — pairing with a mobile wallet app.
+     */
+    connect(request?: ConnectRequest & {
+        /** Called with a pairing code when no extension is detected. Show as QR or text. */
+        onPairingReady?: (pairingCode: string) => void;
+        /** Skip extension detection and go directly to relay pairing. */
+        useRelay?: boolean;
+    }): Promise<ByokySession>;
     /**
      * Reconnect to an existing session using previously stored response data.
      * Returns null if the session is no longer valid.
      */
     reconnect(savedResponse: ConnectResponse): Promise<ByokySession | null>;
+    private connectViaRelay;
+    private buildRelaySession;
     private buildSession;
     private sendConnectRequest;
     private sendDisconnect;

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/byoky.ts
-import { ByokyError as ByokyError2, ByokyErrorCode } from "@byoky/core";
+import { ByokyError as ByokyError2, ByokyErrorCode, encodePairPayload } from "@byoky/core";
 
 // src/detect.ts
 import { BYOKY_PROVIDER_KEY } from "@byoky/core";
@@ -38,8 +38,9 @@ function createProxyFetch(providerId, sessionKey) {
         cleanup();
         reject(new Error("Proxy request timed out"));
       }, 12e4);
-      function handleEvent(event) {
-        const data = event.detail ?? event.data;
+      const channel = new MessageChannel();
+      channel.port1.onmessage = (event) => {
+        const data = event.data;
         if (data?.requestId !== requestId) return;
         switch (data.type) {
           case "BYOKY_PROXY_RESPONSE_META":
@@ -83,12 +84,11 @@ function createProxyFetch(providerId, sessionKey) {
             break;
           }
         }
-      }
+      };
       function cleanup() {
         clearTimeout(timeout);
-        document.removeEventListener("byoky-message", handleEvent);
+        channel.port1.close();
       }
-      document.addEventListener("byoky-message", handleEvent);
       window.postMessage(
         {
           type: "BYOKY_PROXY_REQUEST",
@@ -100,7 +100,8 @@ function createProxyFetch(providerId, sessionKey) {
           headers,
           body
         },
-        "*"
+        window.location.origin,
+        [channel.port2]
       );
     });
   };
@@ -130,6 +131,115 @@ async function readBody(body) {
   return void 0;
 }
 
+// src/relay-fetch.ts
+function createRelayFetch(ws, providerId) {
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = init?.method ?? "GET";
+    const headers = init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : {};
+    const body = init?.body ? await readBody2(init.body) : void 0;
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const { readable, writable } = new TransformStream();
+      const writer = writable.getWriter();
+      const encoder = new TextEncoder();
+      let resolved = false;
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error("Relay proxy request timed out"));
+      }, 12e4);
+      function handleMessage(event) {
+        let data;
+        try {
+          data = JSON.parse(event.data);
+        } catch {
+          return;
+        }
+        if (data.requestId !== requestId) return;
+        switch (data.type) {
+          case "relay:response:meta":
+            if (!resolved) {
+              resolved = true;
+              clearTimeout(timeout);
+              resolve(
+                new Response(readable, {
+                  status: data.status,
+                  statusText: data.statusText ?? "",
+                  headers: new Headers(data.headers)
+                })
+              );
+            }
+            break;
+          case "relay:response:chunk":
+            writer.write(encoder.encode(data.chunk)).catch(() => {
+            });
+            break;
+          case "relay:response:done":
+            writer.close().catch(() => {
+            });
+            cleanup();
+            break;
+          case "relay:response:error": {
+            const err = data.error;
+            const message = typeof err === "string" ? err : err?.message ?? "Relay proxy error";
+            const errResponse = new Response(
+              JSON.stringify({ error: { message, code: typeof err === "object" ? err?.code : "RELAY_ERROR" } }),
+              { status: 500, headers: { "content-type": "application/json" } }
+            );
+            if (!resolved) {
+              resolved = true;
+              clearTimeout(timeout);
+              resolve(errResponse);
+            }
+            writer.close().catch(() => {
+            });
+            cleanup();
+            break;
+          }
+        }
+      }
+      function cleanup() {
+        clearTimeout(timeout);
+        ws.removeEventListener("message", handleMessage);
+      }
+      ws.addEventListener("message", handleMessage);
+      ws.send(JSON.stringify({
+        type: "relay:request",
+        requestId,
+        providerId,
+        url,
+        method,
+        headers,
+        body
+      }));
+    });
+  };
+}
+async function readBody2(body) {
+  if (typeof body === "string") return body;
+  if (body instanceof ArrayBuffer) return new TextDecoder().decode(body);
+  if (body instanceof Blob) return body.text();
+  if (body instanceof URLSearchParams) return body.toString();
+  if (body instanceof ReadableStream) {
+    const reader = body.getReader();
+    const chunks = [];
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const total = chunks.reduce((acc, c) => acc + c.length, 0);
+    const combined = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return new TextDecoder().decode(combined);
+  }
+  return void 0;
+}
+
 // src/relay-client.ts
 import {
   ByokyError,
@@ -145,7 +255,7 @@ function createRelayClient(wsUrl, sessionKey, providers) {
   try {
     const parsed = new URL(wsUrl);
     const isSecure = parsed.protocol === "wss:";
-    const isLocalWs = parsed.protocol === "ws:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1");
+    const isLocalWs = parsed.protocol === "ws:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]");
     if (!isSecure && !isLocalWs) {
       status = "disconnected";
       return {
@@ -316,9 +426,16 @@ function createRelayClient(wsUrl, sessionKey, providers) {
 // src/byoky.ts
 var Byoky = class {
   timeout;
+  relayUrl;
   constructor(options = {}) {
     this.timeout = options.timeout ?? 6e4;
+    this.relayUrl = options.relayUrl ?? "wss://relay.byoky.com";
   }
+  /**
+   * Connect to a Byoky wallet. Tries the browser extension first.
+   * If no extension is found and `onPairingReady` is provided,
+   * falls back to relay mode — pairing with a mobile wallet app.
+   */
   async connect(request = {}) {
     if (typeof window === "undefined") {
       throw new ByokyError2(
@@ -326,15 +443,22 @@ var Byoky = class {
         "Byoky SDK requires a browser environment. On the server, use your API key directly."
       );
     }
-    if (!isExtensionInstalled()) {
-      const storeUrl = getStoreUrl();
-      if (storeUrl) {
-        window.open(storeUrl, "_blank");
-      }
-      throw ByokyError2.walletNotInstalled();
+    const { onPairingReady, useRelay, ...connectRequest } = request;
+    if (useRelay && onPairingReady) {
+      return this.connectViaRelay(connectRequest, onPairingReady);
+    }
+    if (isExtensionInstalled()) {
+      const response = await this.sendConnectRequest(connectRequest);
+      return this.buildSession(response);
+    }
+    if (onPairingReady) {
+      return this.connectViaRelay(connectRequest, onPairingReady);
     }
-    const response = await this.sendConnectRequest(request);
-    return this.buildSession(response);
+    const storeUrl = getStoreUrl();
+    if (storeUrl) {
+      window.open(storeUrl, "_blank");
+    }
+    throw ByokyError2.walletNotInstalled();
   }
   /**
    * Reconnect to an existing session using previously stored response data.
@@ -347,24 +471,139 @@ var Byoky = class {
     if (!connected) return null;
     return this.buildSession(savedResponse);
   }
+  // --- Relay pairing ---
+  connectViaRelay(request, onPairingReady) {
+    return new Promise((resolve, reject) => {
+      const roomId = crypto.randomUUID();
+      const authToken = Array.from(crypto.getRandomValues(new Uint8Array(32))).map((b) => b.toString(16).padStart(2, "0")).join("");
+      const pairingCode = encodePairPayload({
+        v: 1,
+        r: this.relayUrl,
+        id: roomId,
+        t: authToken,
+        o: window.location.origin
+      });
+      const ws = new WebSocket(this.relayUrl);
+      const timeout = setTimeout(() => {
+        ws.close();
+        reject(new ByokyError2(ByokyErrorCode.UNKNOWN, "Pairing timed out. No wallet connected."));
+      }, this.timeout);
+      ws.onopen = () => {
+        ws.send(JSON.stringify({
+          type: "relay:auth",
+          roomId,
+          authToken,
+          role: "recipient"
+        }));
+      };
+      ws.onmessage = (event) => {
+        let msg;
+        try {
+          msg = JSON.parse(event.data);
+        } catch {
+          return;
+        }
+        switch (msg.type) {
+          case "relay:auth:result":
+            if (msg.success) {
+              onPairingReady(pairingCode);
+            } else {
+              clearTimeout(timeout);
+              ws.close();
+              reject(new ByokyError2(ByokyErrorCode.UNKNOWN, `Relay auth failed: ${msg.error}`));
+            }
+            break;
+          case "relay:pair:hello": {
+            clearTimeout(timeout);
+            const providers = msg.providers;
+            ws.send(JSON.stringify({ type: "relay:pair:ack" }));
+            resolve(this.buildRelaySession(ws, roomId, providers));
+            break;
+          }
+          case "relay:peer:status":
+            break;
+        }
+      };
+      ws.onerror = () => {
+        clearTimeout(timeout);
+        reject(new ByokyError2(ByokyErrorCode.UNKNOWN, "Failed to connect to relay server"));
+      };
+      ws.onclose = () => {
+        clearTimeout(timeout);
+      };
+    });
+  }
+  buildRelaySession(ws, roomId, providers) {
+    const sessionKey = `relay_${roomId}`;
+    const disconnectCallbacks = /* @__PURE__ */ new Set();
+    const pingInterval = setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: "relay:ping", ts: Date.now() }));
+      }
+    }, 3e4);
+    ws.addEventListener("close", () => {
+      clearInterval(pingInterval);
+      for (const cb of disconnectCallbacks) cb();
+      disconnectCallbacks.clear();
+    });
+    ws.addEventListener("message", (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        if (msg.type === "relay:peer:status" && msg.online === false) {
+          for (const cb of disconnectCallbacks) cb();
+          disconnectCallbacks.clear();
+          clearInterval(pingInterval);
+          ws.close(1e3, "Phone disconnected");
+        }
+      } catch {
+      }
+    });
+    return {
+      sessionKey,
+      proxyUrl: "",
+      providers,
+      createFetch: (providerId) => createRelayFetch(ws, providerId),
+      createRelay: () => {
+        throw new Error("Relay-in-relay not supported");
+      },
+      disconnect: () => {
+        clearInterval(pingInterval);
+        ws.close(1e3, "Client disconnected");
+      },
+      isConnected: async () => ws.readyState === WebSocket.OPEN,
+      getUsage: async () => ({ requests: 0, inputTokens: 0, outputTokens: 0, byProvider: {} }),
+      onDisconnect: (callback) => {
+        disconnectCallbacks.add(callback);
+        return () => {
+          disconnectCallbacks.delete(callback);
+        };
+      }
+    };
+  }
+  // --- Extension-based session ---
   buildSession(response) {
     const sessionKey = response.sessionKey;
     const disconnectCallbacks = /* @__PURE__ */ new Set();
-    function handleRevocation(event) {
-      const msg = event.detail;
+    const notifyChannel = new MessageChannel();
+    notifyChannel.port1.onmessage = (event) => {
+      const msg = event.data;
       if (msg?.type === "BYOKY_SESSION_REVOKED" && msg.payload?.sessionKey === sessionKey) {
         for (const cb of disconnectCallbacks) cb();
         disconnectCallbacks.clear();
-        document.removeEventListener("byoky-message", handleRevocation);
+        notifyChannel.port1.close();
       }
-    }
-    document.addEventListener("byoky-message", handleRevocation);
+    };
+    window.postMessage(
+      { type: "BYOKY_REGISTER_NOTIFY" },
+      window.location.origin,
+      [notifyChannel.port2]
+    );
     return {
       ...response,
       createFetch: (providerId) => createProxyFetch(providerId, sessionKey),
       createRelay: (wsUrl) => createRelayClient(wsUrl, sessionKey, response.providers),
       disconnect: () => {
-        document.removeEventListener("byoky-message", handleRevocation);
+        notifyChannel.port1.close();
         this.sendDisconnect(sessionKey);
       },
       isConnected: () => this.querySessionStatus(sessionKey),
@@ -386,8 +625,9 @@ var Byoky = class {
           new ByokyError2(ByokyErrorCode.UNKNOWN, "Connection request timed out")
         );
       }, this.timeout);
-      function handleEvent(event) {
-        const msg = event.detail;
+      const channel = new MessageChannel();
+      channel.port1.onmessage = (event) => {
+        const msg = event.data;
         if (typeof msg?.type !== "string" || !msg.type.startsWith("BYOKY_")) return;
         if (msg.requestId !== requestId) return;
         cleanup();
@@ -397,12 +637,11 @@ var Byoky = class {
           const { code, message } = msg.payload;
           reject(new ByokyError2(code, message));
         }
-      }
+      };
       function cleanup() {
         clearTimeout(timeoutId);
-        document.removeEventListener("byoky-message", handleEvent);
+        channel.port1.close();
       }
-      document.addEventListener("byoky-message", handleEvent);
       window.postMessage(
         {
           type: "BYOKY_CONNECT_REQUEST",
@@ -410,14 +649,15 @@ var Byoky = class {
           requestId,
           payload: request
         },
-        "*"
+        window.location.origin,
+        [channel.port2]
       );
     });
   }
   sendDisconnect(sessionKey) {
     window.postMessage(
       { type: "BYOKY_DISCONNECT", payload: { sessionKey } },
-      "*"
+      window.location.origin
     );
   }
   querySessionStatus(sessionKey) {
@@ -427,24 +667,24 @@ var Byoky = class {
         cleanup();
         resolve(false);
       }, 5e3);
-      function handleEvent(event) {
-        const msg = event.detail;
+      const channel = new MessageChannel();
+      channel.port1.onmessage = (event) => {
+        const msg = event.data;
         if (msg?.requestId !== requestId) return;
         if (msg.type === "BYOKY_SESSION_STATUS_RESPONSE") {
           cleanup();
           resolve(!!msg.payload?.connected);
         }
-      }
+      };
       function cleanup() {
         clearTimeout(timeout);
-        document.removeEventListener("byoky-message", handleEvent);
+        channel.port1.close();
       }
-      document.addEventListener("byoky-message", handleEvent);
       window.postMessage({
         type: "BYOKY_SESSION_STATUS",
         requestId,
         payload: { sessionKey }
-      }, "*");
+      }, window.location.origin, [channel.port2]);
     });
   }
   querySessionUsage(sessionKey) {
@@ -454,8 +694,9 @@ var Byoky = class {
         cleanup();
         reject(new Error("Usage query timed out"));
       }, 5e3);
-      function handleEvent(event) {
-        const msg = event.detail;
+      const channel = new MessageChannel();
+      channel.port1.onmessage = (event) => {
+        const msg = event.data;
         if (msg?.requestId !== requestId) return;
         if (msg.type === "BYOKY_SESSION_USAGE_RESPONSE") {
           cleanup();
@@ -465,17 +706,16 @@ var Byoky = class {
             reject(new Error("Session not found"));
           }
         }
-      }
+      };
       function cleanup() {
         clearTimeout(timeout);
-        document.removeEventListener("byoky-message", handleEvent);
+        channel.port1.close();
       }
-      document.addEventListener("byoky-message", handleEvent);
       window.postMessage({
         type: "BYOKY_SESSION_USAGE",
         requestId,
         payload: { sessionKey }
-      }, "*");
+      }, window.location.origin, [channel.port2]);
     });
   }
 };