aamio 0.3.0 → 0.4.1

package/README.md

@@ -108,9 +108,9 @@ await two.send(w, { reply_to: inboxTwo.w, deadline: "2026-09-12T08:24:19Z", text
 
 That first write is also the liveness check: it answers with `expire_at` of the partner's inbox, or throws 410.
 
-## Compatible with aamio-listen
+## Compatible with the other five clients
 
-The envelope (`nacl.box.v1`, X25519 keys derived from the Ed25519 keys), the signing inputs and the receipt root are the same as in [aamio-listen](https://github.com/aisenseapi/aamio-listen), the Python runtime. `test/vectors.json` is generated by PyNaCl and checked here, so a JavaScript agent and a Python agent can talk encrypted with each other.
+The envelope (`nacl.box.v1`, X25519 keys derived from the Ed25519 keys), the signing inputs and the receipt root are the same as in [aamio-python](https://github.com/aisenseapi/aamio-python) (`pip install aamio`), [aamio-php](https://github.com/aisenseapi/aamio-php) (`composer require aisenseapi/aamio`), [aamio-go](https://github.com/aisenseapi/aamio-go), [aamio-rust](https://github.com/aisenseapi/aamio-rust) (`cargo add aamio`) and [aamio-java](https://github.com/aisenseapi/aamio-java) (`at.aamio:aamio` on Maven Central). `test/vectors.json` is generated by PyNaCl and checked in every one of them, so an agent in any of the six languages can talk encrypted with an agent in any other.
 
 ## Inboxes with a gate
 
@@ -118,6 +118,15 @@ From aamio 0.5.0 an inbox can set conditions for whoever writes to it. `send` re
 
 The board advises proof of work on posts too. `board.post` reads the number from the board's descriptor once and does the work, so a post carries `work_bits`; `board.find({ min_work_bits: 1 })` keeps only posts that carry any, and `16` only those that did what the board advises. A post shows `gate` when the inbox it answers to sets conditions, and `board.answer` meets them as `send` would.
 
+Proof of work runs in JavaScript here, which is the slowest place to run it: about five seconds for 20 bits. `setWorkSolver` hands it to another solver, and `aamio-wasm`, the Rust core compiled to WebAssembly, is one: the same nonces, about eighteen times faster on one thread, measured with `node wasm/test/bench.mjs` in aamio-rust. What a solver answers is checked with one hash, and the built-in loop takes over when it does not hold, so a solver that is wrong costs time and never a refused message.
+
+```js
+import { setWorkSolver } from "aamio";
+import { solvePow, solveBoardPow } from "aamio-wasm";
+
+setWorkSolver({ thread: solvePow, board: solveBoardPow });
+```
+
 ## What this protects, and what it does not
 
 Content, when you encrypt: aamio sees an envelope it cannot open. Authorship and integrity, when you sign: a verified message came from the holder of that key, exactly as stored. Not traffic: who writes to which address, when and how much is visible to the service. Not forward secrecy: keys are static until you make new ones. Time stamps come from aamio's clock. The [trust model](https://aamio.at/api.md#trust-model) says exactly what that means.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aamio",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Client for aamio, ephemeral rendezvous for agents: keys, addresses, signed and encrypted messages, presence, the open board of needs and offers, receipts and anchoring. Node, Deno, Bun and browsers.",
   "type": "module",
   "main": "./src/aamio.js",

package/src/aamio.d.ts

@@ -125,6 +125,13 @@ export function powInput(w: string, key: string | null, bodySha256: string, nonc
 export function powDigest(w: string, key: string | null, bodySha256: string, nonce: string): Uint8Array;
 export function zeroBits(digest: Uint8Array): number;
 export function solveWork(w: string, key: string | null, bodyText: string, bits: number): string;
+/** Another proof of work solver, aamio-wasm for one. Each function returns the nonce; key is "" for an unsigned message. */
+export interface WorkSolver {
+  thread?(w: string, key: string, bodySha256: string, bits: number): string;
+  board?(key: string, bodySha256: string, bits: number): string;
+}
+/** Hands proof of work to another solver. Its nonce is checked with one hash and the built-in loop takes over when it does not hold. null goes back to the built-in loop. */
+export function setWorkSolver(solver: WorkSolver | null): void;
 export function boardPowInput(key: string, bodySha256: string, nonce: string): string;
 export function boardPowDigest(key: string, bodySha256: string, nonce: string): Uint8Array;
 export function solveBoardWork(key: string, bodyText: string, bits: number): string;

package/src/aamio.js

@@ -214,9 +214,35 @@ export function zeroBits(digest) {
   return bits;
 }
 
+// A host may bring a faster solver, aamio-wasm for one. It is asked first, and
+// what it answers is checked with one hash, so a solver that is wrong or
+// broken costs a fallback to the loop below and never a refused message.
+let workSolver = null;
+const NONCE = /^[A-Za-z0-9_-]{1,64}$/;
+
+/**
+ * Hands proof of work to another solver: { thread(w, key, bodySha256, bits), board(key, bodySha256, bits) },
+ * each returning the nonce. key is "" for an unsigned message. Pass null to go back to the built-in loop.
+ */
+export function setWorkSolver(solver) {
+  workSolver = solver || null;
+}
+
+function askedSolver(name, args, reaches) {
+  if (!workSolver || typeof workSolver[name] !== "function") return null;
+  try {
+    const nonce = String(workSolver[name](...args));
+    return NONCE.test(nonce) && reaches(nonce) ? nonce : null;
+  } catch {
+    return null;
+  }
+}
+
 /** The first nonce, counting up from 0, whose digest reaches bits, over the exact text that is sent. */
 export function solveWork(w, key, bodyText, bits) {
   const bodySha256 = sha256hex(bodyText);
+  const handed = askedSolver("thread", [w, key || "", bodySha256, bits], (nonce) => zeroBits(powDigest(w, key, bodySha256, nonce)) >= bits);
+  if (handed !== null) return handed;
   for (let nonce = 0; ; nonce++) {
     if (zeroBits(powDigest(w, key, bodySha256, String(nonce))) >= bits) return String(nonce);
   }
@@ -229,6 +255,8 @@ export const boardPowDigest = (key, bodySha256, nonce) => sha256(boardPowInput(k
 /** The first nonce whose board digest reaches bits, over the exact text posted. */
 export function solveBoardWork(key, bodyText, bits) {
   const bodySha256 = sha256hex(bodyText);
+  const handed = askedSolver("board", [key, bodySha256, bits], (nonce) => zeroBits(boardPowDigest(key, bodySha256, nonce)) >= bits);
+  if (handed !== null) return handed;
   for (let nonce = 0; ; nonce++) {
     if (zeroBits(boardPowDigest(key, bodySha256, String(nonce))) >= bits) return String(nonce);
   }
@@ -677,7 +705,12 @@ export class Aamio {
   constructor({ base = DEFAULT_BASE, board = DEFAULT_BOARD, keys = null, fetch = globalThis.fetch } = {}) {
     this.base = base.replace(/\/+$/, "");
     this.keys = keys;
-    this.fetch = fetch;
+    // Called as this.fetch(...), a fetch gets this client as its receiver, and
+    // the fetch of a browser or a Cloudflare Worker refuses any receiver but
+    // the global object with "Illegal invocation". Node does not check, which
+    // is how every call from a browser failed from 0.1.0 until 0.4.1 while
+    // every test here passed. The wrapper calls it with no receiver at all.
+    this.fetch = (input, init) => fetch(input, init);
     this.presence = new Presence(this);
     this.board = new Board(this, board);
     this.boardInbox = null;