lightnode-sdk 0.4.5 → 0.4.6

package/dist/crypto.d.ts

@@ -9,12 +9,14 @@
  *   - AES-GCM ciphertext layout: nonce(12) || ciphertext || tag(16).
  *   - Encrypted session key layout: ephemeralPub(65) || nonce(12) || ciphertext || tag(16).
  *
- * Uses the Web Crypto API exposed via `globalThis.crypto.subtle`, available in
- * Node 18+ and all modern browsers. No Node-only dependencies; the SDK runs
- * unchanged in either environment.
+ * Uses the Web Crypto API. Tries `globalThis.crypto` first (real browsers +
+ * Node 19+ where it is global), then falls back to `node:crypto`'s
+ * `webcrypto` export (Node 18 and StackBlitz's WebContainer, which exposes
+ * the node: module but not the global). No hard dependency on Node, and no
+ * polyfill in the browser bundle.
  */
 /** A fresh 32-byte symmetric session key (random, never derived). */
-export declare function generateSessionKey(): Uint8Array;
+export declare function generateSessionKey(): Promise<Uint8Array>;
 /** Fresh ECDH P-256 keypair (extractable; we need to export the public key on the wire). */
 export declare function generateEcdhKeyPair(): Promise<CryptoKeyPair>;
 /** Export an ECDH public key to its raw uncompressed P-256 encoding (65 bytes). */

package/dist/crypto.js

@@ -9,23 +9,61 @@
  *   - AES-GCM ciphertext layout: nonce(12) || ciphertext || tag(16).
  *   - Encrypted session key layout: ephemeralPub(65) || nonce(12) || ciphertext || tag(16).
  *
- * Uses the Web Crypto API exposed via `globalThis.crypto.subtle`, available in
- * Node 18+ and all modern browsers. No Node-only dependencies; the SDK runs
- * unchanged in either environment.
+ * Uses the Web Crypto API. Tries `globalThis.crypto` first (real browsers +
+ * Node 19+ where it is global), then falls back to `node:crypto`'s
+ * `webcrypto` export (Node 18 and StackBlitz's WebContainer, which exposes
+ * the node: module but not the global). No hard dependency on Node, and no
+ * polyfill in the browser bundle.
  */
 const AES_KEY_BYTES = 32;
 const GCM_NONCE_BYTES = 12;
 const P256_UNCOMPRESSED_KEY_BYTES = 65;
 const SESSION_KEY_BYTES = 32;
-function subtle() {
-    const c = globalThis.crypto;
-    if (!c?.subtle)
-        throw new Error("Web Crypto unavailable - Node 18+ or a browser is required");
-    return c.subtle;
+let resolvedCrypto = null;
+let resolvingCrypto = null;
+async function getCrypto() {
+    if (resolvedCrypto)
+        return resolvedCrypto;
+    if (resolvingCrypto)
+        return resolvingCrypto;
+    resolvingCrypto = (async () => {
+        const g = globalThis.crypto;
+        if (g?.subtle && typeof g.getRandomValues === "function") {
+            const provider = { subtle: g.subtle, getRandomValues: g.getRandomValues.bind(g) };
+            resolvedCrypto = provider;
+            return provider;
+        }
+        // Node 18 + StackBlitz WebContainer: globalThis.crypto is missing, but
+        // `node:crypto` exposes the same Web Crypto API via `webcrypto`.
+        try {
+            const mod = (await import("node:crypto"));
+            const wc = mod.webcrypto;
+            if (wc?.subtle && typeof wc.getRandomValues === "function") {
+                const provider = { subtle: wc.subtle, getRandomValues: wc.getRandomValues.bind(wc) };
+                resolvedCrypto = provider;
+                return provider;
+            }
+        }
+        catch {
+            // node:crypto not importable - we're in a browser bundle without a
+            // global crypto. The fall-through error below explains the fix.
+        }
+        throw new Error("Web Crypto unavailable: globalThis.crypto is missing and node:crypto could not be loaded. " +
+            "The SDK requires Node 18+ or a modern browser.");
+    })();
+    try {
+        return await resolvingCrypto;
+    }
+    finally {
+        resolvingCrypto = null;
+    }
+}
+async function subtle() {
+    return (await getCrypto()).subtle;
 }
-function randomBytes(n) {
+async function randomBytes(n) {
     const buf = new Uint8Array(n);
-    globalThis.crypto.getRandomValues(buf);
+    (await getCrypto()).getRandomValues(buf);
     return buf;
 }
 /** A fresh 32-byte symmetric session key (random, never derived). */
@@ -33,16 +71,16 @@ export function generateSessionKey() {
     return randomBytes(SESSION_KEY_BYTES);
 }
 /** Fresh ECDH P-256 keypair (extractable; we need to export the public key on the wire). */
-export function generateEcdhKeyPair() {
-    return subtle().generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]);
+export async function generateEcdhKeyPair() {
+    return (await subtle()).generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveBits"]);
 }
 /** Export an ECDH public key to its raw uncompressed P-256 encoding (65 bytes). */
 export async function exportPublicKey(key) {
-    return new Uint8Array(await subtle().exportKey("raw", key));
+    return new Uint8Array(await (await subtle()).exportKey("raw", key));
 }
 /** Import a raw uncompressed P-256 public key (65 bytes) into a CryptoKey. */
-export function importPublicKey(raw) {
-    return subtle().importKey("raw", raw, { name: "ECDH", namedCurve: "P-256" }, true, []);
+export async function importPublicKey(raw) {
+    return (await subtle()).importKey("raw", raw, { name: "ECDH", namedCurve: "P-256" }, true, []);
 }
 /**
  * Derive a 32-byte shared secret from a local ECDH private key and a remote
@@ -50,15 +88,16 @@ export function importPublicKey(raw) {
  * protocol's `priv.ECDH(remotePub)` output exactly.
  */
 export async function deriveSharedSecret(privateKey, remotePublicKey) {
-    return new Uint8Array(await subtle().deriveBits({ name: "ECDH", public: remotePublicKey }, privateKey, 256));
+    return new Uint8Array(await (await subtle()).deriveBits({ name: "ECDH", public: remotePublicKey }, privateKey, 256));
 }
 /** Encrypt with AES-256-GCM. Output: nonce(12) || ciphertext || tag(16). */
 export async function encrypt(key, plaintext) {
     if (key.length !== AES_KEY_BYTES)
         throw new Error(`AES key must be ${AES_KEY_BYTES} bytes`);
-    const aesKey = await subtle().importKey("raw", key, "AES-GCM", false, ["encrypt"]);
-    const nonce = randomBytes(GCM_NONCE_BYTES);
-    const ctPlusTag = new Uint8Array(await subtle().encrypt({ name: "AES-GCM", iv: nonce }, aesKey, plaintext));
+    const s = await subtle();
+    const aesKey = await s.importKey("raw", key, "AES-GCM", false, ["encrypt"]);
+    const nonce = await randomBytes(GCM_NONCE_BYTES);
+    const ctPlusTag = new Uint8Array(await s.encrypt({ name: "AES-GCM", iv: nonce }, aesKey, plaintext));
     const out = new Uint8Array(GCM_NONCE_BYTES + ctPlusTag.byteLength);
     out.set(nonce, 0);
     out.set(ctPlusTag, GCM_NONCE_BYTES);
@@ -70,10 +109,11 @@ export async function decrypt(key, ciphertext) {
         throw new Error(`AES key must be ${AES_KEY_BYTES} bytes`);
     if (ciphertext.length < GCM_NONCE_BYTES + 16)
         throw new Error("ciphertext too short");
-    const aesKey = await subtle().importKey("raw", key, "AES-GCM", false, ["decrypt"]);
+    const s = await subtle();
+    const aesKey = await s.importKey("raw", key, "AES-GCM", false, ["decrypt"]);
     const nonce = ciphertext.slice(0, GCM_NONCE_BYTES);
     const body = ciphertext.slice(GCM_NONCE_BYTES);
-    return new Uint8Array(await subtle().decrypt({ name: "AES-GCM", iv: nonce }, aesKey, body));
+    return new Uint8Array(await s.decrypt({ name: "AES-GCM", iv: nonce }, aesKey, body));
 }
 /**
  * Wrap (encrypt) a 32-byte session key for delivery to a remote party (e.g. the

package/dist/inference.js

@@ -76,7 +76,7 @@ export const JOB_REGISTRY_CONSUMER_ABI = [
 export async function prepareSession(gateway, modelTag) {
     const id = modelId(modelTag);
     const selected = await gateway.selectSession(id);
-    const sessionKey = generateSessionKey();
+    const sessionKey = await generateSessionKey();
     // Workers' pubkeys arrive as base64; disputer's as hex - decodePublicKey
     // accepts either.
     const workerPub = await importPublicKey(decodePublicKey(selected.workerEncryptionKey));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lightnode-sdk",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Read-only TypeScript client for LightChain AI: workers, jobs, models, on-chain registration, and per-model network analytics. Independent, community-built (not an official LightChain package).",
   "type": "module",
   "main": "./dist/index.js",