@guaw/web-sdk (Yerba Buena™ Edition)

Official Physical Integrity Verification SDK for Web Applications Standard: Yerba Buena Universal Physical Standard Status: 🔒 SOVEREIGN - Tier 41.0 (Diplomatic Sovereign & ZK-Supreme)

Installation

npm install @guaw/web-sdk

Quick Start

import { GuawClient } from "@guaw/web-sdk";

const guaw = new GuawClient({
  apiKey: "pk_live_...",
});

// Verify a video file
const result = await guaw.verify(videoFile, {
  onProgress: (progress) => console.log(`${progress}%`),
});

if (result.verdict === "VERIFIED_ORGANIC") {
  console.log("✅ Video verified as organic");
  console.log(`Confidence: ${result.confidence * 100}%`);
} else {
  console.log("❌ Synthetic content detected");
}

Features

• ✅ Client-Side Processing - Never uploads actual content
• ✅ Zero-Knowledge Proofs - Privacy-preserving verification (ZK-Supreme)
• ✅ Physical Metrics - Analyzes the Physical Sovereignty Quadrant:
  • Newton (Jerk/Friction)
  • Einstein (Causality/Latency)
  • Boltzmann (Statistical Entropy)
  • Clausius (Thermodynamic Work-Heat Correlation)
• ✅ Yerba Buena Standard - Anchored in physically falsifiable truth.
• ✅ Sovereign Gate Integration - Verification ready for 3rd-party auditors (Tier 100+ compatible).
• ✅ Video & Image Support - KYC videos, documents, photos
• ✅ Batch Processing - Verify multiple files at once
• ✅ TypeScript - Full type safety

API Reference

GuawClient

const guaw = new GuawClient(config: GUAWConfig);

Config:

• apiKey (required): Your GUAW API key
• apiUrl (optional): Custom API URL (default: https://api.guaw.io/api/v1)
• timeout (optional): Request timeout in ms (default: 30000)

Methods

verify(file, options)

Verify a single file.

const result = await guaw.verify(file, {
  onProgress: (p) => console.log(`${p}%`),
  frameCount: 10, // For videos
  sampleCount: 200, // For images
});

Returns: VerificationResult

{
  verdict: 'VERIFIED_ORGANIC' | 'SYNTHETIC_DETECTED' | 'INCONCLUSIVE',
  confidence: number,
  metrics: {
    beta: number,
    sigma: number
  },
  zkProof: ZKProof,
  fileHash: string,
  certificateId?: string,
  timestamp: number
}

verifyBatch(files, options)

Verify multiple files.

const results = await guaw.verifyBatch([file1, file2, file3], {
  onProgress: (p) => console.log(`Overall: ${p}%`),
});

downloadCertificate(certificateId)

Download verification certificate as PDF.

const pdfBlob = await guaw.downloadCertificate(result.certificateId);
const url = URL.createObjectURL(pdfBlob);
window.open(url);

getCertificateMetadata(certificateId)

Get certificate metadata.

const cert = await guaw.getCertificateMetadata(result.certificateId);
console.log(cert.verdict, cert.confidence);

Examples

React Example

import { useState } from "react";
import { GuawClient } from "@guaw/web-sdk";

const guaw = new GuawClient({ apiKey: process.env.REACT_APP_GUAW_API_KEY });

function VideoVerification() {
  const [progress, setProgress] = useState(0);
  const [result, setResult] = useState(null);

  const handleUpload = async (e) => {
    const file = e.target.files[0];

    const verification = await guaw.verify(file, {
      onProgress: setProgress,
    });

    setResult(verification);
  };

  return (
    <div>
      <input type="file" accept="video/*" onChange={handleUpload} />
      {progress > 0 && <progress value={progress} max={100} />}
      {result && (
        <div>
          {result.verdict === "VERIFIED_ORGANIC" ? "✅" : "❌"}
          {result.verdict} ({(result.confidence * 100).toFixed(1)}%)
        </div>
      )}
    </div>
  );
}

Vue Example

<template>
  <div>
    <input type="file" @change="handleUpload" accept="video/*" />
    <progress v-if="progress" :value="progress" max="100"></progress>
    <div v-if="result">
      {{ result.verdict }} ({{ (result.confidence * 100).toFixed(1) }}%)
    </div>
  </div>
</template>

<script setup>
import { ref } from "vue";
import { GuawClient } from "@guaw/web-sdk";

const guaw = new GuawClient({ apiKey: import.meta.env.VITE_GUAW_API_KEY });
const progress = ref(0);
const result = ref(null);

const handleUpload = async (e) => {
  const file = e.target.files[0];
  result.value = await guaw.verify(file, {
    onProgress: (p) => (progress.value = p),
  });
};
</script>

Vanilla JS Example

<!DOCTYPE html>
<html>
  <head>
    <script type="module">
      import { GuawClient } from "https://unpkg.com/@guaw/web-sdk@latest";

      const guaw = new GuawClient({ apiKey: "pk_live_..." });

      document
        .getElementById("upload")
        .addEventListener("change", async (e) => {
          const file = e.target.files[0];
          const result = await guaw.verify(file, {
            onProgress: (p) => console.log(`${p}%`),
          });

          document.getElementById("result").textContent =
            `${result.verdict} (${(result.confidence * 100).toFixed(1)}%)`;
        });
    </script>
  </head>
  <body>
    <input type="file" id="upload" accept="video/*" />
    <div id="result"></div>
  </body>
</html>

How It Works

1. Client-Side Processing: File is processed locally in the browser using the Yerba Buena Standard.
2. Metric Extraction: Extracts physical metrics (Beta, Sigma, Jerk) from samples.
3. ZK-Proof Generation: Creates cryptographic proof (Groth16) without exposing data.
4. Sovereign Gate Verification: Sends proof and metrics to the GUAW Sovereign Gate (Tier 41.0).
5. Result: Receives verdict and optional signed certificate.

Privacy

• ✅ No file upload: Only metrics are transmitted
• ✅ Zero-Knowledge: Proofs don't reveal actual values
• ✅ GDPR compliant: No biometric data stored
• ✅ Client-side: Processing happens in user's browser

Support

• Documentation: https://docs.guaw.io
• Email: [email protected]
• GitHub: https://github.com/guaw/web-sdk

License

MIT