SDKs

Python-, TypeScript-, CLI- en Go-SDKs

Attesto biedt vier first-class developer surfaces: Python, TypeScript, Go en de Attesto CLI. Ze delen hetzelfde Proofstream protocol, dezelfde golden vectors, verifier matrix, production origin en regels voor secret-handling.

Article 13 support en Article 12 evidence met één integratieregel

Voor high-risk AI-systemen gaat Article 12 over technische logging-capability en traceerbaarheid, terwijl Article 13 transparantie en bruikbare informatie richting deployers en gebruikers raakt. In Attesto-termen is de exacte integratieregel export OPENAI_BASE_URL=http://localhost:8765/v1: daarmee wijs je OpenAI-compatible calls naar de Attesto Gateway en kan automatische evidence capture starten. Het deterministische Article 12 report legt uit wat is vastgelegd en onafhankelijk verifieerbaar is, en dezelfde receipt-backed trail kan Article 13-documentatie ondersteunen. Dit is bewijs-ondersteuning, geen juridische conformiteitsverklaring.

De concrete one-line gateway-integratie die dit waar maakt is:

export OPENAI_BASE_URL=http://localhost:8765/v1

Vervang localhost in productie door de gedeployde gateway host en bewaar zowel de provider key als de Attesto system key in server-side secret storage.

Gebruik dit patroon wanneer je een Python function boundary beheert. De decorator legt commitments over argumenten, return value, timing, source reference en failures vast; het report vat coverage samen zonder LLM.

from attesto import AttestoV2Client, attest, article12
import os

with AttestoV2Client(api_key=os.environ["ATTESTO_API_KEY"]) as capture:
    @attest(capture, stream_id="str_...")
    def score_case(case: dict) -> dict:
        return {"decision": "manual_review", "policy_id": "policy-2026-01"}

    score_case({"case_id": "case-2026-0001"})
with AttestoV2Client.with_bearer_token(os.environ["ATTESTO_TENANT_TOKEN"]) as operator:
    print(article12(operator, "str_..."))

De capture path gebruikt een system API key; de report path leest tenant stream events en vereist daarom een tenant/operator bearer token.

attesto --token-env ATTESTO_TENANT_TOKEN \
  report article12 --stream str_... --output report.md

Wat de SDK afhandelt

De SDKs zijn bewust dunne server-side clients. Ze verbergen het evidence model niet, maar verwijderen repetitief transportwerk zodat je applicatie zich kan richten op de juiste event shape en het verifiëren van teruggegeven evidence.

Capability matrix

Python

pip install attesto

import os
from datetime import UTC, datetime
from attesto import AttestoClient

attesto = AttestoClient(api_key=os.environ["ATTESTO_API_KEY"])
ack = attesto.log_event(
    type="inference",
    status="verified",
    ts=datetime.now(UTC),
    payload={
        "model": "risk-service-v4",
        "score": 0.91,
        "policy_id": "policy-2026-01",
    },
)
print(ack.id)

Python async

import os
from datetime import UTC, datetime
from attesto import AsyncAttestoClient

async with AsyncAttestoClient(api_key=os.environ["ATTESTO_API_KEY"]) as attesto:
    ack = await attesto.log_event(
        type="ai.decision",
        status="verified",
        ts=datetime.now(UTC),
        payload={"decision": "manual_review", "score": 91},
    )
    print(ack.id)

TypeScript

npm install @attesto/sdk

import { AttestoClient } from "@attesto/sdk";

const attesto = new AttestoClient({
  apiKey: process.env.ATTESTO_API_KEY!,
});

const ack = await attesto.logEvent({
  type: "inference",
  status: "verified",
  ts: new Date(),
  payload: {
    model: "risk-service-v4",
    score: 0.91,
    policy_id: "policy-2026-01",
  },
});
console.log(ack.id);

TypeScript attestedFetch

Gebruik attestedFetch wanneer een OpenAI-compatible SDK of framework een custom fetch implementation accepteert. Het registreert alleen commitments, nooit raw prompts of completions. strict: true faalt gesloten wanneer evidence niet kan worden ingestuurd; fail-open mode moet gemonitord worden.

import { AttestoV2Client, attestedFetch } from "@attesto/sdk";

const client = new AttestoV2Client({ apiKey: process.env.ATTESTO_API_KEY! });
const fetchWithEvidence = attestedFetch(client, {
  streamId: "str_...",
  capture: "commitments",
  strict: true,
});

Proofstream v2 client

Gebruik AttestoV2Client wanneer je stream-level receipts, checkpoint consistency, witness policy visibility, verifier bundles en offline verification helpers nodig hebt.

from attesto import AttestoV2Client
from datetime import UTC, datetime
import os

with AttestoV2Client(api_key=os.environ["ATTESTO_API_KEY"]) as attesto:
    stream = attesto.create_stream(
        use_case="ai-decision-history",
        policy_id="policy-2026-01",
    )
    receipt = attesto.log_event(
        stream_id=stream.stream_id,
        source_ref="source-event-001",
        event_type="decision",
        occurred_at=datetime.now(UTC),
        payload={"decision": "review", "score": 91},
    )
    stored = attesto.get_receipt(receipt.stream_event_id)
    report = attesto.verify_receipt(
        receipt=stored.receipt,
        public_key_hex=os.environ["ATTESTO_RECEIPT_SIGNER_PUBLIC_KEY_HEX"],
        stream_event_id=receipt.stream_event_id,
    )
    assert report.ok

TypeScript Proofstream:

import { AttestoV2Client } from "@attesto/sdk";

const attesto = new AttestoV2Client({
  apiKey: process.env.ATTESTO_API_KEY!,
});

const stream = await attesto.createStream({
  useCase: "ai-decision-history",
  policyId: "policy-2026-01",
});

const receipt = await attesto.logEvent(stream.streamId, {
  sourceRef: "case-2026-0001:decision-1",
  eventType: "ai.decision",
  occurredAt: new Date(),
  payload: { decision: "manual_review", score: 91 },
});

const report = await attesto.verifyReceipt({
  receipt: receipt.receipt,
  streamEventId: receipt.streamEventId,
  publicKeyHex: process.env.ATTESTO_RECEIPT_SIGNER_PUBLIC_KEY_HEX!,
});
if (!report.ok) throw new Error(report.problems.join("; "));

Go

Gebruik Go voor infrastructure automation, security tooling, cloud workers en verifier services. De Go SDK gebruikt momenteel alleen de Go standard library en wordt resolved vanaf het publieke go.attesto.eu/sdk module path.

go get go.attesto.eu/sdk

package main

import (
  "context"
  "fmt"
  "log"
  "os"

  attesto "go.attesto.eu/sdk"
)

func main() {
  client, err := attesto.NewClient(os.Getenv("ATTESTO_API_KEY"))
  if err != nil {
    log.Fatal(err)
  }

  stream, err := client.CreateStream(context.Background(), attesto.StreamCreateInput{
    UseCase: "ai-decision-history",
    PolicyID: "policy-2026-01",
  })
  if err != nil {
    log.Fatal(err)
  }

  receipt, err := client.LogEvent(context.Background(), stream.StreamID, attesto.EventInput{
    SourceRef: "case-2026-0001:decision-1",
    EventType: "ai.decision",
    Payload: attesto.M{"decision": "manual_review", "score": 91},
  })
  if err != nil {
    log.Fatal(err)
  }

  fmt.Println(receipt.StreamEventID, receipt.EventHash)
}

CLI

De Attesto CLI is de operator- en verifier surface voor scripted workflows. De CLI ondersteunt JSON output, local config, stream/event actions, receipt verification, bundle verification, fork evidence, quorum evidence, connectors, Local Vault en release-readiness evidence checks. De CLI print nooit opgeslagen API keys, tenant tokens of connector secrets.

Installeer de gesigneerde CLI via get.attesto.eu. De installers verifiëren de SHA256-checksum van de release vóór er iets wordt geïnstalleerd, en de handtekening op het manifest is met cosign te verifiëren. De Homebrew-formula en de native Linux-packages herverpakken dezelfde kanaal-binaries: hun hashes komen uit het cosign-gesigneerde SHA256SUMS-manifest, nooit uit een aparte build:

# Linux / macOS
curl -fsSL https://get.attesto.eu | sh

# Windows (PowerShell; user-level install, no admin rights)
irm https://get.attesto.eu/install.ps1 | iex

# macOS / Linux (Homebrew)
brew tap attesto/attesto https://git.attesto.eu/attesto/homebrew-attesto.git
brew trust attesto/attesto
brew install attesto

# Native Linux packages: verify the signed manifest first
curl -fsSLO https://get.attesto.eu/0.5.0/SHA256SUMS
curl -fsSLO https://get.attesto.eu/0.5.0/SHA256SUMS.sig
cosign verify-blob --key https://get.attesto.eu/cosign.pub --insecure-ignore-tlog --signature SHA256SUMS.sig SHA256SUMS

# Debian / Ubuntu (run the install as root; arm64 debs and aarch64 rpms
# are on the same channel)
curl -fsSLO https://get.attesto.eu/0.5.0/attesto_0.5.0-1_amd64.deb
sha256sum -c --ignore-missing SHA256SUMS
apt install ./attesto_0.5.0-1_amd64.deb

# Fedora / RHEL (run the install as root)
curl -fsSLO https://get.attesto.eu/0.5.0/attesto-0.5.0-1.x86_64.rpm
sha256sum -c --ignore-missing SHA256SUMS
dnf install ./attesto-0.5.0-1.x86_64.rpm

arm64/aarch64-packages zijn metadata-geverifieerd tegen het gesigneerde manifest, maar zijn niet uitgevoerd op arm-hardware.

CLI command reference

cd sdk/go
go run ./cmd/attesto --json version

go run ./cmd/attesto --json \
  --api-key-env ATTESTO_API_KEY \
  streams create \
  --use-case ai-decision-history \
  --policy-id policy-2026-01

Offline receipt verification:

go run ./cmd/attesto --json receipts verify \
  --file receipt.json \
  --public-key-hex "$ATTESTO_RECEIPT_SIGNER_PUBLIC_KEY_HEX"

Production readiness evidence check:

go run ./cmd/attesto --json readiness lifecycle
go run ./cmd/attesto --json readiness fork-defense
go run ./cmd/attesto --json readiness production

Marketplace publisher automation:

go run ./cmd/attesto --json marketplace init \
  --output attesto.connector.json \
  --slug signed-webhook-evidence \
  --name "Generic Signed Webhook Evidence" \
  --version 1.0.0 \
  --category compliance \
  --summary "Produces Attesto evidence for signed webhook events." \
  --description "Produces verifiable Proofstream events for signed webhook payloads." \
  --publisher-slug attesto \
  --publisher-name Attesto \
  --repository-url https://git.rotz.ai/attesto/attesto-v1/src/branch/attesto-2.0/connectors/webhook \
  --docs-url https://docs.attesto.eu/manuals/connectors.html#signed \
  --provider-url https://docs.attesto.eu/manuals/connectors.html#signed \
  --auth-mode signed-webhook \
  --auth-scopes webhook:read \
  --sync-modes webhook \
  --event-types webhook.event.received \
  --canary-ref release/attesto-2.0-connector-assurance-readiness/result.json \
  --capabilities proofstream,offline-verification

go run ./cmd/attesto --json marketplace validate \
  --manifest-file attesto.connector.json

go run ./cmd/attesto --json \
  --token-env ATTESTO_TENANT_TOKEN \
  marketplace submit \
  --manifest-file attesto.connector.json \
  --source-ref https://git.rotz.ai/attesto/attesto-v1/src/branch/attesto-2.0/connectors/webhook \
  --visibility public \
  --pricing-model free

Operator endpoints

Tenant/operator endpoints vereisen bearer-token mode. Gebruik dit alleen in trusted operator automation en nooit in publieke clients.

from attesto import AttestoV2Client

operator = AttestoV2Client.with_bearer_token(
    os.environ["ATTESTO_TENANT_TOKEN"],
)
streams = operator.list_tenant_streams()
forks = operator.list_fork_evidence(streams[0]["streamId"])

const operator = new AttestoV2Client({
  apiKey: process.env.ATTESTO_TENANT_TOKEN!,
  authMode: "bearer",
});

const streams = await operator.listTenantStreams();
const forks = await operator.listForkEvidence(String(streams[0].streamId));

operator, err := attesto.NewBearerClient(os.Getenv("ATTESTO_TENANT_TOKEN"))
if err != nil { log.Fatal(err) }
streams, err := operator.ListTenantStreams(context.Background(), "", 100, 0)
if err != nil { log.Fatal(err) }

Offline en online verify helpers

SDK verification methods zijn nuttig in services die Attesto receipts of bundles ontvangen en fail-closed moeten werken voordat ze deze accepteren.

from attesto import AttestoV2Client
from datetime import UTC, datetime
import os

with AttestoV2Client(api_key=os.environ["ATTESTO_API_KEY"]) as attesto:
    report = attesto.verify_object(
        kind="bundle",
        proof_object=bundle_object,
    )
    if not report.ok:
        raise RuntimeError(report.problems)

const report = await attesto.verifyObject({
  kind: "bundle",
  object: bundleObject,
});

if (!report.ok) {
  throw new Error(report.problems.join("; "));
}

Provenance-verificatie (Attesto 3)

De 0.5.0-SDKs voegen een verificatieclient toe voor de Attesto 3 provenance lane: commitment-only provenance streams die gevoed worden door een Local Vault onder beheer van de klant. De gepinde Rust edge core van de vault bouwt capsules, commitments en handtekeningen; de SDK leidt ze opnieuw af en controleert ze, en kan bewust geen capsule of randomizer construeren. Elke functie in dit onderdeel werkt offline, zonder aanroep naar Attesto, en elk rapport bevat een not_claimed-lijst die een verifier-scherm naast het resultaat moet tonen. Protocollen: ATTESTO-PROVENANCE-001, ATTESTO-DISCLOSURE-001, ATTESTO-ZK-RANGE-001 en de bundle provenance binding van ATTESTO-PROOFSTREAM-001. Conformiteit wordt vastgepind door het gedeelde golden-vector-corpus in alle drie de talen.

Een disclosure presentation offline verifiëren

De Local Vault van een houder geeft een selective-disclosure presentation uit: de onthulde leaves met hun randomizers, two-hop inclusion proofs tot aan de capsule root, en een Ed25519-handtekening van de uitgevende installatie. De verifier opent elke onthulde commitment en speelt elk proof na tot aan de gepresenteerde capsule_root. Problemen worden verzameld, niet als exception gegooid, zodat de aanroeper alles ziet wat er mis is. Geef de nonce die je hebt uitgegeven mee voor challenge-modus; zonder nonce is de presentation alleen begrensd door haar expires_at en meldt het rapport bounded_lifetime in plaats van een versheid te suggereren die niet is gecontroleerd. Non-claim: de disclosure bewijst dat de onthulde leaves in de capsule zitten; het is geen uitspraak dat de capsule verder niets bevat.

from attesto.provenance import verify_disclosure

report = verify_disclosure(
    presentation,
    expected_nonce=challenge,
    subject_commitment=asset_commitment,
)
report.ok               # every leaf opened and every proof folded to capsule_root
report.verified_leaves  # ({"subtree": "claims", "leaf_role": "c2pa_manifest_valid", "value": ...},)
report.freshness        # "challenge" | "bounded_lifetime"
report.subject_checked  # True only when subject_commitment matched
report.problems         # () or every problem found
report.not_claimed      # ({"id": "undisclosed_facts_absent", "statement": ...},)

import { verifyDisclosure } from "@attesto/sdk";

const report = await verifyDisclosure(presentation, {
  expectedNonce: challenge,
  subjectCommitment: assetCommitment,
});
report.ok; report.verified_leaves; report.freshness;
report.subject_checked; report.problems; report.not_claimed;

report := attesto.VerifyDisclosure(presentation,
	attesto.WithExpectedNonce(challenge),
	attesto.WithSubjectCommitment(assetCommitment),
)
report.Ok; report.VerifiedLeaves; report.Freshness
report.SubjectChecked; report.Problems; report.NotClaimed

Bundle provenance inclusion en key revocation offline verifiëren

Een verifier bundle over een provenance stream draagt provenance_root, provenance_event_count en vault_key_lifecycle in zijn gehashte payload. Een inclusion object, teruggegeven door GET /v2/streams/{streamId}/provenance-events/{sourceRef}/bundle-inclusion?from_checkpoint_id=...&to_checkpoint_id=... of meegeleverd als provenance_inclusions naast de bundle, bewijst één capsule root onder die root. De verifier berekent de bundle hash opnieuw, hasht de leaf opnieuw uit zijn velden, speelt het proof na, neemt de receipt time voor het seq_no van de leaf uit de eigen receipts van de bundle en past de bevroren revocation-regel toe op de installatie die de leaf noemt. inclusion en key_status blijven gescheiden: een capsule root kan aantoonbaar onder de bundle zitten terwijl de sleutel vóór ontvangst is ingetrokken, en not_evaluated is nooit een goedkeuring. Revocation wordt beoordeeld tegen de platform receipt time, nooit tegen het door de vault geclaimde occurred_at, met een inclusieve grens; een claim die aan de intrekking voorafgaat krijgt de vlag suspect_backdated. Non-claims: de root bewijst dat de capsule root onder de bundle bestond en niets over de inhoud van de capsule; de key lifecycle is zoals bij het bouwen van de bundle, dus een latere intrekking zit niet in de bundle.

from attesto.provenance import evaluate_key_revocation, verify_bundle_provenance

report = verify_bundle_provenance(bundle, inclusion)
report.ok          # bundle hash holds, inclusion VALID, key live at receipt
report.inclusion   # "VALID" | "INVALID"
report.key_status  # "valid" | "revoked_at_receipt" | "unknown_installation" | "not_evaluated"
report.flags       # e.g. ("revoked_at_receipt", "suspect_backdated")
report.not_claimed # three statements

verdict = evaluate_key_revocation(
    revoked_at=key_status["revokedAt"],          # None when never revoked
    receipt_time=receipt["payload"]["issued_at"],
    claimed_occurred_at=envelope["occurred_at"],
    reason=key_status["revocationReason"],
)
verdict.accepted   # status == "valid"

import { evaluateKeyRevocation, verifyBundleProvenance } from "@attesto/sdk";

const report = await verifyBundleProvenance(bundle, inclusion);
report.ok; report.inclusion; report.key_status; report.flags; report.not_claimed;

const verdict = evaluateKeyRevocation(
  keyStatus.revokedAt,
  receipt.payload.issued_at,
  envelope.occurred_at,
  keyStatus.revocationReason,
);
verdict.accepted;

report := attesto.VerifyBundleProvenance(bundle, inclusion)
report.Ok; report.Inclusion; report.KeyStatus; report.Flags; report.NotClaimed

verdict := attesto.EvaluateKeyRevocation(revokedAt, receiptTime, claimedOccurredAt, reason)
verdict.Accepted()

Effective assurance afleiden (L3 wordt afgeleid, nooit ondertekend)

Een vault ondertekent L0 (software-sleutel), L1 (sleutel in een niet-extraheerbaar PKCS#11-token) of L2 (L1 plus een TPM 2.0-quote over de meting van de vault) in zijn envelope, en het platform weigert een L1/L2-envelope die het niet kan onderbouwen met een geregistreerde attestation. L3 heeft geen representatie op de draad: de verifier leidt het af uit L2 plus een behaald witness quorum op de omvattende checkpoint, en een envelope die L3 claimt wordt geweigerd. De anchor-status wordt ernaast gerapporteerd en verhoogt nooit een niveau. Het rapport houdt vault assurance, witness quorum, anchor-status en het afgeleide niveau als vier afzonderlijke feiten. Hoe de niveaus worden verdiend staat in de Local Vault-gids.

from attesto.provenance import effective_assurance

report = effective_assurance("L2", witness_quorum_met=True, anchor_confirmed=True)
report.effective  # "L3"
report.derived    # True: derived here, signed by nobody
report.reasons    # ("anchor confirmed; anchoring does not promote assurance", "L3 derived from L2 plus a met witness quorum")
effective_assurance("L2").effective  # "L2": quorum not evaluated withholds L3
effective_assurance("L3")            # raises AttestoProvenanceError

import { effectiveAssurance } from "@attesto/sdk";

const report = effectiveAssurance("L2", { witnessQuorumMet: true, anchorConfirmed: true });
report.effective; // "L3"
report.derived;   // true
report.reasons;

met := true
report, err := attesto.EffectiveAssurance("L2", &met, &met)
report.Effective // "L3"
report.Derived   // true
report.Reasons

Een exacte private-numeric opening verifiëren

Een private numeric claim legt zijn gecodeerde waarde vast als een Pedersen commitment over ristretto255. Wanneer een houder de waarde en de blinding onthult, berekent de verifier de commitment opnieuw en vergelijkt hij byte voor byte. Curve-rekenwerk is optioneel omdat de rest van de verificatie SHA-256- en Merkle-werk is: Python heeft attesto[zk] nodig, TypeScript de peer dependency @noble/curves en Go de aparte module go.attesto.eu/sdk/zk. Een client zonder die afhankelijkheid rapporteert not_checked. De descriptor moet zijn claim leaf al onder de capsule root hebben geopend, anders kan een passend paar volledig worden gefabriceerd. Een waarde van precies nul is een geldige opening. Dit verifieert geen range proof.

from attesto.provenance import pedersen_available, verify_pedersen_opening

opened = (
    verify_pedersen_opening(descriptor, encoded_value, blinding_scalar)
    if pedersen_available()
    else None  # report "not_checked"
)

import { pedersenAvailable, verifyPedersenOpening } from "@attesto/sdk";

const opened = (await pedersenAvailable())
  ? await verifyPedersenOpening(descriptor, encodedValue, blindingScalar)
  : null; // report "not_checked"

import "go.attesto.eu/sdk/zk"

opened, err := zk.VerifyOpening(descriptor, encodedValue, blindingScalar)

Een ZK range result inspecteren

Selective disclosure v2 bewijst dat de meting van een benoemde detector binnen een interval viel zonder de meting te onthullen. Geen enkele SDK verifieert het range proof zelf; dat blijft het werk van de Rust core. De SDK rapporteert zk_predicate: not_checked onder verified_here, bewaart wat de uitgever claimde onder reported_by_issuer en weigert een resultaat dat een van de drie verplichte non-claims weglaat of een veld in de vorm van een oordeel draagt, zoals authentic, score of probability. Een bewezen grens zegt niets over de vraag of de content machinaal gegenereerd is. Capsule evidence van een AttestoMark Image-, Audio- of Video-provider is een ATTESTO-PROVIDER-RESULT-001/0.2-object waarvan het veld presented_matches_record meldt of de gepresenteerde bytes exact het gemarkeerde asset waren; een mismatch is een observatie die een eerlijke transcode ook oplevert, nooit een weigering.

from attesto.provenance import inspect_predicate_result, validate_range_statement

report = inspect_predicate_result(result)
report["verified_here"]       # {"zk_predicate": "not_checked", "capsule_inclusion": "not_checked"}
report["reported_by_issuer"]
report["not_claimed"]         # detector_correctness_not_proven, content_truth_not_proven, ai_generation_not_proven
width = validate_range_statement(statement)  # 8 | 16 | 32 | 64

import { inspectPredicateResult, validateRangeStatement } from "@attesto/sdk";

const report = inspectPredicateResult(result);
report.verified_here; report.reported_by_issuer; report.not_claimed;
const width = validateRangeStatement(statement);

report, err := attesto.InspectPredicateResult(result, nil)
report.VerifiedHere; report.ReportedByIssuer; report.NotClaimed
width, err := attesto.ValidateRangeStatement(statement)

Niet in de SDKs: capsule-constructie, randomizer-generatie en envelope-ondertekening zitten in de edge core van de Local Vault; range proofs worden alleen door de Rust core geverifieerd; er is nog geen client wrapper voor POST /v2/provenance/streams; en de attesto CLI verifieert in 0.5.0 geen disclosures of bundle provenance.

MockAttesto voor lokale tests

attesto.testing.MockAttesto is een Python test harness voor lokale CI en integratietests. Het gebruikt dezelfde canonical hashing en receipt shapes als de SDK, maar tekent met een per-instance throwaway mock key en markeert objecten als mock evidence. Gebruik het om je applicatieflow zonder netwerktoegang of Attesto-account te testen; gebruik mock receipts nooit in production evidence of customer bundles.

MockAttesto is bewust fail-closed tegen echte trust roots: verificatie met een production witness key moet mock evidence verwerpen. Zo blijven tests snel zonder dat synthetic evidence als production proof kan doorgaan.

Companion packages en edge-surfaces

De core SDKs blijven klein. Aparte packages dekken edge relay, MCP tooling, workflow nodes en de toekomstige independent witness node. Deze packages mogen nooit verborgen transitieve dependencies van de core SDKs worden.

pip install attesto-mcp
pipx install attesto-local-vault
npm install n8n-nodes-attesto

Gespecificeerd als privacy-preserving observation node package. Huidig customer-operated witness gedrag is beschikbaar via Local Vault witness mode; standalone attesto-witness, @attesto/witness en go.attesto.eu/witness mogen alleen worden geïnstalleerd nadat release evidence dat package groen markeert.

Security rules

• Gebruik SDKs alleen vanuit server-side code.
• Bewaar system keys in je secret manager en injecteer ze at runtime.
• Plaats system keys niet in frontend bundles, mobile apps, query strings of logs.
• Gebruik de standaard production origin tenzij je tenant een private deployment origin heeft.
• Houd idempotency ingeschakeld voor ieder write path.