Verify claims on your backend

// npm install @zktls/claim   (Node 22+)
import { canonicalDecode, loadTrustBundle, verify, type TrustBundle } from "@zktls/claim";

const OPERATOR_KEY = process.env.ZKTLS_TRUST_OPERATOR_KEY!;
let highest = 0n;

async function trustBundle(): Promise<TrustBundle> {
  const json = await (await fetch(process.env.ZKTLS_TRUST_BUNDLE_URL!)).text();
  const bundle = loadTrustBundle(json, OPERATOR_KEY, { minVersion: highest });
  highest = bundle.version;
  return bundle;
}

export async function accept(encoded: string, policyId: string) {
  const claim = canonicalDecode(Buffer.from(encoded, "base64"));
  const outputs = await verify(claim, await trustBundle(), BigInt(Math.floor(Date.now() / 1000)));
  if (claim.policy_id !== policyId) throw new Error(`claim is for ${claim.policy_id}`);
  return { outputs, nullifier: claim.nullifier };   // check the nullifier against your store
}

// go get github.com/Cr3dentials/zktls-consumers/consumers/go/zktlsclaim   (Go 1.27+)
func startBundles(ctx context.Context, pinnedOperatorPEM []byte, url string) (*zktlsclaim.BundleClient, error) {
	key, err := zktlsclaim.ParseOperatorKey(pinnedOperatorPEM)
	if err != nil {
		return nil, err
	}
	bundles := zktlsclaim.NewBundleClient(url, key, nil, nil)
	go bundles.Run(ctx) // every 60 s, highest version only, stale after 30 min
	return bundles, nil
}

func accept(bundles *zktlsclaim.BundleClient, encoded, policyID string) ([]zktlsclaim.TypedOutput, error) {
	raw, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		return nil, err
	}
	c, err := zktlsclaim.ClaimCanonicalDecode(raw)
	if err != nil {
		return nil, err
	}
	b, err := bundles.Current()
	if err != nil {
		return nil, err
	}
	outputs, err := zktlsclaim.VerifyClaim(c, b, uint64(time.Now().Unix()))
	if err != nil {
		return nil, err
	}
	if c.PolicyID != policyID {
		return nil, fmt.Errorf("claim is for %s", c.PolicyID)
	}
	return outputs, nil // then zktlsclaim.ConsumeNullifier(c, yourStore)
}

// cargo add zktls-claim
use zktls_claim::bundle::{load_trust_bundle, OperatorKey};

let key = OperatorKey::from_pem_or_der(PINNED_OPERATOR_PEM.as_bytes())?;
let bundle = load_trust_bundle(&fetched_bundle_json, &key)?;
if bundle.version < highest_seen {
    return Err("a stale trust bundle".into());
}
highest_seen = bundle.version;
let claim = zktls_claim::canonical_decode(&base64_decoded_claim)?;
let outputs = zktls_claim::verify(&claim, &bundle, now_unix_seconds)?;
if claim.policy_id != expected_policy_id {
    return Err("not the policy asked for".into());
}