Verify a VAID without talking to us.

use base64::Engine;
use ring::rand::SystemRandom;
use ring::signature::{Ed25519KeyPair, KeyPair};
use sha2::{Digest, Sha256};
use vaid_client::RequestSigner;
use vaid_mint::{verify_vaid_authenticity, AgentClass, ReferenceIssuer, TenantId, VaidIssuer};
use vaid_pop::{request_auth::RequestAuthPayload, vaid_pop::verify_signed_payload};

fn main() {
    let pkcs8 = Ed25519KeyPair::generate_pkcs8(&SystemRandom::new()).unwrap();
    let agent_key = Ed25519KeyPair::from_pkcs8(pkcs8.as_ref()).unwrap();  // the agent holds this
    let issuer = ReferenceIssuer::ephemeral(24, "vaid.example").unwrap(); // your own mint
    let vaid = issuer.issue_vaid_with_key(
        AgentClass::new("orchestrator"), "1.0.0".into(), TenantId::new("acme"), None,
        vec!["data.acme".into()], vec!["read".into()],
        agent_key.public_key().as_ref().to_vec()).unwrap();

    let body = br#"{"query": "select 1"}"#;
    let signer = RequestSigner::from_vaid_json(&serde_json::to_vec(&vaid).unwrap(), agent_key).unwrap();
    let headers = signer.sign_headers("POST", "/query", body).unwrap();

    // Verifier side: public keys and the request. No call to the mint.
    let payload = RequestAuthPayload {
        vaid_id: vaid.vaid_id(), method: "POST".into(), path: "/query".into(),
        body_sha256: hex::encode(Sha256::digest(body)), tenant_id: vaid.tenant_id().as_str().into(),
        timestamp: headers.timestamp.parse().unwrap(), client_nonce: headers.nonce.clone(),
    };
    let sig = base64::engine::general_purpose::STANDARD.decode(&headers.signature).unwrap();

    println!("vaid authentic: {}", verify_vaid_authenticity(issuer.kernel_public_key(), &vaid));
    println!("request signed by holder: {}", verify_signed_payload(&payload, vaid.public_key_der(), &sig));
}

import base64, hashlib
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from vaid_mint import ReferenceIssuer, verify_vaid_authenticity
from vaid_pop import RequestSigner, build_request_auth_payload, verify_signed_payload

agent_key = Ed25519PrivateKey.generate()               # the agent holds this
issuer = ReferenceIssuer.ephemeral(24, "vaid.example") # your own mint
vaid = issuer.issue_vaid_with_key(
    agent_class="orchestrator", version="1.0.0", tenant_id="acme",
    parent_vaid=None, scope_boundary=["data.acme"], capability_set=["read"],
    public_key_der=agent_key.public_key().public_bytes_raw())

body = b'{"query": "select 1"}'
headers = RequestSigner(vaid=vaid, private_key=agent_key).sign_headers("POST", "/query", body)

# Verifier side: public keys and the request. No call to the mint.
payload = build_request_auth_payload(
    vaid_id=vaid["vaid_id"], method="POST", path="/query",
    body_sha256=hashlib.sha256(body).hexdigest(), tenant_id=vaid["tenant_id"],
    timestamp=headers["x-synthera-timestamp"], client_nonce=headers["x-synthera-nonce"])
signature = base64.b64decode(headers["x-synthera-signature"])

print("vaid authentic:", verify_vaid_authenticity(issuer.kernel_public_key(), vaid))
print("request signed by holder:", verify_signed_payload(payload, vaid["public_key_der"], signature))