@optimystic/quereus-plugin-crypto 0.13.5 → 0.14.1

package/dist/index.d.ts

@@ -4,31 +4,79 @@
  * Idiomatic ES module exports with base64url as default encoding.
  * All functions accept and return base64url strings by default for SQL compatibility.
  */
-type HashAlgorithm$1 = 'sha256' | 'sha512' | 'blake3';
-type CurveType$2 = 'secp256k1' | 'p256' | 'ed25519';
+type HashAlgorithm = 'sha256' | 'sha512' | 'blake3';
+type CurveType = 'secp256k1' | 'p256' | 'ed25519';
 type Encoding = 'base64url' | 'base64' | 'hex' | 'utf8' | 'bytes';
+/** Encodings valid for hash *output* (no 'utf8' — a digest is not UTF-8 text). */
+type OutputEncoding = 'base64url' | 'base64' | 'hex' | 'bytes';
+/** A single value in a multi-field digest. Mirrors the SQL value space. */
+type DigestField = string | number | bigint | boolean | Uint8Array | null | undefined | {
+    readonly [key: string]: unknown;
+} | readonly unknown[];
+/** A resolved hash function: raw bytes in, digest bytes out. */
+type DigestHasher = (input: Uint8Array) => Uint8Array;
+/** A resolved output encoder: digest bytes in, encoded form out. */
+type OutputEncoder = (bytes: Uint8Array) => string | Uint8Array;
+/**
+ * Resolve a hash algorithm name to its hasher. Throws on unknown algorithm.
+ * Call once (e.g. at plugin registration) and capture the result so the digest
+ * hot path performs no per-call algorithm branching.
+ */
+declare function resolveHasher(algorithm: HashAlgorithm): DigestHasher;
+/**
+ * Resolve an output encoding name to its encoder. Throws on unknown encoding.
+ */
+declare function resolveOutputEncoder(encoding: OutputEncoding): OutputEncoder;
+/**
+ * Canonically encode an ordered tuple of fields into bytes such that distinct
+ * tuples never collide (injective framing).
+ *
+ * Layout: `version ‖ field*` where each field is `tag ‖ varint(len) ‖ payload`
+ * (NULL is a bare tag). Properties:
+ * - order-preserving and arity-safe (self-delimiting fields → uniquely decodable),
+ * - NULL distinguishable from empty string,
+ * - type distinguishable (INTEGER 123 ≠ TEXT '123' ≠ BOOL true ≠ BLOB),
+ * - delimiter-safe (a separator inside a string is just payload under its length).
+ *
+ * Replicability notes:
+ * - Integer `number` and `bigint` of equal value encode identically (both via
+ *   `BigInt(...).toString()`); a non-integer REAL uses ECMAScript `Number::toString`
+ *   (deterministic across JS engines, but not guaranteed across other languages).
+ * - INT vs REAL is derived from the JS value, not SQL affinity: an integer-valued
+ *   REAL (e.g. 2.0 → number 2) encodes as INTEGER, so INTEGER 2 and REAL 2.0 collide.
+ * - A native JSON object/array field must contain only valid JSON (no `undefined`,
+ *   non-finite numbers, `bigint`, or non-plain objects) — otherwise it throws.
+ */
+declare function encodeFields(fields: readonly DigestField[]): Uint8Array;
 /**
- * Compute hash digest of input data
+ * Low-level multi-field digest: canonically encode the fields, then hash and
+ * encode with the supplied (pre-resolved) hasher/encoder. No per-call branching
+ * on algorithm or encoding — resolve once via {@link resolveHasher} /
+ * {@link resolveOutputEncoder} and reuse.
+ */
+declare function digestFields(fields: readonly DigestField[], hasher: DigestHasher, encode: OutputEncoder): string | Uint8Array;
+/**
+ * Compute an injective digest over an ordered tuple of fields.
  *
- * @param data - Data to hash (base64url string or Uint8Array)
+ * @param fields - Ordered tuple of values to hash (any SQL value type)
  * @param algorithm - Hash algorithm (default: 'sha256')
- * @param inputEncoding - Encoding of input string (default: 'base64url')
- * @param outputEncoding - Encoding of output (default: 'base64url')
- * @returns Hash digest in specified encoding
+ * @param encoding - Output encoding (default: 'base64url')
+ * @returns Hash digest in the specified encoding
  *
  * @example
  * ```typescript
- * // Hash UTF-8 text, output as base64url
- * const hash = digest('hello world', 'sha256', 'utf8');
+ * // Hash a tuple of fields — distinct tuples never collide
+ * const h = digest(['alice', 42, null, true]);
  *
- * // Hash base64url data with SHA-512
- * const hash2 = digest('SGVsbG8', 'sha512');
- *
- * // Get raw bytes
- * const bytes = digest('data', 'blake3', 'utf8', 'bytes');
+ * // Pick algorithm / output encoding
+ * const h512 = digest(['a', 'b'], 'sha512', 'hex');
  * ```
+ *
+ * Note: this is a *framed* digest, not a bare hash of raw bytes —
+ * `digest(['hello'])` is not `sha256("hello")`. Use `hashMod` for sharding a
+ * single value.
  */
-declare function digest(data: string | Uint8Array, algorithm?: HashAlgorithm$1, inputEncoding?: Encoding, outputEncoding?: Encoding): string | Uint8Array;
+declare function digest(fields: readonly DigestField[], algorithm?: HashAlgorithm, encoding?: OutputEncoding): string | Uint8Array;
 /**
  * Hash data and return modulo of specified bit length
  * Useful for generating fixed-size hash values (e.g., 16-bit, 32-bit)
@@ -48,7 +96,7 @@ declare function digest(data: string | Uint8Array, algorithm?: HashAlgorithm$1,
  * const hash32 = hashMod('world', 32, 'sha256', 'utf8');
  * ```
  */
-declare function hashMod(data: string | Uint8Array, bits: number, algorithm?: HashAlgorithm$1, inputEncoding?: Encoding): number;
+declare function hashMod(data: string | Uint8Array, bits: number, algorithm?: HashAlgorithm, inputEncoding?: Encoding): number;
 /**
  * Sign data with a private key
  *
@@ -69,7 +117,7 @@ declare function hashMod(data: string | Uint8Array, bits: number, algorithm?: Ha
  * const sig2 = sign(hashData, privateKey, 'ed25519');
  * ```
  */
-declare function sign(data: string | Uint8Array, privateKey: string | Uint8Array, curve?: CurveType$2, inputEncoding?: Encoding, keyEncoding?: Encoding, outputEncoding?: Encoding): string | Uint8Array;
+declare function sign(data: string | Uint8Array, privateKey: string | Uint8Array, curve?: CurveType, inputEncoding?: Encoding, keyEncoding?: Encoding, outputEncoding?: Encoding): string | Uint8Array;
 /**
  * Verify a signature
  *
@@ -91,7 +139,7 @@ declare function sign(data: string | Uint8Array, privateKey: string | Uint8Array
  * const isValid2 = verify(hashData, signature, publicKey, 'ed25519');
  * ```
  */
-declare function verify(data: string | Uint8Array, signature: string | Uint8Array, publicKey: string | Uint8Array, curve?: CurveType$2, inputEncoding?: Encoding, sigEncoding?: Encoding, keyEncoding?: Encoding): boolean;
+declare function verify(data: string | Uint8Array, signature: string | Uint8Array, publicKey: string | Uint8Array, curve?: CurveType, inputEncoding?: Encoding, sigEncoding?: Encoding, keyEncoding?: Encoding): boolean;
 /**
  * Generate cryptographically secure random bytes
  *
@@ -103,215 +151,193 @@ declare function randomBytes(bits?: number, encoding?: Encoding): string | Uint8
 /**
  * Generate a random private key
  */
-declare function generatePrivateKey(curve?: CurveType$2, encoding?: Encoding): string | Uint8Array;
+declare function generatePrivateKey(curve?: CurveType, encoding?: Encoding): string | Uint8Array;
 /**
  * Get public key from private key
  */
-declare function getPublicKey(privateKey: string | Uint8Array, curve?: CurveType$2, keyEncoding?: Encoding, outputEncoding?: Encoding): string | Uint8Array;
+declare function getPublicKey(privateKey: string | Uint8Array, curve?: CurveType, keyEncoding?: Encoding, outputEncoding?: Encoding): string | Uint8Array;
 
 /**
- * Digest Function for Quereus
+ * Self-describing content identifiers (CIDv1) for Quereus.
  *
- * Computes the hash of all arguments combined.
- * Uses SHA-256 from @noble/hashes for portable implementation.
- * Compatible with React Native and all JS environments.
- */
-/**
- * Hash algorithm options
- */
-type HashAlgorithm = 'sha256' | 'sha512' | 'blake3';
-/**
- * Input type for digest function - can be string, Uint8Array, or number
- */
-type DigestInput$1 = string | Uint8Array | number | boolean | null | undefined;
-/**
- * Options for the digest function
- */
-interface DigestOptions {
-    /** Hash algorithm to use (default: sha256) */
-    algorithm?: HashAlgorithm;
-    /** Output format (default: uint8array) */
-    output?: 'uint8array' | 'hex';
-}
-/**
- * Computes the hash of all arguments
+ * Where {@link ./crypto.ts | digest} emits a *bare* hash (raw digest bytes in
+ * some text encoding), this module emits an interoperable, self-describing
+ * CIDv1:
  *
- * @param {...DigestInput} args - Variable number of arguments to hash
- * @returns {Uint8Array} The computed hash as a Uint8Array
- *
- * @example
- * ```typescript
- * // Hash a string
- * const hash1 = Digest('hello world');
- *
- * // Hash multiple arguments
- * const hash2 = Digest('user:', 123, 'session');
- *
- * // Hash with specific algorithm
- * const hash3 = Digest.withOptions({ algorithm: 'sha512' })('data1', 'data2');
- *
- * // Get hex output
- * const hexHash = Digest.withOptions({ output: 'hex' })('hello');
  * ```
+ * CIDv1     = multibase( version ‖ multicodec(content-type) ‖ multihash )
+ * multihash = hashFnCode ‖ digestLength ‖ digestBytes
+ * ```
+ *
+ * The value carries its own multibase, multicodec (content type), and multihash
+ * (hash algorithm + length), so a consumer can decode it without out-of-band
+ * knowledge, and an algorithm migration (e.g. sha2-256 → another hash) is
+ * unambiguous because the hash code is recorded *in the value*.
+ *
+ * All framing/parsing comes from the audited `multiformats` library — there is
+ * no bespoke byte-pushing here. The actual hashing reuses the same synchronous,
+ * cross-platform `@noble/hashes` functions the rest of the plugin uses (via
+ * {@link resolveHasher}), so the output is byte-identical to the CID an external
+ * content-addressed store (IPFS/IPLD) computes for the same bytes:
+ * `cid(utf8('hello world'))` === `bafkreifzjut3te2nhyekklss27nh3k72ysco7y32koao5eei66wof36n5e`.
  */
-declare function Digest(...args: DigestInput$1[]): Uint8Array;
-declare namespace Digest {
-    var withOptions: (options: DigestOptions) => (...args: DigestInput$1[]) => string | Uint8Array<ArrayBufferLike>;
-    var sha256: (...args: DigestInput$1[]) => Uint8Array;
-    var sha512: (...args: DigestInput$1[]) => Uint8Array;
-    var blake3: (...args: DigestInput$1[]) => Uint8Array;
-    var hex: (...args: DigestInput$1[]) => string;
-    var sha256Hex: (...args: DigestInput$1[]) => string;
-    var sha512Hex: (...args: DigestInput$1[]) => string;
-    var blake3Hex: (...args: DigestInput$1[]) => string;
+/** Content-type multicodec selectable for the CID. Extensible. */
+type Multicodec = 'raw' | 'dag-cbor';
+/** Hash-algorithm multihash code selectable for the CID. */
+type MultihashCode = 'sha2-256' | 'sha2-512' | 'blake3';
+/** Multibase the CID string is rendered in. */
+type Multibase = 'base32' | 'base58btc' | 'base64url' | 'base16';
+/** Parsed parts of a CIDv1 (or CIDv0), as returned by {@link cidDecode}. */
+interface CidParts {
+    /** CID version (1 for the values this module produces; 0 for legacy CIDv0). */
+    readonly version: number;
+    /** Content-type codec name when recognized, else the raw multicodec number. */
+    readonly codec: Multicodec | number;
+    /** Hash-algorithm code name when recognized, else the raw multihash number. */
+    readonly hashCode: MultihashCode | number;
+    /** Raw digest bytes (without the multihash code/length prefix). */
+    readonly digest: Uint8Array;
 }
-
 /**
- * Sign Function for Quereus
+ * Frame an **already-computed** digest as a CIDv1 string. The caller asserts
+ * which `hash` produced the digest; the digest length is validated against that
+ * hash so a mismatched assertion is rejected rather than silently mis-framed.
  *
- * Returns the signature for the given payload using an ECC private key.
- * Uses secp256k1 from @noble/curves for portable implementation.
- * Compatible with React Native and all JS environments.
- */
-/**
- * Supported elliptic curve types
- */
-type CurveType$1 = 'secp256k1' | 'p256' | 'ed25519';
-/**
- * Private key input - can be Uint8Array, hex string, or bigint
- */
-type PrivateKeyInput = Uint8Array | string | bigint;
-/**
- * Digest input - can be Uint8Array or hex string
+ * Use this to turn an existing field-tuple digest into a CID without re-hashing,
+ * e.g. `cidV1(digest(fields, 'sha256', 'bytes'), 'sha2-256')`.
+ *
+ * @param digest - Raw digest bytes (no multihash prefix).
+ * @param hash - The multihash code asserting which algorithm produced `digest`.
+ * @param codec - Content-type multicodec (default `'raw'`).
+ * @param base - Multibase to render in (default `'base32'`, the IPFS canonical).
  */
-type DigestInput = Uint8Array | string;
+declare function cidV1(digest: Uint8Array, hash: MultihashCode, codec?: Multicodec, base?: Multibase): string;
 /**
- * Signature output format options
+ * Hash `data`, wrap the digest as a multihash, frame it as a CIDv1, and encode
+ * in `base`. The result is the same interoperable address an IPFS/IPLD store
+ * computes for the same bytes (for the matching codec/hash).
+ *
+ * @param data - The content bytes to address.
+ * @param codec - Content-type multicodec (default `'raw'`).
+ * @param hash - Hash algorithm (default `'sha2-256'`).
+ * @param base - Multibase to render in (default `'base32'`, the IPFS canonical).
  */
-type SignatureFormat = 'uint8array' | 'hex' | 'compact' | 'der';
+declare function cid(data: Uint8Array, codec?: Multicodec, hash?: MultihashCode, base?: Multibase): string;
 /**
- * Options for the Sign function
+ * Parse a CID string back into its parts, for schema validation and migration.
+ * Recognized codec/hash codes are returned as friendly names; unrecognized ones
+ * as their raw numbers. Throws cleanly on malformed input (delegated to
+ * `multiformats`), never silently mis-framing.
  */
-interface SignOptions {
-    /** Elliptic curve to use (default: secp256k1) */
-    curve?: CurveType$1;
-    /** Output format for signature (default: uint8array) */
-    format?: SignatureFormat;
-    /** Additional entropy for signatures (hedged signatures) */
-    extraEntropy?: boolean | Uint8Array;
-    /** Use low-S canonical signatures (default: true) */
-    lowS?: boolean;
-}
+declare function cidDecode(value: string): CidParts;
+
 /**
- * Sign a digest using the specified private key and curve
+ * Salted-leaf SET COMMITMENT for per-attribute selective disclosure.
  *
- * @param {DigestInput} digest - The digest/hash to sign
- * @param {PrivateKeyInput} privateKey - The private key to use for signing
- * @param {SignOptions} [options] - Optional signing parameters
- * @returns {Uint8Array | string} The signature in the requested format
+ * An authority commits to a whole set of attributes as a single root value (which
+ * it signs / persists), then later reveals only a chosen *subset* to a recipient —
+ * with a proof that the revealed values are genuinely the committed ones — without
+ * leaking the values of the withheld attributes. A flat `digest(whole set)` cannot
+ * do this (verifying one field needs the whole pre-image, so it is all-or-nothing);
+ * this construction supports *partial opening*.
+ *
+ * ## Construction (flat salted-leaf set commitment, NOT a Merkle tree)
+ *
+ * Each disclosable attribute is a salted leaf, and the commitment (root) is the
+ * digest of all leaf digests in canonical order:
  *
- * @example
- * ```typescript
- * // Basic usage with secp256k1
- * const digest = new Uint8Array(32).fill(1); // Your hash here
- * const privateKey = 'a'.repeat(64); // Your private key hex
- * const signature = Sign(digest, privateKey);
- *
- * // With specific curve and format
- * const sig = Sign(digest, privateKey, {
- *   curve: 'p256',
- *   format: 'hex'
- * });
- *
- * // With hedged signatures for extra security
- * const hedgedSig = Sign(digest, privateKey, {
- *   extraEntropy: true
- * });
  * ```
- */
-declare function Sign(digest: DigestInput, privateKey: PrivateKeyInput, options?: SignOptions): Uint8Array | string;
-declare namespace Sign {
-    var secp256k1: (digest: DigestInput, privateKey: PrivateKeyInput, options?: Omit<SignOptions, "curve">) => string | Uint8Array<ArrayBufferLike>;
-    var p256: (digest: DigestInput, privateKey: PrivateKeyInput, options?: Omit<SignOptions, "curve">) => string | Uint8Array<ArrayBufferLike>;
-    var ed25519: (digest: DigestInput, privateKey: PrivateKeyInput, options?: Omit<SignOptions, "curve">) => string | Uint8Array<ArrayBufferLike>;
-    var generatePrivateKey: (curve?: CurveType$1) => Uint8Array;
-    var getPublicKey: (privateKey: PrivateKeyInput, curve?: CurveType$1) => Uint8Array;
-}
-
-/**
- * SignatureValid Function for Quereus
+ * leafDigest = digest([SD_LEAF_DOMAIN_V1, name, value, salt])   // raw digest bytes
+ * root       = digest([SD_SET_DOMAIN_V1, sortedLeaf_0, sortedLeaf_1, ...])
+ * ```
  *
- * Returns true if the ECC signature is valid for the given digest and public key.
- * Uses @noble/curves for portable implementation.
- * Compatible with React Native and all JS environments.
+ * Both layers compose on the existing canonical {@link encodeFields} framing
+ * (injective, type-tagged, length-prefixed, replicable) — the same layering the CID
+ * work uses — so a *generic* salted-set primitive is simultaneously reusable and
+ * fully DB-enforceable. This is the same shape the IETF SD-JWT standard settled on
+ * (flat salted hashes, not a tree); we are NOT wire-compatible with SD-JWT (we reuse
+ * Optimystic's own `encodeFields` framing for cross-peer replicability) — SD-JWT is
+ * cited only as conceptual precedent that the smaller construction is the right one.
+ *
+ * Voter selective-disclosure field sets are small (a handful to a few dozen fields),
+ * so a tree's only advantage — O(log n) proof size — is marginal, while a tree drags
+ * in real footguns we would have to hand-roll and pin (arity, odd-node handling /
+ * the CVE-2012-2459 duplicate-leaf forgery class, leaf-vs-internal domain separation,
+ * and a separate audit-path proof format). A flat construction avoids all of them.
+ *
+ * ## Why these specific choices
+ *
+ * - **`name` is hashed into the leaf** so a disclosed `(value, salt)` proof cannot be
+ *   replayed against a different attribute slot (e.g. presenting an `over18=true`
+ *   proof as the `citizen` field). The binding is free given `encodeFields` framing.
+ * - **`salt` is per-leaf and mandatory** — low-entropy attributes (DOB, booleans, ZIP)
+ *   are brute-forceable from a bare hash, and independent salts also defeat cross-
+ *   registrant equality correlation. Salts come from `random_bytes` (≥128 bits).
+ * - **Canonical order is by raw leaf-digest bytes (lexicographic), and this is FORCED,
+ *   not a preference.** In a disclosure the verifier learns the *names* of only the
+ *   disclosed leaves; the withheld leaves arrive as opaque digests with no name. So the
+ *   verifier can re-derive the root only if the ordering key is something it holds for
+ *   *every* leaf — the leaf digest itself. Sorting by name would be unverifiable for
+ *   hidden leaves. Do NOT "tidy" this into a name sort.
+ * - Sort is over **raw digest bytes**, never over encoded strings — an encoding-
+ *   dependent ordering would break cross-peer agreement. Output encoding applies only
+ *   to the final root.
+ *
+ * Because leaf and root reuse `encodeFields`, a future `DIGEST_FORMAT_V1` bump changes
+ * `setCommit` output too; this coupling is intentional (one canonical framing).
  */
+
+/** One disclosable attribute. `value` spans the SQL value space ({@link DigestField}). */
+interface SaltedLeaf {
+    readonly name: string;
+    readonly value: DigestField;
+    /** base64url text (e.g. from `random_bytes`) or raw bytes. Mandatory, non-empty. */
+    readonly salt: string | Uint8Array;
+}
+/** A disclosure payload sent to a recipient. */
+interface SetDisclosure {
+    /** The opened `(name, value, salt)` triples. */
+    readonly disclosed: readonly SaltedLeaf[];
+    /** Opaque leaf digests (base64url) of the withheld leaves — no name, no value, no salt. */
+    readonly hidden: readonly string[];
+}
 /**
- * Supported elliptic curve types
+ * Raw leaf digest bytes for one salted leaf: `digest([SD_LEAF_DOMAIN_V1, name,
+ * value, salt])`. Domain-separated (can never equal a root) and name-bound (a
+ * `(value, salt)` proof cannot be replayed under another attribute name). THROWS on
+ * a missing/empty salt.
  */
-type CurveType = 'secp256k1' | 'p256' | 'ed25519';
+declare function leafDigest(leaf: SaltedLeaf, hasher: DigestHasher): Uint8Array;
 /**
- * Input types that can be Uint8Array or hex string
+ * Commit to a SET of salted leaves → a single root (the signed/persisted value).
+ * Sorts leaves by raw leaf-digest bytes, then digests them under `SD_SET_DOMAIN_V1`.
+ * Like `digest`, this emits a BARE digest — apply `cid()` on top for the self-
+ * describing column representation (`cid(set_commit(...))`).
+ *
+ * The empty set is well-defined (the digest of `[SD_SET_DOMAIN_V1]`), not an error.
+ * THROWS on a duplicate `name` or a missing/empty `salt` (invalid states made
+ * impossible). Resolve `hasher`/`encode` once and reuse — no per-call branching.
  */
-type BytesInput = Uint8Array | string;
+declare function setCommit(leaves: readonly SaltedLeaf[], hasher?: DigestHasher, encode?: OutputEncoder): string | Uint8Array;
 /**
- * Options for signature verification
+ * Split a leaf set into the revealed `(name, value, salt)` triples plus the opaque
+ * leaf digests (base64url) of the rest. Withheld `value`/`salt` never appear in the
+ * output. Names in `revealNames` that match no leaf are simply not disclosed.
+ * THROWS on a duplicate `name` or a missing/empty salt of a withheld leaf.
  */
-interface VerifyOptions {
-    /** Elliptic curve to use (default: secp256k1) */
-    curve?: CurveType;
-    /** Signature format (default: auto-detect) */
-    signatureFormat?: 'compact' | 'der' | 'raw';
-    /** Allow malleable signatures (default: false for ECDSA, true for EdDSA) */
-    allowMalleableSignatures?: boolean;
-}
+declare function setDisclose(leaves: readonly SaltedLeaf[], revealNames: readonly string[], hasher?: DigestHasher): SetDisclosure;
 /**
- * Verify if an ECC signature is valid
- *
- * @param {BytesInput} digest - The digest/hash that was signed
- * @param {BytesInput} signature - The signature to verify
- * @param {BytesInput} publicKey - The public key to verify against
- * @param {VerifyOptions} [options] - Optional verification parameters
- * @returns {boolean} True if the signature is valid, false otherwise
- *
- * @example
- * ```typescript
- * // Basic usage with secp256k1
- * const isValid = SignatureValid(digest, signature, publicKey);
- *
- * // With specific curve
- * const isValid = SignatureValid(digest, signature, publicKey, {
- *   curve: 'p256'
- * });
- *
- * // With specific signature format
- * const isValid = SignatureValid(digest, signature, publicKey, {
- *   curve: 'secp256k1',
- *   signatureFormat: 'der'
- * });
- *
- * // Allow malleable signatures
- * const isValid = SignatureValid(digest, signature, publicKey, {
- *   allowMalleableSignatures: true
- * });
- * ```
+ * Verify a disclosure against a signed root. Recomputes the disclosed leaves'
+ * digests, unions them with the supplied hidden digests, sorts by bytes, recomputes
+ * the root, and compares to `root`. This reconstructs the ENTIRE root, so it proves
+ * the disclosed leaves belong to *exactly* this committed set — the holder cannot
+ * add, drop, or swap a leaf (the leaf count is bound too).
+ *
+ * `encode` is how the signed `root` is rendered (so the recomputed root is encoded
+ * the same way before comparison); for a `Uint8Array` root the raw bytes are compared
+ * directly. Returns `false` on mismatch or malformed input — mirroring `verify`'s
+ * forgiving contract rather than throwing.
  */
-declare function SignatureValid(digest: BytesInput, signature: BytesInput, publicKey: BytesInput, options?: VerifyOptions): boolean;
-declare namespace SignatureValid {
-    var secp256k1: (digest: BytesInput, signature: BytesInput, publicKey: BytesInput, options?: Omit<VerifyOptions, "curve">) => boolean;
-    var p256: (digest: BytesInput, signature: BytesInput, publicKey: BytesInput, options?: Omit<VerifyOptions, "curve">) => boolean;
-    var ed25519: (digest: BytesInput, signature: BytesInput, publicKey: BytesInput, options?: Omit<VerifyOptions, "curve">) => boolean;
-    var batch: (verifications: Array<{
-        digest: BytesInput;
-        signature: BytesInput;
-        publicKey: BytesInput;
-        options?: VerifyOptions;
-    }>) => boolean[];
-    var detailed: (digest: BytesInput, signature: BytesInput, publicKey: BytesInput, options?: VerifyOptions) => {
-        valid: boolean;
-        curve: CurveType;
-        signatureFormat: string;
-        error?: string;
-    };
-}
+declare function setVerify(root: string | Uint8Array, disclosure: SetDisclosure, hasher?: DigestHasher, encode?: OutputEncoder): boolean;
 
-export { type BytesInput, type CurveType$2 as CurveType, Digest, type DigestInput$1 as DigestInput, type DigestOptions, type Encoding, type HashAlgorithm$1 as HashAlgorithm, type PrivateKeyInput, Sign, type SignOptions, SignatureValid, type VerifyOptions, digest, generatePrivateKey, getPublicKey, hashMod, randomBytes, sign, verify };
+export { type CidParts, type CurveType, type DigestField, type DigestHasher, type Encoding, type HashAlgorithm, type Multibase, type Multicodec, type MultihashCode, type OutputEncoder, type OutputEncoding, type SaltedLeaf, type SetDisclosure, cid, cidDecode, cidV1, digest, digestFields, encodeFields, generatePrivateKey, getPublicKey, hashMod, leafDigest, randomBytes, resolveHasher, resolveOutputEncoder, setCommit, setDisclose, setVerify, sign, verify };