@voidly/session 1.0.0 → 1.1.0

package/dist/proofsCli.mjs

@@ -0,0 +1,417 @@
+#!/usr/bin/env node
+import nacl from "tweetnacl";
+import __naclUtil0 from "tweetnacl-util";
+const { decodeBase64 } = __naclUtil0;
+var MAX_WINDOW_MS = 3600 * 1e3, MAX_CLOCK_SKEW_MS = 30 * 1e3;
+function canonicalize(value) {
+  if (value == null) return "null";
+  if (typeof value == "boolean") return value ? "true" : "false";
+  if (typeof value == "number") {
+    if (!Number.isFinite(value) || !Number.isInteger(value)) throw new Error("canonicalize: only finite integers supported");
+    return value.toString(10);
+  }
+  if (typeof value == "bigint") return value.toString(10);
+  if (typeof value == "string") return JSON.stringify(value);
+  if (Array.isArray(value)) return "[" + value.map(canonicalize).join(",") + "]";
+  if (typeof value == "object") {
+    let obj = value;
+    return "{" + Object.keys(obj).filter((k) => obj[k] !== null && obj[k] !== void 0).sort().map((k) => JSON.stringify(k) + ":" + canonicalize(obj[k])).join(",") + "}";
+  }
+  throw new Error(`canonicalize: unsupported type ${typeof value}`);
+}
+function canonicalBytes(value) {
+  return new TextEncoder().encode(canonicalize(value));
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function toBase58(bytes) {
+  let result = "", num = BigInt("0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(""));
+  for (; num > 0n; ) {
+    let remainder = num % 58n;
+    num = num / 58n, result = BASE58_ALPHABET[Number(remainder)] + result;
+  }
+  for (let byte of bytes) if (byte === 0) result = "1" + result;
+  else break;
+  return result || "1";
+}
+function deriveDidFromSigningKey(signingPublicKey) {
+  return `did:voidly:${toBase58(signingPublicKey.slice(0, 16))}`;
+}
+async function sha256Bytes(bytes) {
+  let buf = await crypto.subtle.digest("SHA-256", bytes);
+  return new Uint8Array(buf);
+}
+async function sha256Hex(bytes) {
+  let digest = await sha256Bytes(bytes);
+  return Array.from(digest).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var FRAME_OFFER_HASH_BYTES = 32, FRAME_BODY_NONCE_BYTES = 24, FRAME_HEADER_LENGTH = FRAME_OFFER_HASH_BYTES + FRAME_BODY_NONCE_BYTES + 4, MIN_FRAME_BUCKET = 512;
+var SECRETBOX_TAG_BYTES = 16, CAPSULE_SALT_BYTES = 32;
+function base64Length(bytes) {
+  return 4 * Math.ceil(bytes / 3);
+}
+var SESSION_MAX_BODY_BYTES = 32 * 1024, SESSION_WORST_CASE_ENVELOPE_BYTES = 4972, MAX_FRAME_BUCKET_BYTES = (() => {
+  let best = 0;
+  for (let bucket = MIN_FRAME_BUCKET; bucket <= SESSION_MAX_BODY_BYTES; bucket *= 2) base64Length(bucket + SECRETBOX_TAG_BYTES) + SESSION_WORST_CASE_ENVELOPE_BYTES <= SESSION_MAX_BODY_BYTES && (best = bucket);
+  if (best === 0) throw new Error("wireBudget: the transport ceiling cannot carry the minimum frame bucket");
+  return best;
+})(), MAX_CAPSULE_BODY_BYTES = MAX_FRAME_BUCKET_BYTES + SECRETBOX_TAG_BYTES, MAX_CAPSULE_BODY_BASE64_LENGTH = base64Length(MAX_CAPSULE_BODY_BYTES), MAX_SEALED_PAYLOAD_BYTES = MAX_FRAME_BUCKET_BYTES - FRAME_HEADER_LENGTH, SESSION_EVIDENCE_HEADROOM_BYTES = SESSION_MAX_BODY_BYTES - MAX_CAPSULE_BODY_BASE64_LENGTH - SESSION_WORST_CASE_ENVELOPE_BYTES;
+var TASK_BRIEF_SCHEMA = "voidly-task-brief/v1";
+var TASK_RESULT_SCHEMA = "voidly-task-result/v1";
+var MAX_OFFER_TTL_MS = 1440 * 60 * 1e3, MAX_GRANT_TTL_MS = 1440 * 60 * 1e3;
+var SESSION_RAIL_MIN_CONFIRMATIONS = 12, SESSION_RAIL_BLOCK_TIME_MS = 2e3, MIN_GRANT_TTL_MS = SESSION_RAIL_MIN_CONFIRMATIONS * SESSION_RAIL_BLOCK_TIME_MS + MAX_CLOCK_SKEW_MS, MAX_SERVICE_REF_LENGTH = 128;
+var BRIEF_SALT_BASE64_LENGTH = base64Length(CAPSULE_SALT_BYTES), canonicalPayloadOverhead = (schema, field) => canonicalBytes({ schema, [field]: "", salt_base64: "A".repeat(BRIEF_SALT_BASE64_LENGTH) }).length, MAX_BRIEF_LENGTH = MAX_SEALED_PAYLOAD_BYTES - Math.max(canonicalPayloadOverhead(TASK_BRIEF_SCHEMA, "brief"), canonicalPayloadOverhead(TASK_RESULT_SCHEMA, "result"));
+var MAX_RECOVERY_TTL_MS = 10080 * 60 * 1e3;
+var DID_RE = /^did:voidly:[A-Za-z0-9._-]{1,64}$/;
+function hasOnlyKeys(raw, allowed) {
+  for (let k of Object.keys(raw)) if (!allowed.includes(k)) return false;
+  return true;
+}
+function isBase64Key32(value, decode) {
+  if (typeof value != "string" || value.length === 0) return false;
+  try {
+    return decode(value).length === 32;
+  } catch {
+    return false;
+  }
+}
+var CAIP2_RE = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}$/, CAIP10_RE = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}:[-.%a-zA-Z0-9]{1,128}$/, CAIP19_RE = /^[-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32}\/[-a-z0-9]{3,8}:[-.%a-zA-Z0-9]{1,128}(\/[-.%a-zA-Z0-9]{1,78})?$/, POSITIVE_DECIMAL_RE = /^[1-9][0-9]{0,77}$/;
+function isCaip2(s) {
+  return typeof s == "string" && CAIP2_RE.test(s);
+}
+function isCaip10(s) {
+  return typeof s == "string" && CAIP10_RE.test(s);
+}
+function isCaip19(s) {
+  return typeof s == "string" && CAIP19_RE.test(s);
+}
+function isPositiveDecimalString(s) {
+  return typeof s == "string" && POSITIVE_DECIMAL_RE.test(s);
+}
+import __naclUtil1 from "tweetnacl-util";
+const { decodeBase64: decodeBase642 } = __naclUtil1;
+var SESSION_HIRE_SCHEMA = "voidly-session-hire/v1";
+var AUTHORIZATION_ENTRY_POINTS = ["transfer_with_authorization", "receive_with_authorization"];
+import nacl2 from "tweetnacl";
+import __naclUtil2 from "tweetnacl-util";
+const { decodeBase64: decodeBase643 } = __naclUtil2;
+var MINTED = /* @__PURE__ */ new WeakMap();
+function containerCopy(value) {
+  if (value === null || typeof value != "object") return null;
+  if (Array.isArray(value)) {
+    let source = value, sink = [];
+    for (let key of Object.keys(source)) sink[key] = source[key];
+    return sink;
+  }
+  return { ...value };
+}
+function rebuildDocumentDeep(document) {
+  let top = containerCopy(document);
+  if (top === null) return document;
+  let made = /* @__PURE__ */ new Map();
+  made.set(document, top);
+  let pending = [top];
+  for (; pending.length > 0; ) {
+    let frame = pending.pop();
+    if (frame === void 0) break;
+    for (let key of Object.keys(frame)) {
+      let child = frame[key];
+      if (child === null || typeof child != "object") continue;
+      let already = made.get(child);
+      if (already !== void 0) {
+        frame[key] = already;
+        continue;
+      }
+      let copy = containerCopy(child);
+      copy !== null && (made.set(child, copy), frame[key] = copy, pending.push(copy));
+    }
+  }
+  return top;
+}
+function freezeManifestDeep(m) {
+  let seen = /* @__PURE__ */ new Set(), pending = [m];
+  for (; pending.length > 0; ) {
+    let node = pending.pop();
+    if (node === null || typeof node != "object") continue;
+    let container = node;
+    if (!seen.has(container)) {
+      seen.add(container), Object.freeze(container);
+      for (let key of Reflect.ownKeys(container)) {
+        if (typeof key == "symbol") continue;
+        let d = Object.getOwnPropertyDescriptor(container, key);
+        d !== void 0 && "value" in d && pending.push(d.value);
+      }
+    }
+  }
+  return m;
+}
+function mintVerifiedProvider(manifest) {
+  let document = freezeManifestDeep(rebuildDocumentDeep(manifest)), provider = Object.freeze({ manifest: document });
+  return MINTED.set(provider, document), provider;
+}
+var PROVIDER_MANIFEST_SCHEMA = "voidly.session.provider.manifest/v1", PROVIDER_MANIFEST_KEYS = ["schema", "provider_did", "signing_public_key_base64", "encryption_public_key_base64", "attestor_public_key_base64", "accept_url", "hire_message_schema", "worker_base_url", "hint_url", "relays", "grant_ttl_ms", "acceptance_ttl_ms", "services", "payment_buys", "notes", "signature_base64"];
+function manifestSigningBytes(m) {
+  return canonicalBytes(m);
+}
+function isNonEmptyString(v, max = 2048) {
+  return typeof v == "string" && v.length > 0 && v.length <= max;
+}
+function isPositiveInt(v) {
+  return typeof v == "number" && Number.isInteger(v) && v > 0;
+}
+function verifyManifest(raw, expectedProviderDid) {
+  if (typeof raw != "object" || raw === null || Array.isArray(raw)) return { ok: false, reason: "manifest_not_object" };
+  let r = { ...raw };
+  if (r.schema !== PROVIDER_MANIFEST_SCHEMA) return { ok: false, reason: "manifest_schema_mismatch" };
+  if (!hasOnlyKeys(r, PROVIDER_MANIFEST_KEYS)) return { ok: false, reason: "manifest_unexpected_field" };
+  if (r.signature_base64 === void 0 || r.signature_base64 === null) return { ok: false, reason: "manifest_signature_missing" };
+  if (typeof r.signature_base64 != "string" || r.signature_base64.length === 0) return { ok: false, reason: "manifest_signature_malformed" };
+  let signature;
+  try {
+    signature = decodeBase643(r.signature_base64);
+  } catch {
+    return { ok: false, reason: "manifest_signature_malformed" };
+  }
+  if (signature.length !== nacl2.sign.signatureLength) return { ok: false, reason: "manifest_signature_malformed" };
+  if (!isBase64Key32(r.signing_public_key_base64, decodeBase643)) return { ok: false, reason: "manifest_field_malformed" };
+  if (!isBase64Key32(r.encryption_public_key_base64, decodeBase643)) return { ok: false, reason: "manifest_field_malformed" };
+  if (!isBase64Key32(r.attestor_public_key_base64, decodeBase643)) return { ok: false, reason: "manifest_field_malformed" };
+  if (typeof r.provider_did != "string" || !DID_RE.test(r.provider_did)) return { ok: false, reason: "manifest_field_malformed" };
+  if (!isNonEmptyString(r.accept_url) || !isNonEmptyString(r.worker_base_url)) return { ok: false, reason: "manifest_field_malformed" };
+  let rawHintUrl = r.hint_url;
+  if (rawHintUrl !== void 0 && !isNonEmptyString(rawHintUrl)) return { ok: false, reason: "manifest_field_malformed" };
+  let hintUrl = rawHintUrl === void 0 ? void 0 : rawHintUrl, rawRelays = r.relays, relays;
+  if (rawRelays !== void 0) {
+    if (typeof rawRelays != "object" || rawRelays === null || Array.isArray(rawRelays)) return { ok: false, reason: "manifest_field_malformed" };
+    let rel = { ...rawRelays };
+    if (!hasOnlyKeys(rel, ["provider_submits", "accepted_entry_points"])) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof rel.provider_submits != "boolean") return { ok: false, reason: "manifest_field_malformed" };
+    let rawDoors = rel.accepted_entry_points;
+    if (!Array.isArray(rawDoors) || rawDoors.length === 0 || rawDoors.length > AUTHORIZATION_ENTRY_POINTS.length) return { ok: false, reason: "manifest_field_malformed" };
+    let doors = [];
+    for (let i = 0; i < rawDoors.length; i += 1) {
+      let door = rawDoors[i];
+      if (typeof door != "string" || !AUTHORIZATION_ENTRY_POINTS.includes(door)) return { ok: false, reason: "manifest_field_malformed" };
+      if (doors.includes(door)) return { ok: false, reason: "manifest_field_malformed" };
+      doors.push(door);
+    }
+    relays = { provider_submits: rel.provider_submits, accepted_entry_points: doors };
+  }
+  if (r.hire_message_schema !== SESSION_HIRE_SCHEMA) return { ok: false, reason: "manifest_field_malformed" };
+  if (r.payment_buys !== "an attempt, not an outcome") return { ok: false, reason: "manifest_field_malformed" };
+  if (!isPositiveInt(r.acceptance_ttl_ms)) return { ok: false, reason: "manifest_field_malformed" };
+  let ttl = r.grant_ttl_ms;
+  if (typeof ttl != "object" || ttl === null || Array.isArray(ttl)) return { ok: false, reason: "manifest_field_malformed" };
+  let ttlSnap = { ...ttl };
+  if (!hasOnlyKeys(ttlSnap, ["min", "max"])) return { ok: false, reason: "manifest_field_malformed" };
+  if (!isPositiveInt(ttlSnap.min) || !isPositiveInt(ttlSnap.max)) return { ok: false, reason: "manifest_field_malformed" };
+  if (ttlSnap.min > ttlSnap.max || ttlSnap.max > MAX_GRANT_TTL_MS) return { ok: false, reason: "manifest_field_malformed" };
+  let rawNotes = r.notes;
+  if (!Array.isArray(rawNotes)) return { ok: false, reason: "manifest_field_malformed" };
+  let notes = [];
+  for (let i = 0; i < rawNotes.length; i += 1) {
+    let note = rawNotes[i];
+    if (!isNonEmptyString(note, 4096)) return { ok: false, reason: "manifest_field_malformed" };
+    notes.push(note);
+  }
+  let rawServices = r.services;
+  if (!Array.isArray(rawServices) || rawServices.length === 0) return { ok: false, reason: "manifest_field_malformed" };
+  let services = [];
+  for (let i = 0; i < rawServices.length; i += 1) {
+    let entry = rawServices[i];
+    if (typeof entry != "object" || entry === null || Array.isArray(entry)) return { ok: false, reason: "manifest_field_malformed" };
+    let s = { ...entry };
+    if (!hasOnlyKeys(s, ["ref", "description", "price"])) return { ok: false, reason: "manifest_field_malformed" };
+    if (!isNonEmptyString(s.ref, MAX_SERVICE_REF_LENGTH) || typeof s.description != "string") return { ok: false, reason: "manifest_field_malformed" };
+    let price = s.price;
+    if (typeof price != "object" || price === null || Array.isArray(price)) return { ok: false, reason: "manifest_field_malformed" };
+    let p = { ...price };
+    if (!hasOnlyKeys(p, ["chain", "asset", "payee_account", "min_amount", "max_amount"])) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.chain != "string" || !isCaip2(p.chain)) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.asset != "string" || !isCaip19(p.asset)) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.payee_account != "string" || !isCaip10(p.payee_account)) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.min_amount != "string" || !isPositiveDecimalString(p.min_amount)) return { ok: false, reason: "manifest_field_malformed" };
+    if (typeof p.max_amount != "string" || !isPositiveDecimalString(p.max_amount)) return { ok: false, reason: "manifest_field_malformed" };
+    services.push({ ref: s.ref, description: s.description, price: { chain: p.chain, asset: p.asset, payee_account: p.payee_account, min_amount: p.min_amount, max_amount: p.max_amount } });
+  }
+  let signingKey = decodeBase643(r.signing_public_key_base64), derived = null;
+  try {
+    derived = deriveDidFromSigningKey(signingKey);
+  } catch {
+    derived = null;
+  }
+  if (derived === null || derived !== r.provider_did) return { ok: false, reason: "manifest_did_not_derived" };
+  let body = { schema: PROVIDER_MANIFEST_SCHEMA, provider_did: r.provider_did, signing_public_key_base64: r.signing_public_key_base64, encryption_public_key_base64: r.encryption_public_key_base64, attestor_public_key_base64: r.attestor_public_key_base64, accept_url: r.accept_url, hire_message_schema: SESSION_HIRE_SCHEMA, worker_base_url: r.worker_base_url, ...hintUrl !== void 0 ? { hint_url: hintUrl } : {}, ...relays !== void 0 ? { relays } : {}, grant_ttl_ms: { min: ttlSnap.min, max: ttlSnap.max }, acceptance_ttl_ms: r.acceptance_ttl_ms, services, payment_buys: "an attempt, not an outcome", notes }, verified = false;
+  try {
+    verified = nacl2.sign.detached.verify(manifestSigningBytes(body), signature, signingKey);
+  } catch {
+    verified = false;
+  }
+  return verified ? expectedProviderDid !== void 0 && expectedProviderDid !== body.provider_did ? { ok: false, reason: "manifest_did_not_pinned" } : { ok: true, manifest: { ...body, signature_base64: r.signature_base64 } } : { ok: false, reason: "manifest_signature_invalid" };
+}
+function verifyProvider(raw, expectedProviderDid) {
+  if (typeof expectedProviderDid != "string" || !DID_RE.test(expectedProviderDid)) return { ok: false, reason: "manifest_pin_not_a_did" };
+  let verdict = verifyManifest(raw, expectedProviderDid);
+  if (!verdict.ok) return { ok: false, reason: verdict.reason };
+  let refs = /* @__PURE__ */ new Set();
+  for (let offering of verdict.manifest.services) {
+    if (refs.has(offering.ref)) return { ok: false, reason: "manifest_service_ref_duplicated" };
+    refs.add(offering.ref);
+  }
+  return { ok: true, provider: mintVerifiedProvider(verdict.manifest) };
+}
+var PROOFS_FIXTURE = { schema: "voidly.session.provider.manifest/v1", provider_did: "did:voidly:E41eeJuRTVxE7411zGGF9H", signing_public_key_base64: "abJvEa/votvZLFZzFKEhwNxyBoIqBRYgvL6mrNysGFI=", encryption_public_key_base64: "CwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCws=", attestor_public_key_base64: "ExMTExMTExMTExMTExMTExMTExMTExMTExMTExMTExM=", accept_url: "https://fixture.example.test/session/accept", hire_message_schema: "voidly-session-hire/v1", worker_base_url: "https://fixture.example.test", grant_ttl_ms: { min: 3e5, max: 216e5 }, acceptance_ttl_ms: 3e5, services: [{ ref: "sessions.public.fixture/v1", description: "Offline signature verification fixture only.", price: { chain: "eip155:8453", asset: "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", payee_account: "eip155:8453:0x2222222222222222222222222222222222222222", min_amount: "1", max_amount: "1" } }], payment_buys: "an attempt, not an outcome", notes: ["Public offline fixture. Never contact these example endpoints or use this manifest for a payment."], signature_base64: "1gE/tewhX6oLaymE2i1w2vrR5gzZv3WTz5EzIECoetx4Dma+aVTAZDyzSLDHeHi/fc57mO7Sd6+3cR/WjfcJDA==" }, PROOFS_FIXTURE_DIGEST = "ccf7933183585166962b3244e19df341b6011895daa4fd43337011bc94b0846a";
+var TITLE = "Your proof artwork", DESCRIPTION = "Code-generated artwork for a saved proof. Decorative, not a signed receipt or evidence of identity, payment, or impact.", PALETTES = [[[184, 166, 237], [237, 227, 206]], [[158, 190, 214], [224, 227, 238]], [[219, 185, 171], [194, 176, 230]]];
+function generator(id) {
+  let a = parseInt(id.slice(0, 8), 16) | 0, b = parseInt(id.slice(8, 16), 16) | 0, c = parseInt(id.slice(16, 24), 16) | 0, d = parseInt(id.slice(24, 32), 16) | 0;
+  function next() {
+    let value = (a + b | 0) + d | 0;
+    return d = d + 1 | 0, a = b ^ b >>> 9, b = c + (c << 3) | 0, c = (c << 21 | c >>> 11) + value | 0, (value >>> 0) / 4294967296;
+  }
+  for (let index = 0; index < 16; index++) next();
+  return next;
+}
+function proofArtworkSvg(id) {
+  if (typeof id != "string" || !/^[0-9a-f]{32}$/.test(id)) throw new Error("Artwork requires a valid saved proof event ID.");
+  let random = generator(id), palette = PALETTES[Math.floor(random() * PALETTES.length)], rotation = random() * Math.PI * 2, phase = random() * Math.PI * 2, lobes = 2 + Math.floor(random() * 4), twist = (random() - 0.5) * 4.8, amplitude = 0.07 + random() * 0.12, stretch = 0.58 + random() * 0.4, driftX = (random() - 0.5) * 54, driftY = (random() - 0.5) * 54, aperture = 5 + random() * 23, power = 0.75 + random() * 0.75, paths = [];
+  for (let ring = 0; ring < 38; ring++) {
+    let progress = ring / 37, radius = aperture + progress * (102 - aperture), turn = rotation + twist * (1 - progress) ** 2, points = [];
+    for (let sample = 0; sample < 112; sample++) {
+      let angle = sample / 112 * Math.PI * 2, ripple = 1 + Math.sin(angle * lobes + phase + progress) * amplitude + Math.cos(angle * 2 - phase) * 0.025, cos = Math.cos(angle), sin = Math.sin(angle), x = Math.sign(cos) * Math.abs(cos) ** power * radius * ripple, y = Math.sign(sin) * Math.abs(sin) ** power * radius * ripple * stretch, px = 160 + Math.cos(turn) * x - Math.sin(turn) * y + driftX * (1 - progress), py = 160 + Math.sin(turn) * x + Math.cos(turn) * y + driftY * (1 - progress);
+      points.push(`${sample ? "L" : "M"}${px.toFixed(2)} ${py.toFixed(2)}`);
+    }
+    let color = palette[0].map((value, index) => Math.round(value + (palette[1][index] - value) * progress));
+    paths.push(`<path d="${points.join("")}Z" fill="none" stroke="rgb(${color.join(",")})" stroke-width="${ring % 6 === 0 ? 1.4 : 0.9}"/>`);
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="1200" viewBox="0 0 320 320" role="img" aria-label="${TITLE}"><title>${TITLE}</title><desc>${DESCRIPTION}</desc><rect width="320" height="320" fill="#050506"/>${paths.join("")}</svg>`;
+}
+var PUBLIC_EXERCISE_SCHEMA = "voidpay.proof-collection.public-exercise/v3", PUBLIC_RESULT_SCHEMA = "voidpay.proof-collection.public-result/v3", PUBLIC_RESPONSE_SCHEMA = "voidpay.proof-collection.public-response/v3", SESSIONS_PROOFS_TASK = Object.freeze({ id: "sessions-public-check-01", version: 1, acceptance_rule_sha256: "1be9d67c2f8caffa45fd985b7454371838c29e4fadbd8dadc2a4e6663b0f7bc5" }), SESSIONS_PROOFS_PROVIDER = Object.freeze({ provider_did: "did:voidly:6rGTFa5apSnKNF14bGXZfu", manifest_url: "https://intelligence.voidly.ai:8443/.well-known/voidly-session-provider.json", index_url: "https://api.voidly.ai/v1/session/providers" }), PUBLIC_EXERCISE_MAX_BYTES = 8192, PUBLIC_EXERCISE_TTL_MS = 6e5, WRONG_PIN = "did:voidly:2222222222222222", HEX32 = /^[0-9a-f]{32}$/, HEX64 = /^[0-9a-f]{64}$/, PublicExerciseError = class extends Error {
+  constructor(code) {
+    super(code), this.name = "PublicExerciseError", this.code = code;
+  }
+};
+function requireCondition(value, code) {
+  if (!value) throw new PublicExerciseError(code);
+}
+function plain(value) {
+  return value !== null && typeof value == "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function exact(value, keys) {
+  return plain(value) && Object.keys(value).length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function same(value, expected) {
+  return exact(value, Object.keys(expected)) && Object.entries(expected).every(([key, field]) => value[key] === field);
+}
+function iso(value) {
+  return typeof value == "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString() === value;
+}
+function parsePublicExercise(text, nowMs = Date.now()) {
+  requireCondition(typeof text == "string" && new TextEncoder().encode(text).length <= PUBLIC_EXERCISE_MAX_BYTES, "exercise_invalid");
+  let input2;
+  try {
+    input2 = JSON.parse(text);
+  } catch {
+    throw new PublicExerciseError("exercise_invalid");
+  }
+  return requireCondition(exact(input2, ["schema", "task", "challenge_id", "challenge", "issued_at", "expires_at", "provider"]), "exercise_invalid"), requireCondition(input2.schema === PUBLIC_EXERCISE_SCHEMA && same(input2.task, SESSIONS_PROOFS_TASK) && same(input2.provider, SESSIONS_PROOFS_PROVIDER) && typeof input2.challenge_id == "string" && HEX32.test(input2.challenge_id) && typeof input2.challenge == "string" && HEX64.test(input2.challenge) && iso(input2.issued_at) && iso(input2.expires_at), "exercise_invalid"), requireCondition(Number.isFinite(nowMs) && Date.parse(input2.expires_at) - Date.parse(input2.issued_at) === PUBLIC_EXERCISE_TTL_MS && Date.parse(input2.issued_at) <= nowMs + 3e4, "exercise_invalid"), requireCondition(Date.parse(input2.expires_at) > nowMs, "exercise_expired"), { schema: PUBLIC_EXERCISE_SCHEMA, task: SESSIONS_PROOFS_TASK, challenge_id: input2.challenge_id, challenge: input2.challenge, issued_at: input2.issued_at, expires_at: input2.expires_at, provider: SESSIONS_PROOFS_PROVIDER };
+}
+async function runSessionsSelfTest() {
+  let found = verifyProvider(PROOFS_FIXTURE, PROOFS_FIXTURE.provider_did), wrong = verifyProvider(PROOFS_FIXTURE, WRONG_PIN), altered = verifyProvider({ ...PROOFS_FIXTURE, accept_url: "https://changed.example.test/accept" }, PROOFS_FIXTURE.provider_did), digest = found.ok ? await sha256Hex(canonicalBytes(found.provider.manifest)) : null, checks = { signed_manifest_verified: found.ok, wrong_pin_refused: !wrong.ok && wrong.reason === "manifest_did_not_pinned", changed_manifest_refused: !altered.ok && altered.reason === "manifest_signature_invalid", canonical_digest_matches: digest === PROOFS_FIXTURE_DIGEST };
+  return { schema: "voidly.session.self-test/v1", ok: Object.values(checks).every(Boolean), mode: "offline", checks, network_requests: 0, saved_proof: false };
+}
+async function verifyPublicExercise(exercise, index, manifest, nowMs = Date.now()) {
+  let parsed = parsePublicExercise(JSON.stringify(exercise), nowMs);
+  requireCondition(plain(index) && Array.isArray(index.providers) && index.providers.length <= 1e3 && index.providers.some((entry) => plain(entry) && entry.provider_did === SESSIONS_PROOFS_PROVIDER.provider_did && entry.manifest_url === SESSIONS_PROOFS_PROVIDER.manifest_url), "provider_not_listed");
+  let verified = verifyProvider(manifest, SESSIONS_PROOFS_PROVIDER.provider_did);
+  requireCondition(verified.ok, "manifest_invalid");
+  let wrong = verifyProvider(verified.provider.manifest, WRONG_PIN);
+  requireCondition(!wrong.ok && wrong.reason === "manifest_did_not_pinned", "wrong_pin_not_refused");
+  let manifest_digest_sha256 = await sha256Hex(canonicalBytes(verified.provider.manifest)), challenge_response_sha256 = await sha256Hex(canonicalBytes({ schema: PUBLIC_RESPONSE_SCHEMA, task: parsed.task, challenge_id: parsed.challenge_id, challenge: parsed.challenge, manifest_digest_sha256 }));
+  return { schema: PUBLIC_RESULT_SCHEMA, task: parsed.task, challenge_id: parsed.challenge_id, challenge: parsed.challenge, manifest_digest_sha256, challenge_response_sha256, checks: { provider_pair_listed: true, manifest_verified: true, wrong_pin_refused: true } };
+}
+async function readFixedJson(url, maxBytes, fetchImpl) {
+  let controller = new AbortController(), timer, reader, deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort(), reject(new PublicExerciseError("upstream_unavailable"));
+    }, 8e3);
+  });
+  try {
+    let response = await Promise.race([fetchImpl(url, { method: "GET", headers: { accept: "application/json" }, redirect: "error", credentials: "omit", cache: "no-store", referrerPolicy: "no-referrer", signal: controller.signal }), deadline]);
+    requireCondition(!response.redirected && (response.url === "" || response.url === url), "upstream_redirect"), requireCondition(response.ok && response.body, "upstream_unavailable"), requireCondition(/^application\/json(?:\s*;|$)/i.test(response.headers.get("content-type") ?? ""), "upstream_not_json");
+    let contentLength = response.headers.get("content-length");
+    requireCondition(contentLength === null || /^\d+$/.test(contentLength) && Number(contentLength) <= maxBytes, "upstream_too_large"), reader = response.body.getReader();
+    let chunks = [], size = 0;
+    for (; ; ) {
+      let part = await Promise.race([reader.read(), deadline]);
+      if (part.done) break;
+      size += part.value.byteLength, requireCondition(size <= maxBytes, "upstream_too_large"), chunks.push(part.value);
+    }
+    let bytes = new Uint8Array(size), offset = 0;
+    for (let chunk of chunks) bytes.set(chunk, offset), offset += chunk.byteLength;
+    try {
+      return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    } catch {
+      throw new PublicExerciseError("upstream_not_json");
+    }
+  } catch (error) {
+    throw error instanceof PublicExerciseError ? error : new PublicExerciseError("upstream_unavailable");
+  } finally {
+    clearTimeout(timer), controller.abort(), reader && (reader.cancel().catch(() => {
+    }), reader.releaseLock());
+  }
+}
+async function runPublicExercise(text, options = {}) {
+  let nowMs = options.nowMs ?? Date.now(), exercise = parsePublicExercise(text, nowMs), fetchImpl = options.fetchImpl ?? fetch, index = await readFixedJson(SESSIONS_PROOFS_PROVIDER.index_url, 262144, fetchImpl), manifest = await readFixedJson(SESSIONS_PROOFS_PROVIDER.manifest_url, 65536, fetchImpl);
+  return verifyPublicExercise(exercise, index, manifest, options.nowMs ?? Date.now());
+}
+async function input() {
+  return new Promise((resolve, reject) => {
+    let chunks = [], size = 0, cleanup = () => {
+      clearTimeout(timer), process.stdin.removeListener("data", onData), process.stdin.removeListener("end", onEnd), process.stdin.removeListener("error", onError), process.stdin.pause();
+    }, fail = () => {
+      cleanup(), reject(new Error("input_invalid"));
+    }, onData = (chunk) => {
+      size += chunk.byteLength, size > PUBLIC_EXERCISE_MAX_BYTES ? fail() : chunks.push(chunk);
+    }, onEnd = () => {
+      cleanup();
+      try {
+        resolve(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks)));
+      } catch {
+        reject(new Error("input_invalid"));
+      }
+    }, onError = () => fail(), timer = setTimeout(fail, 3e4);
+    process.stdin.on("data", onData), process.stdin.once("end", onEnd), process.stdin.once("error", onError);
+  });
+}
+async function main() {
+  let [major, minor] = process.versions.node.split(".").map(Number);
+  if (major < 20 || major === 20 && minor < 3) return process.stderr.write(`This CLI requires Node.js 20.3 or newer. No check was run.
+`), 1;
+  let args = process.argv.slice(2);
+  if (args.length === 2 && args[0] === "artwork" && /^[0-9a-f]{32}$/.test(args[1])) return process.stdout.write(proofArtworkSvg(args[1]) + `
+`), process.stderr.write(`Decorative artwork only. The supplied identifier was not checked with a server.
+`), 0;
+  if (args.length !== 1 || !["self-test", "public-check", "--help"].includes(args[0])) return process.stderr.write(`Usage: voidly-session self-test | public-check | artwork <saved-event-id> | --help
+`), 1;
+  if (args[0] === "--help") return process.stdout.write(`self-test: offline SDK verification; no network.
+public-check: public exercise JSON on stdin; two fixed public GETs; result JSON on stdout.
+artwork <saved-event-id>: decorative SVG on stdout, generated locally; no savedness verification.
+These commands do not save proofs, publish or perform payment. Review the installed package before running it.
+`), 0;
+  try {
+    if (args[0] === "self-test") {
+      let result2 = await runSessionsSelfTest();
+      return process.stdout.write(JSON.stringify(result2, null, 2) + `
+`), result2.ok ? 0 : 3;
+    }
+    let result = await runPublicExercise(await input());
+    return process.stdout.write(JSON.stringify(result, null, 2) + `
+`), process.stderr.write(`Public check complete. Import this JSON at https://voidly.ai/pay/proofs and choose Save proof. Nothing has been saved or published by this command.
+`), 0;
+  } catch (error) {
+    return process.stderr.write(`Check stopped: ${error instanceof PublicExerciseError ? error.code : "check_failed"}. No proof was saved.
+`), 1;
+  }
+}
+main().then((code) => {
+  process.exitCode = code;
+});

package/package.json

@@ -1,7 +1,23 @@
 {
   "name": "@voidly/session",
-  "version": "1.0.0",
-  "description": "Client for the Voidly Pay session rail: private hire, verify-only settlement on Base. The rail never holds, custodies or submits funds — the payee relays its own settlement and the verifier's only I/O is read-only JSON-RPC.",
+  "version": "1.1.0",
+  "description": "The voidpay session client. Hire and pay another AI agent for work: non-custodial USDC settlement on Base via signed EIP-3009 authorizations, with x402 facilitator support. The rail never holds, custodies or submits funds — it only verifies.",
+  "keywords": [
+    "agent-payments",
+    "agent-to-agent",
+    "ai-agents",
+    "autonomous-agents",
+    "machine-payments",
+    "eip-3009",
+    "usdc",
+    "stablecoin",
+    "base",
+    "non-custodial",
+    "micropayments",
+    "pay-per-call",
+    "did",
+    "voidly"
+  ],
   "type": "module",
   "repository": {
     "type": "git",
@@ -25,8 +41,16 @@
       "import": "./dist/breakEven.mjs",
       "default": "./dist/breakEven.mjs"
     },
+    "./proofs": {
+      "types": "./dist/proofs.d.ts",
+      "import": "./dist/proofs.mjs",
+      "default": "./dist/proofs.mjs"
+    },
     "./package.json": "./package.json"
   },
+  "bin": {
+    "voidly-session": "./dist/proofsCli.mjs"
+  },
   "files": [
     "dist",
     "README.md",
@@ -45,8 +69,8 @@
     "dry-run": "node scripts/dry-run-base-mainnet-payment.mjs"
   },
   "dependencies": {
-    "tweetnacl": "^1.0.3",
-    "tweetnacl-util": "^0.15.1"
+    "tweetnacl": "1.0.3",
+    "tweetnacl-util": "0.15.1"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",