@sonate/verify-sdk 2.0.0

package/README.md

@@ -0,0 +1,153 @@
+# @sonate/verify-sdk
+
+[![npm version](https://img.shields.io/npm/v/@sonate/verify-sdk.svg)](https://www.npmjs.com/package/@sonate/verify-sdk)
+[![license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Client-side SDK for verifying SONATE Trust Receipts. Works in Node.js and browsers — zero backend calls required.
+
+## Install
+
+```bash
+npm install @sonate/verify-sdk
+```
+
+## Quick Start
+
+```typescript
+import { verify, fetchPublicKey } from '@sonate/verify-sdk';
+
+// Fetch the SONATE public key (or provide your own)
+const publicKey = await fetchPublicKey();
+
+// Verify a receipt
+const result = await verify(receipt, publicKey);
+
+if (result.valid) {
+  console.log('All checks passed');
+  console.log('Trust score:', result.trustScore);
+} else {
+  console.error('Verification failed:', result.errors);
+}
+```
+
+## API
+
+### `verify(receipt, publicKey)`
+
+Full verification with detailed check results.
+
+```typescript
+const result = await verify(receipt, publicKey);
+
+// result.valid — overall pass/fail
+// result.checks.structure — required fields present
+// result.checks.signature — Ed25519 signature valid
+// result.checks.chain — hash chain intact
+// result.checks.timestamp — timestamp reasonable
+// result.trustScore — extracted from telemetry (0-100)
+// result.errors — array of error messages
+```
+
+### `quickVerify(receipt, publicKey)`
+
+Boolean-only verification for simple pass/fail checks.
+
+```typescript
+const isValid = await quickVerify(receipt, publicKey);
+```
+
+### `verifyBatch(receipts, publicKey)`
+
+Verify multiple receipts at once.
+
+```typescript
+const { total, valid, invalid, results } = await verifyBatch(receipts, publicKey);
+```
+
+### `fetchPublicKey(url?)`
+
+Fetch a SONATE public key from a backend endpoint.
+
+```typescript
+// Default: fetches from SONATE platform
+const key = await fetchPublicKey();
+
+// Custom endpoint
+const key = await fetchPublicKey('https://your-server.com/api/public-key');
+```
+
+### `canonicalize(obj)`
+
+Deterministic JSON serialization (RFC 8785). Useful for building custom verification flows.
+
+```typescript
+import { canonicalize } from '@sonate/verify-sdk';
+
+const canonical = canonicalize({ b: 2, a: 1 });
+// '{"a":1,"b":2}'
+```
+
+## Verification Checks
+
+| Check | What it verifies |
+|-------|-----------------|
+| **Structure** | Receipt has `id`, `timestamp`, and `signature` fields |
+| **Signature** | Ed25519 signature over canonical receipt content |
+| **Chain** | `chain_hash` matches `SHA-256(canonical_content + previous_hash)` |
+| **Timestamp** | Not in the future, not older than 1 year |
+
+## Browser Support
+
+The SDK uses Web Crypto API in browsers and falls back to Node.js `crypto` module. Ed25519 operations use `@noble/ed25519` for cross-platform compatibility.
+
+```html
+<script type="module">
+  import { verify, fetchPublicKey } from '@sonate/verify-sdk';
+
+  const publicKey = await fetchPublicKey();
+  const result = await verify(receiptFromAPI, publicKey);
+  console.log('Valid:', result.valid);
+</script>
+```
+
+## Receipt Format
+
+The SDK verifies V2 Trust Receipts:
+
+```typescript
+interface TrustReceipt {
+  id: string;              // SHA-256 of canonical content
+  version: '2.0.0';
+  timestamp: string;       // ISO 8601
+  session_id: string;
+  agent_did: string;       // did:web:...
+  human_did: string;
+  mode: 'constitutional' | 'directive';
+  interaction: {
+    prompt?: string;        // Raw content (when included)
+    response?: string;
+    prompt_hash?: string;   // SHA-256 hash (privacy-preserving)
+    response_hash?: string;
+    model: string;
+  };
+  chain: {
+    previous_hash: string;
+    chain_hash: string;
+  };
+  signature: {
+    algorithm: 'Ed25519';
+    value: string;          // Hex-encoded
+    key_version: string;
+  };
+}
+```
+
+## Related Packages
+
+- [`@sonate/trust-receipts`](https://www.npmjs.com/package/@sonate/trust-receipts) — Generate signed receipts in your own applications
+- [`@sonate/schemas`](https://www.npmjs.com/package/@sonate/schemas) — JSON Schema + TypeScript types
+- [`@sonate/core`](https://www.npmjs.com/package/@sonate/core) — Core trust protocol implementation
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,171 @@
+/**
+ * SONATE Verify SDK
+ *
+ * Client-side SDK for verifying trust receipts in Node.js and browsers.
+ * Zero backend calls required - cryptographic verification is local.
+ *
+ * @example
+ * ```typescript
+ * import { verify, fetchPublicKey } from '@sonate/verify-sdk';
+ *
+ * const publicKey = await fetchPublicKey();
+ * const result = await verify(receipt, publicKey);
+ *
+ * if (result.valid) {
+ *   console.log('All checks passed');
+ * }
+ * ```
+ */
+interface TrustReceipt {
+    /** V2 receipt ID (SHA-256 hash of canonical content) */
+    id: string;
+    /** Receipt schema version */
+    version: '2.0.0';
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** Session identifier */
+    session_id: string;
+    /** DID of the AI agent */
+    agent_did: string;
+    /** DID of the human user */
+    human_did: string;
+    /** Policy version */
+    policy_version?: string;
+    /** Governance mode */
+    mode: 'constitutional' | 'directive';
+    /** AI interaction data */
+    interaction: {
+        prompt?: string;
+        response?: string;
+        prompt_hash?: string;
+        response_hash?: string;
+        model: string;
+        provider?: string;
+        temperature?: number;
+        max_tokens?: number;
+        reasoning?: {
+            thought_process?: string;
+            confidence?: number;
+            retrieved_context?: string[];
+        };
+    };
+    /** Trust metrics */
+    telemetry?: {
+        resonance_score?: number;
+        resonance_rm?: number;
+        trust_resonance_gap?: number;
+        overall_trust_score?: number;
+        resonance_quality?: string;
+        bedau_index?: number;
+        coherence_score?: number;
+        truth_debt?: number;
+        volatility?: number;
+        ciq_metrics?: {
+            clarity?: number;
+            integrity?: number;
+            quality?: number;
+        };
+    };
+    /** Policy state */
+    policy_state?: Record<string, any>;
+    /** Hash chain for immutability */
+    chain: {
+        previous_hash: string;
+        chain_hash: string;
+        chain_length?: number;
+    };
+    /** Cryptographic signature */
+    signature: {
+        algorithm: 'Ed25519';
+        value: string;
+        key_version: string;
+        timestamp_signed?: string;
+        public_key?: string;
+    };
+    /** Optional metadata */
+    metadata?: Record<string, any>;
+    /** @deprecated Use `id` instead */
+    self_hash?: string;
+}
+interface VerificationResult {
+    valid: boolean;
+    checks: {
+        structure: {
+            passed: boolean;
+            message: string;
+        };
+        signature: {
+            passed: boolean;
+            message: string;
+        };
+        chain: {
+            passed: boolean;
+            message: string;
+        };
+        timestamp: {
+            passed: boolean;
+            message: string;
+        };
+    };
+    trustScore: number | null;
+    errors: string[];
+    receipt: TrustReceipt;
+}
+interface PublicKeyInfo {
+    publicKey: string;
+    algorithm: string;
+    format: string;
+    keyId?: string;
+}
+/**
+ * Fetch the SONATE platform public key
+ */
+declare function fetchPublicKey(url?: string): Promise<string>;
+/**
+ * Canonicalize object for signing (deterministic JSON)
+ *
+ * CRITICAL: This function MUST produce identical output to:
+ * - receipt-generator.ts canonicalize()
+ * - public-demo.routes.ts canonicalize()
+ *
+ * Rules:
+ * - Recursively sort keys at every nesting level
+ * - Filter out undefined values
+ * - Arrays preserve order
+ */
+declare function canonicalize(obj: any): string;
+/**
+ * Verify a SONATE trust receipt
+ *
+ * @param receipt - The trust receipt to verify
+ * @param publicKey - The SONATE public key (hex string)
+ * @returns Verification result with detailed checks
+ */
+declare function verify(receipt: TrustReceipt, publicKey: string): Promise<VerificationResult>;
+/**
+ * Quick verification - returns boolean only
+ */
+declare function quickVerify(receipt: TrustReceipt, publicKey: string): Promise<boolean>;
+/**
+ * Verify a batch of receipts
+ */
+declare function verifyBatch(receipts: TrustReceipt[], publicKey: string): Promise<{
+    total: number;
+    valid: number;
+    invalid: number;
+    results: VerificationResult[];
+}>;
+/**
+ * Calculate trust score from CIQ metrics
+ */
+declare function calculateTrustScore(ciqMetrics: {
+    clarity?: number;
+    integrity?: number;
+    quality?: number;
+}): number;
+/**
+ * Check if a receipt is from a trusted issuer
+ */
+declare function isTrustedIssuer(receipt: TrustReceipt, trustedIssuers: string[]): boolean;
+
+export { type PublicKeyInfo, type TrustReceipt, type VerificationResult, calculateTrustScore, canonicalize, fetchPublicKey, isTrustedIssuer, quickVerify, verify, verifyBatch };

package/dist/index.d.ts

@@ -0,0 +1,171 @@
+/**
+ * SONATE Verify SDK
+ *
+ * Client-side SDK for verifying trust receipts in Node.js and browsers.
+ * Zero backend calls required - cryptographic verification is local.
+ *
+ * @example
+ * ```typescript
+ * import { verify, fetchPublicKey } from '@sonate/verify-sdk';
+ *
+ * const publicKey = await fetchPublicKey();
+ * const result = await verify(receipt, publicKey);
+ *
+ * if (result.valid) {
+ *   console.log('All checks passed');
+ * }
+ * ```
+ */
+interface TrustReceipt {
+    /** V2 receipt ID (SHA-256 hash of canonical content) */
+    id: string;
+    /** Receipt schema version */
+    version: '2.0.0';
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** Session identifier */
+    session_id: string;
+    /** DID of the AI agent */
+    agent_did: string;
+    /** DID of the human user */
+    human_did: string;
+    /** Policy version */
+    policy_version?: string;
+    /** Governance mode */
+    mode: 'constitutional' | 'directive';
+    /** AI interaction data */
+    interaction: {
+        prompt?: string;
+        response?: string;
+        prompt_hash?: string;
+        response_hash?: string;
+        model: string;
+        provider?: string;
+        temperature?: number;
+        max_tokens?: number;
+        reasoning?: {
+            thought_process?: string;
+            confidence?: number;
+            retrieved_context?: string[];
+        };
+    };
+    /** Trust metrics */
+    telemetry?: {
+        resonance_score?: number;
+        resonance_rm?: number;
+        trust_resonance_gap?: number;
+        overall_trust_score?: number;
+        resonance_quality?: string;
+        bedau_index?: number;
+        coherence_score?: number;
+        truth_debt?: number;
+        volatility?: number;
+        ciq_metrics?: {
+            clarity?: number;
+            integrity?: number;
+            quality?: number;
+        };
+    };
+    /** Policy state */
+    policy_state?: Record<string, any>;
+    /** Hash chain for immutability */
+    chain: {
+        previous_hash: string;
+        chain_hash: string;
+        chain_length?: number;
+    };
+    /** Cryptographic signature */
+    signature: {
+        algorithm: 'Ed25519';
+        value: string;
+        key_version: string;
+        timestamp_signed?: string;
+        public_key?: string;
+    };
+    /** Optional metadata */
+    metadata?: Record<string, any>;
+    /** @deprecated Use `id` instead */
+    self_hash?: string;
+}
+interface VerificationResult {
+    valid: boolean;
+    checks: {
+        structure: {
+            passed: boolean;
+            message: string;
+        };
+        signature: {
+            passed: boolean;
+            message: string;
+        };
+        chain: {
+            passed: boolean;
+            message: string;
+        };
+        timestamp: {
+            passed: boolean;
+            message: string;
+        };
+    };
+    trustScore: number | null;
+    errors: string[];
+    receipt: TrustReceipt;
+}
+interface PublicKeyInfo {
+    publicKey: string;
+    algorithm: string;
+    format: string;
+    keyId?: string;
+}
+/**
+ * Fetch the SONATE platform public key
+ */
+declare function fetchPublicKey(url?: string): Promise<string>;
+/**
+ * Canonicalize object for signing (deterministic JSON)
+ *
+ * CRITICAL: This function MUST produce identical output to:
+ * - receipt-generator.ts canonicalize()
+ * - public-demo.routes.ts canonicalize()
+ *
+ * Rules:
+ * - Recursively sort keys at every nesting level
+ * - Filter out undefined values
+ * - Arrays preserve order
+ */
+declare function canonicalize(obj: any): string;
+/**
+ * Verify a SONATE trust receipt
+ *
+ * @param receipt - The trust receipt to verify
+ * @param publicKey - The SONATE public key (hex string)
+ * @returns Verification result with detailed checks
+ */
+declare function verify(receipt: TrustReceipt, publicKey: string): Promise<VerificationResult>;
+/**
+ * Quick verification - returns boolean only
+ */
+declare function quickVerify(receipt: TrustReceipt, publicKey: string): Promise<boolean>;
+/**
+ * Verify a batch of receipts
+ */
+declare function verifyBatch(receipts: TrustReceipt[], publicKey: string): Promise<{
+    total: number;
+    valid: number;
+    invalid: number;
+    results: VerificationResult[];
+}>;
+/**
+ * Calculate trust score from CIQ metrics
+ */
+declare function calculateTrustScore(ciqMetrics: {
+    clarity?: number;
+    integrity?: number;
+    quality?: number;
+}): number;
+/**
+ * Check if a receipt is from a trusted issuer
+ */
+declare function isTrustedIssuer(receipt: TrustReceipt, trustedIssuers: string[]): boolean;
+
+export { type PublicKeyInfo, type TrustReceipt, type VerificationResult, calculateTrustScore, canonicalize, fetchPublicKey, isTrustedIssuer, quickVerify, verify, verifyBatch };

package/dist/index.js

@@ -0,0 +1,262 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  calculateTrustScore: () => calculateTrustScore,
+  canonicalize: () => canonicalize,
+  fetchPublicKey: () => fetchPublicKey,
+  isTrustedIssuer: () => isTrustedIssuer,
+  quickVerify: () => quickVerify,
+  verify: () => verify,
+  verifyBatch: () => verifyBatch
+});
+module.exports = __toCommonJS(index_exports);
+var isBrowser = typeof window !== "undefined";
+var DEFAULT_PUBKEY_URL = "https://yseeku-backend.fly.dev/api/public-demo/public-key";
+async function fetchPublicKey(url) {
+  const response = await fetch(url || DEFAULT_PUBKEY_URL);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch public key: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.data?.publicKey || data.publicKey;
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function sha256(message) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(message);
+  if (isBrowser && crypto.subtle) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    return bytesToHex(new Uint8Array(hashBuffer));
+  } else {
+    const nodeCrypto = await import("crypto");
+    return nodeCrypto.createHash("sha256").update(message).digest("hex");
+  }
+}
+async function verifyEd25519(message, signature, publicKey) {
+  try {
+    const ed = await import("@noble/ed25519");
+    if (ed.etc && !ed.etc.sha512Sync) {
+      if (isBrowser && crypto.subtle) {
+        ed.etc.sha512Async = async (message2) => {
+          const hashBuffer = await crypto.subtle.digest("SHA-512", new Uint8Array(message2));
+          return new Uint8Array(hashBuffer);
+        };
+      } else {
+        const nodeCrypto = await import("crypto");
+        ed.etc.sha512Sync = (...m) => new Uint8Array(nodeCrypto.createHash("sha512").update(m[0]).digest());
+      }
+    }
+    return await ed.verifyAsync(signature, message, publicKey);
+  } catch (error) {
+    console.error("Ed25519 verification error:", error);
+    return false;
+  }
+}
+function canonicalize(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) {
+    return "[" + obj.map(canonicalize).join(",") + "]";
+  }
+  const sortedKeys = Object.keys(obj).sort();
+  const pairs = sortedKeys.filter((key) => obj[key] !== void 0).map((key) => JSON.stringify(key) + ":" + canonicalize(obj[key]));
+  return "{" + pairs.join(",") + "}";
+}
+async function verify(receipt, publicKey) {
+  const result = {
+    valid: false,
+    checks: {
+      structure: { passed: false, message: "" },
+      signature: { passed: false, message: "" },
+      chain: { passed: false, message: "" },
+      timestamp: { passed: false, message: "" }
+    },
+    trustScore: null,
+    errors: [],
+    receipt
+  };
+  try {
+    const receiptId = receipt.id || receipt.self_hash;
+    if (!receiptId || !receipt.signature?.value) {
+      const missing = [];
+      if (!receiptId) missing.push("id");
+      if (!receipt.signature?.value) missing.push("signature");
+      result.checks.structure.message = `Missing required fields: ${missing.join(", ")}`;
+      result.errors.push(result.checks.structure.message);
+      if (receipt.self_hash && !receipt.id) {
+        result.checks.structure.message = 'This receipt uses V1 format (self_hash). V2 format with "id" field is required.';
+        result.errors.push(result.checks.structure.message);
+      }
+    } else {
+      result.checks.structure.passed = true;
+      result.checks.structure.message = "Valid V2 receipt structure";
+    }
+    const signatureValue = receipt.signature?.value;
+    if (signatureValue && publicKey) {
+      const { signature: _sig, ...receiptWithoutSig } = receipt;
+      const canonical = canonicalize(receiptWithoutSig);
+      const messageBytes = new TextEncoder().encode(canonical);
+      const signatureBytes = hexToBytes(signatureValue);
+      const publicKeyBytes = hexToBytes(publicKey);
+      const isValid = await verifyEd25519(messageBytes, signatureBytes, publicKeyBytes);
+      result.checks.signature.passed = isValid;
+      result.checks.signature.message = isValid ? "Ed25519 signature verified" : "Signature verification failed - content may have been tampered";
+      if (!isValid) {
+        result.errors.push("Signature verification failed");
+      }
+    } else {
+      result.checks.signature.message = "No signature or public key provided";
+      result.errors.push(result.checks.signature.message);
+    }
+    if (receipt.chain?.chain_hash && receipt.chain?.previous_hash) {
+      const { signature: _sig, ...receiptWithoutSig } = receipt;
+      const receiptForChain = {
+        ...receiptWithoutSig,
+        chain: { ...receipt.chain, chain_hash: "" }
+      };
+      const contentForChain = canonicalize(receiptForChain);
+      const chainContent = contentForChain + receipt.chain.previous_hash;
+      const expectedChainHash = await sha256(chainContent);
+      const chainValid = expectedChainHash === receipt.chain.chain_hash;
+      result.checks.chain.passed = chainValid;
+      result.checks.chain.message = chainValid ? "Chain hash verified" : "Chain hash mismatch - receipt may have been tampered";
+      if (!chainValid) {
+        result.errors.push("Chain hash verification failed");
+      }
+    } else if (receipt.chain?.previous_hash === "GENESIS") {
+      if (receipt.chain?.chain_hash) {
+        const { signature: _sig, ...receiptWithoutSig } = receipt;
+        const receiptForChain = {
+          ...receiptWithoutSig,
+          chain: { ...receipt.chain, chain_hash: "" }
+        };
+        const contentForChain = canonicalize(receiptForChain);
+        const chainContent = contentForChain + "GENESIS";
+        const expectedChainHash = await sha256(chainContent);
+        const chainValid = expectedChainHash === receipt.chain.chain_hash;
+        result.checks.chain.passed = chainValid;
+        result.checks.chain.message = chainValid ? "Genesis chain hash verified" : "Genesis chain hash mismatch";
+        if (!chainValid) {
+          result.errors.push("Genesis chain hash verification failed");
+        }
+      } else {
+        result.checks.chain.passed = true;
+        result.checks.chain.message = "First receipt in chain (GENESIS)";
+      }
+    } else {
+      result.checks.chain.passed = true;
+      result.checks.chain.message = "Chain verification skipped (no chain data)";
+    }
+    const timestamp = receipt.timestamp;
+    if (timestamp) {
+      const receiptTime = new Date(timestamp);
+      const now = /* @__PURE__ */ new Date();
+      const oneYearAgo = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1e3);
+      const fiveMinutesFromNow = new Date(now.getTime() + 5 * 60 * 1e3);
+      if (receiptTime > fiveMinutesFromNow) {
+        result.checks.timestamp.passed = false;
+        result.checks.timestamp.message = "Timestamp is in the future";
+        result.errors.push(result.checks.timestamp.message);
+      } else if (receiptTime < oneYearAgo) {
+        result.checks.timestamp.passed = false;
+        result.checks.timestamp.message = "Timestamp is older than 1 year";
+        result.errors.push(result.checks.timestamp.message);
+      } else {
+        result.checks.timestamp.passed = true;
+        result.checks.timestamp.message = `Issued ${receiptTime.toISOString()}`;
+      }
+    } else {
+      result.checks.timestamp.passed = false;
+      result.checks.timestamp.message = "No timestamp present";
+      result.errors.push(result.checks.timestamp.message);
+    }
+    if (typeof receipt.telemetry?.overall_trust_score === "number") {
+      result.trustScore = Math.round(receipt.telemetry.overall_trust_score);
+    } else if (receipt.telemetry?.ciq_metrics) {
+      const { clarity = 0, integrity = 0, quality = 0 } = receipt.telemetry.ciq_metrics;
+      result.trustScore = Math.round((clarity + integrity + quality) / 3 * 100);
+    } else if (receipt.telemetry?.resonance_score !== void 0) {
+      result.trustScore = Math.round(receipt.telemetry.resonance_score * 100);
+    }
+    result.valid = result.checks.structure.passed && result.checks.signature.passed && result.checks.chain.passed && result.checks.timestamp.passed;
+  } catch (error) {
+    result.errors.push(`Verification error: ${error}`);
+  }
+  return result;
+}
+async function quickVerify(receipt, publicKey) {
+  const result = await verify(receipt, publicKey);
+  return result.valid;
+}
+async function verifyBatch(receipts, publicKey) {
+  const results = await Promise.all(
+    receipts.map((receipt) => verify(receipt, publicKey))
+  );
+  return {
+    total: receipts.length,
+    valid: results.filter((r) => r.valid).length,
+    invalid: results.filter((r) => !r.valid).length,
+    results
+  };
+}
+function calculateTrustScore(ciqMetrics) {
+  const { clarity = 0, integrity = 0, quality = 0 } = ciqMetrics;
+  return Math.round((clarity + integrity + quality) / 3 * 100);
+}
+function isTrustedIssuer(receipt, trustedIssuers) {
+  const issuer = receipt.issuer;
+  if (!issuer) return false;
+  const issuerId = typeof issuer === "string" ? issuer : issuer.id;
+  return trustedIssuers.some(
+    (trusted) => issuerId === trusted || issuerId.startsWith(trusted)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateTrustScore,
+  canonicalize,
+  fetchPublicKey,
+  isTrustedIssuer,
+  quickVerify,
+  verify,
+  verifyBatch
+});

package/dist/index.mjs

@@ -0,0 +1,221 @@
+// src/index.ts
+var isBrowser = typeof window !== "undefined";
+var DEFAULT_PUBKEY_URL = "https://yseeku-backend.fly.dev/api/public-demo/public-key";
+async function fetchPublicKey(url) {
+  const response = await fetch(url || DEFAULT_PUBKEY_URL);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch public key: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.data?.publicKey || data.publicKey;
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function sha256(message) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(message);
+  if (isBrowser && crypto.subtle) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    return bytesToHex(new Uint8Array(hashBuffer));
+  } else {
+    const nodeCrypto = await import("crypto");
+    return nodeCrypto.createHash("sha256").update(message).digest("hex");
+  }
+}
+async function verifyEd25519(message, signature, publicKey) {
+  try {
+    const ed = await import("@noble/ed25519");
+    if (ed.etc && !ed.etc.sha512Sync) {
+      if (isBrowser && crypto.subtle) {
+        ed.etc.sha512Async = async (message2) => {
+          const hashBuffer = await crypto.subtle.digest("SHA-512", new Uint8Array(message2));
+          return new Uint8Array(hashBuffer);
+        };
+      } else {
+        const nodeCrypto = await import("crypto");
+        ed.etc.sha512Sync = (...m) => new Uint8Array(nodeCrypto.createHash("sha512").update(m[0]).digest());
+      }
+    }
+    return await ed.verifyAsync(signature, message, publicKey);
+  } catch (error) {
+    console.error("Ed25519 verification error:", error);
+    return false;
+  }
+}
+function canonicalize(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) {
+    return "[" + obj.map(canonicalize).join(",") + "]";
+  }
+  const sortedKeys = Object.keys(obj).sort();
+  const pairs = sortedKeys.filter((key) => obj[key] !== void 0).map((key) => JSON.stringify(key) + ":" + canonicalize(obj[key]));
+  return "{" + pairs.join(",") + "}";
+}
+async function verify(receipt, publicKey) {
+  const result = {
+    valid: false,
+    checks: {
+      structure: { passed: false, message: "" },
+      signature: { passed: false, message: "" },
+      chain: { passed: false, message: "" },
+      timestamp: { passed: false, message: "" }
+    },
+    trustScore: null,
+    errors: [],
+    receipt
+  };
+  try {
+    const receiptId = receipt.id || receipt.self_hash;
+    if (!receiptId || !receipt.signature?.value) {
+      const missing = [];
+      if (!receiptId) missing.push("id");
+      if (!receipt.signature?.value) missing.push("signature");
+      result.checks.structure.message = `Missing required fields: ${missing.join(", ")}`;
+      result.errors.push(result.checks.structure.message);
+      if (receipt.self_hash && !receipt.id) {
+        result.checks.structure.message = 'This receipt uses V1 format (self_hash). V2 format with "id" field is required.';
+        result.errors.push(result.checks.structure.message);
+      }
+    } else {
+      result.checks.structure.passed = true;
+      result.checks.structure.message = "Valid V2 receipt structure";
+    }
+    const signatureValue = receipt.signature?.value;
+    if (signatureValue && publicKey) {
+      const { signature: _sig, ...receiptWithoutSig } = receipt;
+      const canonical = canonicalize(receiptWithoutSig);
+      const messageBytes = new TextEncoder().encode(canonical);
+      const signatureBytes = hexToBytes(signatureValue);
+      const publicKeyBytes = hexToBytes(publicKey);
+      const isValid = await verifyEd25519(messageBytes, signatureBytes, publicKeyBytes);
+      result.checks.signature.passed = isValid;
+      result.checks.signature.message = isValid ? "Ed25519 signature verified" : "Signature verification failed - content may have been tampered";
+      if (!isValid) {
+        result.errors.push("Signature verification failed");
+      }
+    } else {
+      result.checks.signature.message = "No signature or public key provided";
+      result.errors.push(result.checks.signature.message);
+    }
+    if (receipt.chain?.chain_hash && receipt.chain?.previous_hash) {
+      const { signature: _sig, ...receiptWithoutSig } = receipt;
+      const receiptForChain = {
+        ...receiptWithoutSig,
+        chain: { ...receipt.chain, chain_hash: "" }
+      };
+      const contentForChain = canonicalize(receiptForChain);
+      const chainContent = contentForChain + receipt.chain.previous_hash;
+      const expectedChainHash = await sha256(chainContent);
+      const chainValid = expectedChainHash === receipt.chain.chain_hash;
+      result.checks.chain.passed = chainValid;
+      result.checks.chain.message = chainValid ? "Chain hash verified" : "Chain hash mismatch - receipt may have been tampered";
+      if (!chainValid) {
+        result.errors.push("Chain hash verification failed");
+      }
+    } else if (receipt.chain?.previous_hash === "GENESIS") {
+      if (receipt.chain?.chain_hash) {
+        const { signature: _sig, ...receiptWithoutSig } = receipt;
+        const receiptForChain = {
+          ...receiptWithoutSig,
+          chain: { ...receipt.chain, chain_hash: "" }
+        };
+        const contentForChain = canonicalize(receiptForChain);
+        const chainContent = contentForChain + "GENESIS";
+        const expectedChainHash = await sha256(chainContent);
+        const chainValid = expectedChainHash === receipt.chain.chain_hash;
+        result.checks.chain.passed = chainValid;
+        result.checks.chain.message = chainValid ? "Genesis chain hash verified" : "Genesis chain hash mismatch";
+        if (!chainValid) {
+          result.errors.push("Genesis chain hash verification failed");
+        }
+      } else {
+        result.checks.chain.passed = true;
+        result.checks.chain.message = "First receipt in chain (GENESIS)";
+      }
+    } else {
+      result.checks.chain.passed = true;
+      result.checks.chain.message = "Chain verification skipped (no chain data)";
+    }
+    const timestamp = receipt.timestamp;
+    if (timestamp) {
+      const receiptTime = new Date(timestamp);
+      const now = /* @__PURE__ */ new Date();
+      const oneYearAgo = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1e3);
+      const fiveMinutesFromNow = new Date(now.getTime() + 5 * 60 * 1e3);
+      if (receiptTime > fiveMinutesFromNow) {
+        result.checks.timestamp.passed = false;
+        result.checks.timestamp.message = "Timestamp is in the future";
+        result.errors.push(result.checks.timestamp.message);
+      } else if (receiptTime < oneYearAgo) {
+        result.checks.timestamp.passed = false;
+        result.checks.timestamp.message = "Timestamp is older than 1 year";
+        result.errors.push(result.checks.timestamp.message);
+      } else {
+        result.checks.timestamp.passed = true;
+        result.checks.timestamp.message = `Issued ${receiptTime.toISOString()}`;
+      }
+    } else {
+      result.checks.timestamp.passed = false;
+      result.checks.timestamp.message = "No timestamp present";
+      result.errors.push(result.checks.timestamp.message);
+    }
+    if (typeof receipt.telemetry?.overall_trust_score === "number") {
+      result.trustScore = Math.round(receipt.telemetry.overall_trust_score);
+    } else if (receipt.telemetry?.ciq_metrics) {
+      const { clarity = 0, integrity = 0, quality = 0 } = receipt.telemetry.ciq_metrics;
+      result.trustScore = Math.round((clarity + integrity + quality) / 3 * 100);
+    } else if (receipt.telemetry?.resonance_score !== void 0) {
+      result.trustScore = Math.round(receipt.telemetry.resonance_score * 100);
+    }
+    result.valid = result.checks.structure.passed && result.checks.signature.passed && result.checks.chain.passed && result.checks.timestamp.passed;
+  } catch (error) {
+    result.errors.push(`Verification error: ${error}`);
+  }
+  return result;
+}
+async function quickVerify(receipt, publicKey) {
+  const result = await verify(receipt, publicKey);
+  return result.valid;
+}
+async function verifyBatch(receipts, publicKey) {
+  const results = await Promise.all(
+    receipts.map((receipt) => verify(receipt, publicKey))
+  );
+  return {
+    total: receipts.length,
+    valid: results.filter((r) => r.valid).length,
+    invalid: results.filter((r) => !r.valid).length,
+    results
+  };
+}
+function calculateTrustScore(ciqMetrics) {
+  const { clarity = 0, integrity = 0, quality = 0 } = ciqMetrics;
+  return Math.round((clarity + integrity + quality) / 3 * 100);
+}
+function isTrustedIssuer(receipt, trustedIssuers) {
+  const issuer = receipt.issuer;
+  if (!issuer) return false;
+  const issuerId = typeof issuer === "string" ? issuer : issuer.id;
+  return trustedIssuers.some(
+    (trusted) => issuerId === trusted || issuerId.startsWith(trusted)
+  );
+}
+export {
+  calculateTrustScore,
+  canonicalize,
+  fetchPublicKey,
+  isTrustedIssuer,
+  quickVerify,
+  verify,
+  verifyBatch
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@sonate/verify-sdk",
+  "version": "2.0.0",
+  "description": "Client-side SDK for verifying SONATE trust receipts",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "vitest run",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
+  },
+  "keywords": [
+    "sonate",
+    "trust",
+    "verification",
+    "ed25519",
+    "receipts",
+    "ai-safety"
+  ],
+  "author": "SONATE",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/s8ken/SONATE-SDK.git",
+    "directory": "packages/verify-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/s8ken/SONATE-SDK/issues"
+  },
+  "homepage": "https://github.com/s8ken/SONATE-SDK/tree/main/packages/verify-sdk#readme",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^4.0.0"
+  },
+  "dependencies": {
+    "@noble/ed25519": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}