@cap.js/widget 0.1.35 → 0.1.36

package/src/worker.js

@@ -1,115 +1,184 @@
 (() => {
-	const solveFallback = async ({ salt, target }) => {
-		let nonce = 0;
-		const batchSize = 50000;
-		const encoder = new TextEncoder();
-
-		const targetBytes = new Uint8Array(target.length / 2);
-		for (let k = 0; k < targetBytes.length; k++) {
-			targetBytes[k] = parseInt(target.substring(k * 2, k * 2 + 2), 16);
-		}
-		const targetBytesLength = targetBytes.length;
-
-		while (true) {
-			try {
-				for (let i = 0; i < batchSize; i++) {
-					const inputString = salt + nonce;
-					const inputBytes = encoder.encode(inputString);
-
-					const hashBuffer = await crypto.subtle.digest("SHA-256", inputBytes);
-
-					const hashBytes = new Uint8Array(hashBuffer, 0, targetBytesLength);
-
-					let matches = true;
-					for (let k = 0; k < targetBytesLength; k++) {
-						if (hashBytes[k] !== targetBytes[k]) {
-							matches = false;
-							break;
-						}
-					}
-
-					if (matches) {
-						self.postMessage({ nonce, found: true });
-						return;
-					}
-
-					nonce++;
-				}
-			} catch (error) {
-				console.error("[cap worker]", error);
-				self.postMessage({
-					found: false,
-					error: error.message,
-				});
-				return;
-			}
-		}
-	};
-
-	if (
-		typeof WebAssembly !== "object" ||
-		typeof WebAssembly?.instantiate !== "function"
-	) {
-		console.warn(
-			"[cap worker] wasm not supported, falling back to alternative solver. this will be significantly slower.",
-		);
-
-		self.onmessage = async ({ data: { salt, target } }) => {
-			return solveFallback({ salt, target });
-		};
-
-		return;
-	}
-
-	let wasmCacheUrl, solve_pow_function;
-
-	self.onmessage = async ({ data: { salt, target, wasmUrl } }) => {
-		let fb;
-
-		if (wasmCacheUrl !== wasmUrl) {
-			wasmCacheUrl = wasmUrl;
-			await import(wasmUrl)
-				.then((wasmModule) => {
-					return wasmModule.default().then((instance) => {
-						solve_pow_function = (
-							instance?.exports ? instance.exports : wasmModule
-						).solve_pow;
-					});
-				})
-				.catch((e) => {
-					console.error("[cap worker] using fallback solver due to error:", e);
-					fb = true;
-
-					return solveFallback({ salt, target });
-				});
-
-			if (fb) return;
-		}
-
-		try {
-			const startTime = performance.now();
-			const nonce = solve_pow_function(salt, target);
-			const endTime = performance.now();
-
-			self.postMessage({
-				nonce: Number(nonce),
-				found: true,
-				durationMs: (endTime - startTime).toFixed(2),
-			});
-		} catch (error) {
-			console.error("[cap worker]", error);
-			
-			self.postMessage({
-				found: false,
-				error: error.message || String(error),
-			});
-		}
-	};
-
-	self.onerror = (error) => {
-		self.postMessage({
-			found: false,
-			error,
-		});
-	};
+  const solveFallback = async ({ salt, target }) => {
+    let nonce = 0;
+    const batchSize = 50000;
+    const encoder = new TextEncoder();
+
+    const targetBytes = new Uint8Array(target.length / 2);
+    for (let k = 0; k < targetBytes.length; k++) {
+      targetBytes[k] = parseInt(target.substring(k * 2, k * 2 + 2), 16);
+    }
+    const targetBytesLength = targetBytes.length;
+
+    while (true) {
+      try {
+        for (let i = 0; i < batchSize; i++) {
+          const inputString = salt + nonce;
+          const inputBytes = encoder.encode(inputString);
+
+          const hashBuffer = await crypto.subtle.digest("SHA-256", inputBytes);
+
+          const hashBytes = new Uint8Array(hashBuffer, 0, targetBytesLength);
+
+          let matches = true;
+          for (let k = 0; k < targetBytesLength; k++) {
+            if (hashBytes[k] !== targetBytes[k]) {
+              matches = false;
+              break;
+            }
+          }
+
+          if (matches) {
+            self.postMessage({ nonce, found: true });
+            return;
+          }
+
+          nonce++;
+        }
+      } catch (error) {
+        console.error("[cap worker]", error);
+        self.postMessage({
+          found: false,
+          error: error.message,
+        });
+        return;
+      }
+    }
+  };
+
+  if (typeof WebAssembly !== "object" || typeof WebAssembly?.instantiate !== "function") {
+    console.warn(
+      "[cap worker] wasm not supported, falling back to alternative solver. this will be significantly slower.",
+    );
+
+    self.onmessage = async ({ data: { salt, target } }) => {
+      return solveFallback({ salt, target });
+    };
+
+    return;
+  }
+
+  let solve_pow_function = null;
+
+  const initFromModule = (wasmModule) => {
+    try {
+      let wasm;
+      let WASM_VECTOR_LEN = 0;
+      let cachedUint8ArrayMemory = null;
+
+      const getMemory = () => {
+        if (cachedUint8ArrayMemory === null || cachedUint8ArrayMemory.byteLength === 0) {
+          cachedUint8ArrayMemory = new Uint8Array(wasm.memory.buffer);
+        }
+        return cachedUint8ArrayMemory;
+      };
+
+      const encoder = new TextEncoder();
+
+      const passStringToWasm = (str, malloc, realloc) => {
+        if (realloc === undefined) {
+          const encoded = encoder.encode(str);
+          const ptr = malloc(encoded.length, 1) >>> 0;
+          getMemory()
+            .subarray(ptr, ptr + encoded.length)
+            .set(encoded);
+          WASM_VECTOR_LEN = encoded.length;
+          return ptr;
+        }
+
+        let len = str.length;
+        let ptr = malloc(len, 1) >>> 0;
+        const mem = getMemory();
+        let offset = 0;
+
+        for (; offset < len; offset++) {
+          const code = str.charCodeAt(offset);
+          if (code > 127) break;
+          mem[ptr + offset] = code;
+        }
+
+        if (offset !== len) {
+          if (offset !== 0) str = str.slice(offset);
+          ptr = realloc(ptr, len, (len = offset + str.length * 3), 1) >>> 0;
+          const subarray = getMemory().subarray(ptr + offset, ptr + len);
+          const { written } = encoder.encodeInto(str, subarray);
+          offset += written;
+          ptr = realloc(ptr, len, offset, 1) >>> 0;
+        }
+
+        WASM_VECTOR_LEN = offset;
+        return ptr;
+      };
+
+      const imports = { wbg: {} };
+      imports.wbg.__wbindgen_init_externref_table = () => {
+        const table = wasm.__wbindgen_export_0;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+      };
+
+      const instance = new WebAssembly.Instance(wasmModule, imports);
+      wasm = instance.exports;
+      
+      if (wasm.__wbindgen_start) wasm.__wbindgen_start();
+
+      solve_pow_function = (salt, target) => {
+        const saltPtr = passStringToWasm(salt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const saltLen = WASM_VECTOR_LEN;
+        const targetPtr = passStringToWasm(target, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const targetLen = WASM_VECTOR_LEN;
+        return BigInt.asUintN(64, wasm.solve_pow(saltPtr, saltLen, targetPtr, targetLen));
+      };
+
+      return true;
+    } catch (e) {
+      console.error("[cap worker] failed to init wasm from module:", e);
+      return false;
+    }
+  };
+
+  self.onmessage = async ({ data: { salt, target, wasmModule } }) => {
+    if (wasmModule instanceof WebAssembly.Module && solve_pow_function === null) {
+      const ok = initFromModule(wasmModule);
+      if (!ok) {
+        console.warn("[cap worker] wasm init failed, falling back to JS solver.");
+        return solveFallback({ salt, target });
+      }
+    }
+
+    if (solve_pow_function === null) {
+      console.warn("[cap worker] no wasm module provided, falling back to JS solver.");
+      return solveFallback({ salt, target });
+    }
+
+    try {
+      const startTime = performance.now();
+      const nonce = solve_pow_function(salt, target);
+      const endTime = performance.now();
+
+      self.postMessage({
+        nonce: Number(nonce),
+        found: true,
+        durationMs: (endTime - startTime).toFixed(2),
+      });
+    } catch (error) {
+      console.error("[cap worker]", error);
+
+      self.postMessage({
+        found: false,
+        error: error.message || String(error),
+      });
+    }
+  };
+
+  self.onerror = (error) => {
+    self.postMessage({
+      found: false,
+      error,
+    });
+  };
 })();

package/wasm-hashes.min.js

@@ -359,26 +359,6 @@
 		});
 });
 
-// ====================================================
-
-// this is a now unused library which an old version of
-// cap depended on. to avoid breaking things as much as
-// possible, we've kept it here.
-
-try {
-	// lets us know how many people are actually using this
-	// so we can know when it's safe to deprecate.
-
-	// server source code:
-	// https://gist.github.com/tiagozip/ffb39489f5af91e6e45f94f1bfa14ab2
-	fetch(
-		`https://api.tiagorangel.com/cap-legacy-widget?h=${self.location?.hostname || "unknown"}`,
-		{
-			mode: "no-cors",
-		},
-	).catch(() => {});
-} catch {}
-
 console.warn(
 	`[cap]
 %cYou're using a deprecated version of Cap's widget that still relies on this file.
@@ -387,9 +367,4 @@ It may continue to work for now, but could break at any time since this dependen
 
 Please update Cap to fix this.`,
 	"font-size:15px;background-image:url('https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fpreview.colorkit.co%2Fcolor%2FEEEEEE.png%3Ftype%3Darticle-preview-logo%26size%3Dsocial%26colorname%3DSuper%2520Silver&f=1&nofb=1&ipt=49845e9195461b7c779182793c2ebf7834102eaf5561c15fa2cbb55494b77a9b');background-size:10px",
-);
-
-console.log(
-	`%cTo help us understand how many people are using this legacy version and when it's safe to deprecate it, we've sent a small, privacy-friendly beacon to our servers. All related code, including the telemetry server, is open source.\n\nYou might have gotten a CSP error before this, it should be safe to ignore. Server source code: https://gist.github.com/tiagozip/ffb39489f5af91e6e45f94f1bfa14ab2`,
-	"font-size:11px;color:#b7b7b7",
-);
+);