@atep/core 0.0.1 → 0.1.0-alpha.3

package/dist/index.js

@@ -0,0 +1,374 @@
+// @atep/core: TypeScript API over the Rust atep-core compiled to WebAssembly.
+//
+// Call `await init()` once before anything else (or `initSync(bytes)`).
+import rawInit, { initSync as rawInitSync, Identity as RawIdentity, agentIdOfBundle, parseAgentId as rawParseAgentId, sha256 as rawSha256, encrypt as rawEncrypt, encryptWithRandomness, view as rawView, submittedForm, withAttestations as rawWithAttestations, withInclusionProof as rawWithInclusionProof, merkleRoot as rawMerkleRoot, auditPath as rawAuditPath, verify as rawVerify, verifyAs as rawVerifyAs, verifyCheckpoint as rawVerifyCheckpoint, verifyInclusion as rawVerifyInclusion, checkConsistency as rawCheckConsistency, checkSplitView as rawCheckSplitView, verifySrl as rawVerifySrl, chainIdKind as rawChainIdKind, parseAnchorRecord as rawParseAnchorRecord, encodeAnchorRecord as rawEncodeAnchorRecord, checkpointHash as rawCheckpointHash, checkPublishedAnchor as rawCheckPublishedAnchor, parseRequireAnchor as rawParseRequireAnchor, checkAdmission as rawCheckAdmission, checkDomainBinding as rawCheckDomainBinding, } from "./wasm/atep_wasm.js";
+// ---------------------------------------------------------------------------
+// Initialisation
+let ready = false;
+/**
+ * Load the wasm module. Without an argument the binary is found next to this
+ * file: read from disk for `file:` URLs (Node, Bun, Deno), fetched otherwise
+ * (browsers, bundlers that rewrite `import.meta.url`). Pass bytes, a URL or a
+ * `Response` to override. Safe to call more than once.
+ */
+export async function init(source) {
+    if (ready)
+        return;
+    let input = source;
+    if (input === undefined) {
+        const url = new URL("./wasm/atep_wasm_bg.wasm", import.meta.url);
+        if (url.protocol === "file:") {
+            const { readFile } = await import("node:fs/promises");
+            input = await readFile(url);
+        }
+        else {
+            input = url;
+        }
+    }
+    if (input instanceof Uint8Array) {
+        rawInitSync({ module: input });
+    }
+    else {
+        await rawInit({ module_or_path: input });
+    }
+    ready = true;
+}
+/** Synchronous initialisation from wasm bytes or a compiled module. */
+export function initSync(source) {
+    if (ready)
+        return;
+    rawInitSync({ module: source });
+    ready = true;
+}
+function need() {
+    if (!ready)
+        throw new Error("@atep/core: call `await init()` first");
+}
+// ---------------------------------------------------------------------------
+// Helpers
+export function hexToBytes(hex) {
+    if (hex.length % 2 !== 0 || /[^0-9a-fA-F]/.test(hex))
+        throw new Error("invalid hex");
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    return out;
+}
+export function bytesToHex(b) {
+    let s = "";
+    for (const x of b)
+        s += x.toString(16).padStart(2, "0");
+    return s;
+}
+const hx = (v) => (typeof v === "string" ? v : bytesToHex(v));
+const nowSecs = () => Math.floor(Date.now() / 1000);
+function normalizePolicy(p) {
+    const o = { ...p };
+    for (const k of ["known_bundles", "seen_nonces", "attestations", "srls"]) {
+        const v = p[k];
+        if (v !== undefined)
+            o[k] = v.map(hx);
+    }
+    if (p.detached_payload_hex !== undefined)
+        o.detached_payload_hex = hx(p.detached_payload_hex);
+    return JSON.stringify(o);
+}
+function signJson(o) {
+    const j = {
+        content_type: o.contentType,
+        issued_at: o.issuedAt ?? nowSecs(),
+        expires_at: o.expiresAt ?? undefined,
+        detached: o.detached,
+        include_bundle: o.includeBundle,
+        nonce_hex: o.nonce && bytesToHex(o.nonce),
+        mode: o.deterministic ? "deterministic" : "hedged",
+        command_class: o.commandClass,
+    };
+    return JSON.stringify(j);
+}
+/**
+ * An agent identity. Its secret seeds live in wasm linear memory and are
+ * zeroized when the object is freed. Call `free()` (or use `using`) when done.
+ */
+export class Identity {
+    #raw;
+    constructor(raw) {
+        this.#raw = raw;
+    }
+    /** Generate a new identity. `encryption` adds X25519 and ML-KEM-768 keys (needed to receive encrypted envelopes). */
+    static generate(encryption = true) {
+        need();
+        return new Identity(RawIdentity.generate(encryption));
+    }
+    /** From raw seeds (the same values the test vectors list). */
+    static fromSeeds(seeds) {
+        need();
+        return new Identity(RawIdentity.fromSeeds(seeds.ed25519, seeds.mldsa65, seeds.x25519 ?? null, seeds.mlkem768 ?? null));
+    }
+    /** From seeds given as hex (the format of the vector `inputs`). */
+    static fromSeedsHex(s) {
+        return Identity.fromSeeds({
+            ed25519: hexToBytes(s.ed25519),
+            mldsa65: hexToBytes(s.mldsa65),
+            x25519: s.x25519 ? hexToBytes(s.x25519) : undefined,
+            mlkem768: s.mlkem768 ? hexToBytes(s.mlkem768) : undefined,
+        });
+    }
+    /** From the CBOR secret key file written by `exportSecret` or the Rust CLI. */
+    static fromSecret(secret) {
+        need();
+        return new Identity(RawIdentity.fromSecret(secret));
+    }
+    /** The secret key file. The returned array holds secrets: `fill(0)` it when done. */
+    exportSecret() {
+        return this.#raw.exportSecret();
+    }
+    /** Agent ID, `atep:...`. */
+    get agentId() {
+        return this.#raw.agentId();
+    }
+    get agentIdBytes() {
+        return this.#raw.agentIdBytes();
+    }
+    get did() {
+        return this.#raw.did();
+    }
+    get publicBundle() {
+        return this.#raw.publicBundle();
+    }
+    get hasEncryption() {
+        return this.#raw.hasEncryption();
+    }
+    /** Sign a payload into a tag 98 envelope (Ed25519 plus ML-DSA-65). */
+    sign(payload, options = {}) {
+        return this.#raw.sign(payload, signJson(options));
+    }
+    /** Open a tag 96 envelope addressed to this identity. Returns the inner signed envelope, unverified. */
+    decrypt(data) {
+        return this.#raw.decrypt(data);
+    }
+    /** Issue an attestation (spec section 7) about `options.subject`. */
+    issueAttestation(o) {
+        return this.#raw.issueAttestation(JSON.stringify({
+            subject: o.subject,
+            claim: o.claim,
+            issued_at: o.issuedAt,
+            expires_at: o.expiresAt,
+            data: o.data,
+            data_hex: o.dataCbor && bytesToHex(o.dataCbor),
+            evidence_hex: o.evidence && bytesToHex(o.evidence),
+            evidence_uri: o.evidenceUri,
+            id_hex: o.id && bytesToHex(o.id),
+            nonce_hex: o.nonce && bytesToHex(o.nonce),
+            mode: o.deterministic ? "deterministic" : "hedged",
+            include_bundle: o.includeBundle,
+            allow_long_default: o.allowLongDefault,
+        }));
+    }
+    /** Create a signed revocation list with this identity as issuer (spec section 8). */
+    createSrl(o) {
+        return this.#raw.createSrl(JSON.stringify({
+            sequence: o.sequence,
+            issued_at: o.issuedAt,
+            next_update: o.nextUpdate,
+            revoked: o.revoked.map((r) => ({
+                ...("attestationId" in r ? { id_hex: bytesToHex(r.attestationId) } : { id: r.identity }),
+                reason: r.reason,
+                revoked_at: r.revokedAt,
+            })),
+            nonce_hex: o.nonce && bytesToHex(o.nonce),
+            mode: o.deterministic ? "deterministic" : "hedged",
+            include_bundle: o.includeBundle,
+        }));
+    }
+    /** Sign a log checkpoint with this identity as the log. */
+    createCheckpoint(o) {
+        return this.#raw.createCheckpoint(JSON.stringify({
+            tree_size: o.treeSize,
+            root_hash_hex: bytesToHex(o.rootHash),
+            timestamp: o.timestamp,
+            nonce_hex: o.nonce && bytesToHex(o.nonce),
+            mode: o.deterministic ? "deterministic" : "hedged",
+        }));
+    }
+    /** Verify with this identity as the recipient (opens tag 96 envelopes). */
+    verify(data, policy = {}, now = nowSecs()) {
+        return JSON.parse(rawVerifyAs(this.#raw, data, normalizePolicy(policy), now));
+    }
+    /** Zeroize and release the secret seeds. */
+    free() {
+        this.#raw.free();
+    }
+    [Symbol.dispose]() {
+        this.#raw.free();
+    }
+}
+// ---------------------------------------------------------------------------
+// Functions
+/** Generate an identity (alias of `Identity.generate`). */
+export function keygen(encryption = true) {
+    return Identity.generate(encryption);
+}
+/** Agent ID of a public bundle (or of an Identity). */
+export function agentId(bundleOrIdentity) {
+    need();
+    return bundleOrIdentity instanceof Identity
+        ? bundleOrIdentity.agentId
+        : agentIdOfBundle(bundleOrIdentity);
+}
+/** Parse an Agent ID in `atep:` or `did:atep:` form. */
+export function parseAgentId(s) {
+    need();
+    return JSON.parse(rawParseAgentId(s));
+}
+export function sign(identity, payload, options = {}) {
+    return identity.sign(payload, options);
+}
+/** Encrypt a signed envelope to a recipient's public bundle (hybrid X25519 + ML-KEM-768, AES-256-GCM). */
+export function encrypt(signedEnvelope, recipientBundle) {
+    need();
+    return rawEncrypt(signedEnvelope, recipientBundle);
+}
+/** Encrypt with explicit randomness. Only for reproducing test vectors. */
+export function encryptDeterministic(signedEnvelope, recipientBundle, rnd) {
+    need();
+    return encryptWithRandomness(signedEnvelope, recipientBundle, rnd.x25519Ephemeral, rnd.mlkemM, rnd.iv);
+}
+export function decrypt(identity, data) {
+    return identity.decrypt(data);
+}
+/**
+ * Verify an envelope, spec section 10 steps 1 to 10. A rejection is returned
+ * as `{ok: false, step, error}`, not thrown. Malformed arguments throw.
+ */
+export function verify(data, policy = {}, options = {}) {
+    need();
+    const now = options.now ?? nowSecs();
+    if (options.recipient)
+        return options.recipient.verify(data, policy, now);
+    return JSON.parse(rawVerify(data, normalizePolicy(policy), now));
+}
+/** JSON debug rendering of any ATEP CBOR object (envelope, bundle, ...). Not canonical. */
+export function view(data) {
+    need();
+    return JSON.parse(rawView(data));
+}
+export function sha256(data) {
+    need();
+    return rawSha256(data);
+}
+/** Put inline attestations into the (unsigned) unprotected header of an envelope. */
+export function withAttestations(envelope, attestations) {
+    need();
+    return rawWithAttestations(envelope, JSON.stringify(attestations.map(bytesToHex)));
+}
+/** Attach a log inclusion proof to an attestation. */
+export function withInclusionProof(attestation, proof) {
+    need();
+    return rawWithInclusionProof(attestation, proof.leafIndex, JSON.stringify(proof.auditPath.map(bytesToHex)), proof.checkpoint);
+}
+/** The attestation as submitted to a log: its inclusion proof header removed. This is the Merkle leaf. */
+export function submittedFormOf(attestation) {
+    need();
+    return submittedForm(attestation);
+}
+/** RFC 9162 Merkle root over leaves. */
+export function merkleRoot(leaves) {
+    need();
+    return hexToBytes(rawMerkleRoot(JSON.stringify(leaves.map(bytesToHex))));
+}
+/** RFC 9162 audit path of leaf `index`. */
+export function auditPath(index, leaves) {
+    need();
+    return JSON.parse(rawAuditPath(index, JSON.stringify(leaves.map(bytesToHex)))).map(hexToBytes);
+}
+/** Verify a checkpoint envelope: steps 1 to 8, content type, trusted log, schema. */
+export function verifyCheckpoint(cbor, trustedLogs, now = nowSecs()) {
+    need();
+    return JSON.parse(rawVerifyCheckpoint(cbor, JSON.stringify(trustedLogs), now));
+}
+/** Verify the inclusion proof an attestation carries (offline, against trusted logs). */
+export function verifyInclusion(attestation, trustedLogs, now = nowSecs()) {
+    need();
+    return JSON.parse(rawVerifyInclusion(attestation, JSON.stringify(trustedLogs), now));
+}
+/** Check a consistency proof document `{old, new, proof}` (CBOR). */
+export function checkConsistency(cbor, trustedLogs, now = nowSecs()) {
+    need();
+    return JSON.parse(rawCheckConsistency(cbor, JSON.stringify(trustedLogs), now));
+}
+/** Check a split view document `{a, b, proof?}` (CBOR). */
+export function checkSplitView(cbor, trustedLogs, now = nowSecs()) {
+    need();
+    return JSON.parse(rawCheckSplitView(cbor, JSON.stringify(trustedLogs), now));
+}
+function normalizeSrlContext(c) {
+    const o = { ...c };
+    for (const k of ["known_bundles", "attestations"]) {
+        const v = c[k];
+        if (v !== undefined)
+            o[k] = v.map(hx);
+    }
+    return JSON.stringify(o);
+}
+/**
+ * Verify a signed revocation list and apply the freshness rule. `cached` is a
+ * previously accepted SRL of the same issuer (rollback and conflict rules apply).
+ */
+export function verifySrl(srl, options = {}) {
+    need();
+    return JSON.parse(rawVerifySrl(srl, options.now ?? nowSecs(), JSON.stringify({ on_stale: options.onStale ?? "fail-closed" }), options.cached ?? undefined, options.context ? normalizeSrlContext(options.context) : undefined));
+}
+/** Is `id` a valid `chain-id`: one of the five registered ids, or `x-` plus a lowercase name. Pure function. */
+export function chainIdKind(id) {
+    need();
+    return JSON.parse(rawChainIdKind(id));
+}
+/** Decode an anchor record payload (strict deterministic CBOR). Invalid input is a result, not an exception. */
+export function parseAnchorRecord(payload) {
+    need();
+    return JSON.parse(rawParseAnchorRecord(payload));
+}
+/** Deterministic CBOR of an anchor record (no `block-height` key when it is null or absent). */
+export function encodeAnchorRecord(record) {
+    need();
+    return rawEncodeAnchorRecord(JSON.stringify(record));
+}
+/** Verify a checkpoint envelope (as `verifyCheckpoint`) and add `checkpoint_hash`: SHA-256 of the verified payload. */
+export function checkpointHash(cbor, trustedLogs, now = nowSecs()) {
+    need();
+    return JSON.parse(rawCheckpointHash(cbor, JSON.stringify(trustedLogs), now));
+}
+/**
+ * Take a log-signed anchor envelope as published: steps 1 to 8 (reported as they are), then the content
+ * type, the record schema, the signer (`log`) and the checkpoint hash (hex), in that order.
+ * Whether the witness really holds the hash is not checked.
+ */
+export function checkPublishedAnchor(envelope, log, checkpointHashHex, now = nowSecs()) {
+    need();
+    return JSON.parse(rawCheckPublishedAnchor(envelope, log, checkpointHashHex, now));
+}
+/** Parse the `require_anchor` rules of a trust policy object. A bad policy is `{ok: false, error: "policy_invalid"}`. */
+export function parseRequireAnchor(policy) {
+    need();
+    return JSON.parse(rawParseRequireAnchor(JSON.stringify(policy)));
+}
+/**
+ * The admission rules of a log (spec section 9) applied to one submission, including the data rules of
+ * `registry-endpoint` and `domain-control`. `logged` are documents admitted first, in order (hex or bytes).
+ * This package has no log: this is a pure check of the rules.
+ */
+export function checkAdmission(submission, options) {
+    need();
+    return JSON.parse(rawCheckAdmission(submission, JSON.stringify({
+        now: options.now ?? nowSecs(),
+        log: options.log,
+        max_envelope_bytes: options.maxEnvelopeBytes ?? 65536,
+        logged: (options.logged ?? []).map(hx),
+    })));
+}
+/** Run the domain binding check (section 7) over a fixture of fetcher answers. No network is used. */
+export function checkDomainBinding(fixture) {
+    need();
+    return JSON.parse(rawCheckDomainBinding(JSON.stringify(fixture)));
+}

package/dist/wasm/atep_wasm.d.ts

@@ -0,0 +1,312 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * An agent identity. The secret seeds stay inside wasm memory.
+ */
+export class Identity {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    agentIdBytes(): Uint8Array;
+    /**
+     * Agent ID in text form (`atep:...`).
+     */
+    agentId(): string;
+    /**
+     * Sign a log checkpoint (this identity is the log). `options` JSON:
+     * `{tree_size, root_hash_hex, timestamp, nonce_hex?, mode?}`.
+     */
+    createCheckpoint(options: string): Uint8Array;
+    /**
+     * Create a signed revocation list (spec section 8). `options` JSON:
+     * `{sequence, issued_at, next_update, revoked: [{id_hex (16 bytes, an
+     * attestation) | id (an Agent ID), reason, revoked_at}], nonce_hex?,
+     * mode?, include_bundle?}`. The issuer is this identity.
+     */
+    createSrl(options: string): Uint8Array;
+    /**
+     * Open a tag 96 envelope addressed to this identity; returns the inner
+     * tag 98 envelope (not verified, run `verify` on it or use `verify`
+     * directly with this identity as recipient).
+     */
+    decrypt(data: Uint8Array): Uint8Array;
+    did(): string;
+    /**
+     * The CBOR secret key file. This copies secret material into a JS
+     * Uint8Array: the caller owns it and should `.fill(0)` it after use.
+     */
+    exportSecret(): Uint8Array;
+    /**
+     * From the CBOR secret key file written by `exportSecret` (and by the Rust CLI).
+     */
+    static fromSecret(secret_file: Uint8Array): Identity;
+    /**
+     * From raw seeds. `x25519` and `mlkem768` are both given or both empty.
+     */
+    static fromSeeds(ed25519: Uint8Array, mldsa65: Uint8Array, x25519?: Uint8Array | null, mlkem768?: Uint8Array | null): Identity;
+    /**
+     * New identity from system randomness (`crypto.getRandomValues`).
+     */
+    static generate(with_encryption: boolean): Identity;
+    hasEncryption(): boolean;
+    /**
+     * Issue an attestation (spec section 7). `options` is JSON:
+     * `{subject, claim, issued_at, expires_at, data?: JSON object (or data_hex: CBOR),
+     * evidence_hex?, evidence_uri?, id_hex?, nonce_hex?, mode?, include_bundle?,
+     * allow_long_default?}`. In `data`, `{"$hex": "..."}` becomes a byte string.
+     */
+    issueAttestation(options: string): Uint8Array;
+    /**
+     * Canonical public key bundle (CBOR).
+     */
+    publicBundle(): Uint8Array;
+    /**
+     * Sign a payload into a tag 98 envelope. `options` is JSON:
+     * `{content_type?, issued_at, expires_at?, detached?, include_bundle?,
+     * nonce_hex?, mode?: "hedged"|"deterministic", command_class?}`.
+     */
+    sign(payload: Uint8Array, options: string): Uint8Array;
+}
+
+/**
+ * Agent ID (text form) of a public bundle.
+ */
+export function agentIdOfBundle(bundle_bytes: Uint8Array): string;
+
+/**
+ * Audit path for `index` (JSON array of hex hashes) over the leaves.
+ */
+export function auditPath(index: number, leaves: string): string;
+
+/**
+ * Check a `chain-id` (spec section 9, "The `chain-id` registry"): returns
+ * `{ok: true, kind: "registered" | "extension"}` or `{ok: false}`.
+ */
+export function chainIdKind(id: string): string;
+
+/**
+ * Run the admission rules of a log (spec section 9, "Admission", the 14 core
+ * claim types, `registry-endpoint` and `domain-control` data rules) on a
+ * submission. `options` JSON: `{now, log, max_envelope_bytes, logged?: [hex]}`
+ * where `logged` are documents admitted first, in order. Returns
+ * `{ok: true, document}` or `{ok: false, refusal, step?, error?}`.
+ */
+export function checkAdmission(cbor: Uint8Array, options: string): string;
+
+/**
+ * Check a consistency proof document `{old, new, proof}` (CBOR).
+ */
+export function checkConsistency(cbor: Uint8Array, trusted_logs: string, now: number): string;
+
+/**
+ * Run the domain binding check (spec section 7, "Checking a domain binding")
+ * on a fixture: `{domain, agent_id, options: {require_both, require_dnssec},
+ * well_known: {host: answer}, txt: {name: answer}}`, the fetcher's answers
+ * by name (a name with no key does not exist). No network is used. Returns
+ * `{well_known, dns, outcome, queried: {well_known, txt}}`.
+ */
+export function checkDomainBinding(fixture: string): string;
+
+/**
+ * Take a log-signed anchor envelope as published (spec section 9, "Anchor
+ * records"): steps 1 to 8, content type, record schema, signer is `log`,
+ * record is for `checkpoint_hash_hex`. Returns `{ok: true, log, record}` or
+ * `{ok: false, step, error}`.
+ */
+export function checkPublishedAnchor(cbor: Uint8Array, log_id: string, checkpoint_hash_hex: string, now: number): string;
+
+/**
+ * Check a split view document `{a, b, proof?}` (CBOR).
+ */
+export function checkSplitView(cbor: Uint8Array, trusted_logs: string, now: number): string;
+
+/**
+ * Verify a checkpoint envelope (as `verifyCheckpoint`) and add its checkpoint
+ * hash, SHA-256 of the verified payload bytes. Returns
+ * `{ok: true, checkpoint, checkpoint_hash, payload_hex}` or a rejection.
+ */
+export function checkpointHash(cbor: Uint8Array, trusted_logs: string, now: number): string;
+
+/**
+ * Encode an anchor record (deterministic CBOR). `record` is JSON
+ * `{checkpoint_hash, chain_id, transaction_id, block_height?, anchored_at}`
+ * (the shape `parseAnchorRecord` returns). Throws when the chain id is invalid.
+ */
+export function encodeAnchorRecord(record: string): Uint8Array;
+
+/**
+ * Encrypt a signed envelope to a recipient bundle with fresh randomness.
+ */
+export function encrypt(signed_envelope: Uint8Array, recipient_bundle: Uint8Array): Uint8Array;
+
+/**
+ * Encrypt with caller supplied randomness (for reproducing test vectors; do
+ * not use in production). Sizes: 32, 32 and 12 bytes.
+ */
+export function encryptWithRandomness(signed_envelope: Uint8Array, recipient_bundle: Uint8Array, x25519_ephemeral: Uint8Array, mlkem_m: Uint8Array, iv: Uint8Array): Uint8Array;
+
+/**
+ * RFC 9162 Merkle tree root over leaves given as a JSON array of hex strings.
+ */
+export function merkleRoot(leaves: string): string;
+
+/**
+ * Parse any accepted Agent ID spelling (`atep:` text or `did:atep:`) and
+ * return `{text, did, hex}` as JSON.
+ */
+export function parseAgentId(s: string): string;
+
+/**
+ * Decode an anchor record payload (strict deterministic CBOR, schema of
+ * section 9). Returns `{ok: true, record}` or
+ * `{ok: false, error: "anchor_record_invalid"}`. An accepted record must
+ * re-encode to the same bytes, else this throws (an internal inconsistency).
+ */
+export function parseAnchorRecord(payload: Uint8Array): string;
+
+/**
+ * Parse the `require_anchor` rules of a trust policy (a JSON object, the
+ * policy file format). Returns `{ok: true, require_anchor: [...]}` or
+ * `{ok: false, error: "policy_invalid"}` (a configuration error, no step).
+ */
+export function parseRequireAnchor(policy: string): string;
+
+/**
+ * SHA-256.
+ */
+export function sha256(data: Uint8Array): Uint8Array;
+
+/**
+ * The form of an attestation that is submitted to a log (the `-70012` header removed).
+ */
+export function submittedForm(envelope_bytes: Uint8Array): Uint8Array;
+
+/**
+ * Verify an envelope (spec section 10, all ten steps). `policy` is JSON in the
+ * format of the test vectors: `{max_skew_secs?, known_bundles: [hex],
+ * seen_nonces: [hex], revocations: [{id, reason, revoked_at}],
+ * detached_payload_hex?, trust?: {...policy file...}, attestations?: [hex],
+ * srls?: [hex], recipient_seeds?: {...}}`. A recipient `Identity` object can
+ * be passed instead of `recipient_seeds` (preferred: the seeds then never
+ * enter JSON). Returns JSON: `{ok: true, signer, ..., payload_hex}` or
+ * `{ok: false, step, error, cause?}`.
+ */
+export function verify(data: Uint8Array, policy: string, now: number): string;
+
+/**
+ * `verify` with a recipient `Identity` object that opens tag 96 envelopes.
+ */
+export function verifyAs(recipient: Identity, data: Uint8Array, policy: string, now: number): string;
+
+/**
+ * Verify a checkpoint envelope against trusted logs (JSON array of Agent IDs).
+ */
+export function verifyCheckpoint(cbor: Uint8Array, trusted_logs: string, now: number): string;
+
+/**
+ * Verify the inclusion proof carried by an attestation.
+ */
+export function verifyInclusion(attestation_bytes: Uint8Array, trusted_logs: string, now: number): string;
+
+/**
+ * Verify an SRL envelope and apply the freshness policy. `srl_policy` JSON:
+ * `{on_stale: "fail-closed"|"fail-open", on_missing?}`; `cached_srl` is an
+ * optional previously accepted SRL envelope (rollback rules apply).
+ * `context` is optional JSON `{known_bundles?: [hex], attestations?: [hex],
+ * revocations?: [{id, reason, revoked_at}], max_skew_secs?}`: the verifier's
+ * own context in which the cached list and the list are loaded (steps 1 to 8,
+ * spec section 8). Without it only the inline bundles are known.
+ */
+export function verifySrl(cbor: Uint8Array, now: number, srl_policy: string, cached_srl?: Uint8Array | null, context?: string | null): string;
+
+/**
+ * JSON debug view of any ATEP CBOR object.
+ */
+export function view(data: Uint8Array): string;
+
+/**
+ * Put inline attestations (`-70009`) into the unprotected header of an
+ * envelope. `attestations` is a JSON array of hex strings.
+ */
+export function withAttestations(envelope_bytes: Uint8Array, attestations: string): Uint8Array;
+
+/**
+ * Attach an inclusion proof (`-70012`) to an attestation. `audit_path` is a
+ * JSON array of 32 byte hex hashes, `checkpoint` the signed checkpoint envelope.
+ */
+export function withInclusionProof(attestation_bytes: Uint8Array, leaf_index: number, audit_path: string, checkpoint: Uint8Array): Uint8Array;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_identity_free: (a: number, b: number) => void;
+    readonly agentIdOfBundle: (a: number, b: number, c: number) => void;
+    readonly auditPath: (a: number, b: number, c: number, d: number) => void;
+    readonly chainIdKind: (a: number, b: number, c: number) => void;
+    readonly checkAdmission: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly checkConsistency: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly checkDomainBinding: (a: number, b: number, c: number) => void;
+    readonly checkPublishedAnchor: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly checkSplitView: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly checkpointHash: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly encodeAnchorRecord: (a: number, b: number, c: number) => void;
+    readonly encrypt: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly encryptWithRandomness: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+    readonly identity_agentId: (a: number, b: number) => void;
+    readonly identity_agentIdBytes: (a: number, b: number) => void;
+    readonly identity_createCheckpoint: (a: number, b: number, c: number, d: number) => void;
+    readonly identity_createSrl: (a: number, b: number, c: number, d: number) => void;
+    readonly identity_decrypt: (a: number, b: number, c: number, d: number) => void;
+    readonly identity_did: (a: number, b: number) => void;
+    readonly identity_exportSecret: (a: number, b: number) => void;
+    readonly identity_fromSecret: (a: number, b: number, c: number) => void;
+    readonly identity_fromSeeds: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly identity_generate: (a: number, b: number) => void;
+    readonly identity_hasEncryption: (a: number) => number;
+    readonly identity_issueAttestation: (a: number, b: number, c: number, d: number) => void;
+    readonly identity_publicBundle: (a: number, b: number) => void;
+    readonly identity_sign: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly merkleRoot: (a: number, b: number, c: number) => void;
+    readonly parseAgentId: (a: number, b: number, c: number) => void;
+    readonly parseAnchorRecord: (a: number, b: number, c: number) => void;
+    readonly parseRequireAnchor: (a: number, b: number, c: number) => void;
+    readonly sha256: (a: number, b: number, c: number) => void;
+    readonly submittedForm: (a: number, b: number, c: number) => void;
+    readonly verify: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly verifyAs: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly verifyCheckpoint: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly verifyInclusion: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly verifySrl: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+    readonly view: (a: number, b: number, c: number) => void;
+    readonly withAttestations: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly withInclusionProof: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly __wbindgen_export: (a: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number, d: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;