@fide.work/fcp 0.0.1-alpha.0

package/dist/broadcasting/registry.d.ts

@@ -0,0 +1,111 @@
+/**
+ * FCP SDK Broadcasting Utilities
+ *
+ * Helpers for formatting attestations for JSONL registry files.
+ *
+ * Note: This module provides formatting helpers. Actual Git operations
+ * (commit, push) should be handled by your application using libraries
+ * like `simple-git` or `isomorphic-git`.
+ */
+import type { AttestationResult } from "../attestation/index.js";
+import type { Statement } from "../statement/build.js";
+/**
+ * Statement object in lean JSONL format
+ * Uses short keys for efficiency: s/sr, p/pr, o/or
+ */
+export interface JSONLStatement {
+    /** Subject Fide ID (full did:fide:0x... format) */
+    s: string;
+    /** Subject raw identifier */
+    sr: string;
+    /** Predicate Fide ID (full did:fide:0x... format) */
+    p: string;
+    /** Predicate raw identifier */
+    pr: string;
+    /** Object Fide ID (full did:fide:0x... format) */
+    o: string;
+    /** Object raw identifier */
+    or: string;
+}
+/**
+ * Lean attestation format for JSONL registry files
+ *
+ * Optimized for indexers: minimal verbosity, all data needed for verification
+ * and materialization. Each line is one attestation batch.
+ *
+ * Format matches canonical attestation data structure: {m, r, s, u}
+ * Indexer derives attestation Fide ID from these fields.
+ */
+export interface JSONLAttestation {
+    /** Method: Signing method (e.g., "ed25519", "eip712", "eip191") */
+    m: string;
+    /** User: CAIP-10 signer identifier */
+    u: string;
+    /** Root: Merkle root commitment */
+    r: string;
+    /** Signature: Cryptographic signature */
+    s: string;
+    /** Timestamp: ISO 8601 UTC timestamp */
+    t: string;
+    /** Data: Array of statements in this batch */
+    d: JSONLStatement[];
+}
+/**
+ * Format an attestation result for JSONL output
+ *
+ * Converts an AttestationResult into the lean JSONL format optimized for indexers.
+ * Each line in the JSONL file should be one attestation batch (one signature covering
+ * multiple statements via Merkle root).
+ *
+ * Format uses short keys (m, u, r, s, t, d) matching the canonical attestation
+ * data structure. Indexer derives attestation Fide ID from {m, r, s, u}.
+ *
+ * @param attestationResult - The result from createAttestation
+ * @param statements - The original statements that were attested (must match statementFideIds order)
+ * @param signedAt - ISO timestamp when the attestation was signed (defaults to current time)
+ * @returns Formatted attestation ready for JSONL output
+ *
+ * @example
+ * ```ts
+ * const statements = await buildStatementBatch([...]);
+ * const attestation = await createAttestation(statementFideIds, options);
+ * const jsonlAttestation = formatAttestationForJSONL(attestation, statements);
+ *
+ * // Write to JSONL file (one line per batch)
+ * fs.appendFileSync('attestation.jsonl', JSON.stringify(jsonlAttestation) + '\n');
+ * ```
+ */
+export declare function formatAttestationForJSONL(attestationResult: AttestationResult, statements: Statement[], signedAt?: string): JSONLAttestation;
+/**
+ * Generate the registry directory path for a given date
+ *
+ * Follows the YYYY/MM/DD structure required for Fide attestation registries.
+ * Uses UTC timezone for consistency across timezones.
+ *
+ * @param date - Date object (defaults to current UTC date)
+ * @returns Directory path (e.g., "2024/01/15")
+ *
+ * @example
+ * ```ts
+ * const path = generateRegistryPath(new Date('2024-01-15T00:00:00Z'));
+ * // Result: "2024/01/15"
+ * ```
+ */
+export declare function generateRegistryPath(date?: Date): string;
+/**
+ * Generate a JSONL filename following the registry convention
+ *
+ * Format: YYYY-MM-DD-{HHmm}-{sequence}.jsonl
+ * Uses UTC timezone for consistency across timezones.
+ *
+ * @param date - Date object (defaults to current UTC date)
+ * @param sequence - Sequence number (defaults to 1)
+ * @returns Filename (e.g., "2024-01-15-1400-1.jsonl")
+ *
+ * @example
+ * ```ts
+ * const filename = generateJSONLFilename(new Date('2024-01-15T14:00:00Z'), 1);
+ * // Result: "2024-01-15-1400-1.jsonl"
+ * ```
+ */
+export declare function generateJSONLFilename(date?: Date, sequence?: number): string;

package/dist/broadcasting/registry.js

@@ -0,0 +1,99 @@
+/**
+ * FCP SDK Broadcasting Utilities
+ *
+ * Helpers for formatting attestations for JSONL registry files.
+ *
+ * Note: This module provides formatting helpers. Actual Git operations
+ * (commit, push) should be handled by your application using libraries
+ * like `simple-git` or `isomorphic-git`.
+ */
+/**
+ * Format an attestation result for JSONL output
+ *
+ * Converts an AttestationResult into the lean JSONL format optimized for indexers.
+ * Each line in the JSONL file should be one attestation batch (one signature covering
+ * multiple statements via Merkle root).
+ *
+ * Format uses short keys (m, u, r, s, t, d) matching the canonical attestation
+ * data structure. Indexer derives attestation Fide ID from {m, r, s, u}.
+ *
+ * @param attestationResult - The result from createAttestation
+ * @param statements - The original statements that were attested (must match statementFideIds order)
+ * @param signedAt - ISO timestamp when the attestation was signed (defaults to current time)
+ * @returns Formatted attestation ready for JSONL output
+ *
+ * @example
+ * ```ts
+ * const statements = await buildStatementBatch([...]);
+ * const attestation = await createAttestation(statementFideIds, options);
+ * const jsonlAttestation = formatAttestationForJSONL(attestation, statements);
+ *
+ * // Write to JSONL file (one line per batch)
+ * fs.appendFileSync('attestation.jsonl', JSON.stringify(jsonlAttestation) + '\n');
+ * ```
+ */
+export function formatAttestationForJSONL(attestationResult, statements, signedAt = new Date().toISOString()) {
+    // Convert statements to lean JSONL format with short keys
+    const jsonlStatements = statements.map(stmt => ({
+        s: stmt.subjectFideId,
+        sr: stmt.subjectRawIdentifier,
+        p: stmt.predicateFideId,
+        pr: stmt.predicateRawIdentifier,
+        o: stmt.objectFideId,
+        or: stmt.objectRawIdentifier
+    }));
+    return {
+        m: attestationResult.attestationData.m,
+        u: attestationResult.attestationData.u,
+        r: attestationResult.merkleRoot,
+        s: attestationResult.attestationData.s,
+        t: signedAt,
+        d: jsonlStatements
+    };
+}
+/**
+ * Generate the registry directory path for a given date
+ *
+ * Follows the YYYY/MM/DD structure required for Fide attestation registries.
+ * Uses UTC timezone for consistency across timezones.
+ *
+ * @param date - Date object (defaults to current UTC date)
+ * @returns Directory path (e.g., "2024/01/15")
+ *
+ * @example
+ * ```ts
+ * const path = generateRegistryPath(new Date('2024-01-15T00:00:00Z'));
+ * // Result: "2024/01/15"
+ * ```
+ */
+export function generateRegistryPath(date = new Date()) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    return `${year}/${month}/${day}`;
+}
+/**
+ * Generate a JSONL filename following the registry convention
+ *
+ * Format: YYYY-MM-DD-{HHmm}-{sequence}.jsonl
+ * Uses UTC timezone for consistency across timezones.
+ *
+ * @param date - Date object (defaults to current UTC date)
+ * @param sequence - Sequence number (defaults to 1)
+ * @returns Filename (e.g., "2024-01-15-1400-1.jsonl")
+ *
+ * @example
+ * ```ts
+ * const filename = generateJSONLFilename(new Date('2024-01-15T14:00:00Z'), 1);
+ * // Result: "2024-01-15-1400-1.jsonl"
+ * ```
+ */
+export function generateJSONLFilename(date = new Date(), sequence = 1) {
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    const hours = String(date.getUTCHours()).padStart(2, '0');
+    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+    const timeWindow = `${hours}${minutes}`;
+    return `${year}-${month}-${day}-${timeWindow}-${sequence}.jsonl`;
+}

package/dist/experimental/attestation/create.d.ts

@@ -0,0 +1,173 @@
+/**
+ * FCP SDK Attestation Utilities
+ *
+ * High-level helpers for creating and verifying attestations.
+ * Combines Fide ID calculation, Merkle trees, and signing.
+ */
+import type { FideId } from "../../fide-id/types.js";
+import { type MerkleProof } from "../merkle/index.js";
+/**
+ * Signing method identifier
+ *
+ * `ed25519` has no external dependency.
+ * `eip712` and `eip191` require the optional `viem` peer dependency.
+ */
+export type SigningMethod = 'ed25519' | 'eip712' | 'eip191';
+/**
+ * Attestation data structure (baked into Fide ID)
+ * Uses short keys to match protocol: m, u, r, s
+ */
+export interface AttestationData {
+    /** Method: Signing standard used */
+    m: SigningMethod;
+    /** User: CAIP-10 signer identifier */
+    u: string;
+    /** Root: Merkle tree commitment */
+    r: string;
+    /** Signature: Cryptographic proof */
+    s: string;
+}
+/**
+ * Full attestation result
+ */
+export interface AttestationResult {
+    /** The Attestation Fide ID */
+    attestationFideId: FideId;
+    /** The raw attestation data */
+    attestationData: AttestationData;
+    /** The normalized JSON string (raw identifier) */
+    rawIdentifier: string;
+    /** The Merkle root */
+    merkleRoot: string;
+    /** Proofs for each statement, keyed by statement Fide ID */
+    proofs: Map<string, MerkleProof>;
+}
+/**
+ * Options for creating an attestation
+ */
+export interface CreateAttestationOptions {
+    /** The signing method to use (`eip712`/`eip191` require `viem` to be installed). */
+    method: SigningMethod;
+    /** CAIP-10 identifier for the signer (e.g., "eip155:1:0x...") */
+    caip10User: string;
+    /** Signing function - takes merkle root string, returns signature hex string */
+    sign: (merkleRoot: string) => Promise<string>;
+}
+/**
+ * Provenance statement linking a statement to its attestation
+ */
+export interface ProvenanceStatement {
+    subjectFideId: string;
+    predicateFideId: string;
+    objectFideId: string;
+    predicateRawIdentifier: string;
+    objectRawIdentifier: string;
+}
+/**
+ * Create an attestation for a batch of statement Fide IDs
+ *
+ * This function:
+ * 1. Builds a Merkle tree from the statement Fide IDs
+ * 2. Signs the Merkle root using the provided signing function
+ * 3. Creates the attestation data structure
+ * 4. Derives the Attestation Fide ID
+ *
+ * @param statementFideIds - Array of statement Fide IDs.
+ * @param options - Configuration options for operation.
+ * @paramDefault statementFideIds ["did:fide:0x10...", "did:fide:0x10..."]
+ * @paramDefault options {"method":"ed25519","caip10User":"ed25519:123...","sign":"async (root) => 'signature'"}
+ * @returns Full attestation result including ID, data, and proofs
+ *
+ * @example
+ * ```ts
+ * import { createAttestation, signEd25519 } from '@fide.work/fcp';
+ *
+ * const result = await createAttestation(
+ *   [statement1FideId, statement2FideId],
+ *   {
+ *     method: 'ed25519',
+ *     caip10User: 'ed25519::abc123...',
+ *     sign: (root) => signEd25519(root, privateKey)
+ *   }
+ * );
+ *
+ * console.log('Attestation ID:', result.attestationFideId);
+ * ```
+ */
+export declare function createAttestation(statementFideIds: string[], options: CreateAttestationOptions): Promise<AttestationResult>;
+/**
+ * Create provenance statements linking each statement to the attestation
+ *
+ * These are the "Statement → prov:wasGeneratedBy → Attestation" triples
+ * that connect content statements to their attestation.
+ *
+ * @param statementFideIds - Array of statement Fide IDs to include in attestation
+ * @param attestationResult - The attestation data structure
+ * @returns Array of provenance statements to publish
+ *
+ * @example
+ * ```ts
+ * const provenance = await createProvenanceStatements(
+ *   statementFideIds,
+ *   attestationResult
+ * );
+ * // Each provenance statement links a content statement to the attestation
+ * ```
+ */
+export declare function createProvenanceStatements(statementFideIds: string[], attestationResult: AttestationResult): Promise<ProvenanceStatement[]>;
+/**
+ * Verify that a statement is part of an attestation
+ *
+ * This verifies the Merkle proof but does NOT verify the signature.
+ * Signature verification depends on the signing method and should
+ * be done separately using verifyEd25519 or verifyEip712.
+ *
+ * @param statementFideId - The leaf value to verify.
+ * @param proof - The Merkle proof path.
+ * @param attestationData - The attestation data.
+ * @paramDefault statementFideId did:fide:0x10...
+ * @paramDefault proof ["hash1", "hash2"]
+ * @paramDefault attestationData {"r":"root-hash"}
+ * @returns True if the statement is in the attestation
+ *
+ * @example
+ * ```ts
+ * const isInBatch = await verifyStatementInAttestation(
+ *   statementFideId,
+ *   proof,
+ *   attestationData
+ * );
+ * ```
+ */
+export declare function verifyStatementInAttestation(statementFideId: string, proof: MerkleProof, attestationData: AttestationData | {
+    r: string;
+}): Promise<boolean>;
+/**
+ * Parse attestation data from a raw identifier string
+ *
+ * @param rawIdentifier - The JSON string from objectRawIdentifier
+ * @returns Parsed attestation data
+ * @throws Error if JSON is invalid
+ *
+ * @example
+ * ```ts
+ * const attestationData = parseAttestationData(provenanceStatement.objectRawIdentifier);
+ * ```
+ */
+export declare function parseAttestationData(rawIdentifier: string): AttestationData;
+/**
+ * Verify that an attestation's Fide ID is correctly derived
+ *
+ * @param attestationFideId - The claimed attestation Fide ID
+ * @param rawIdentifier - The raw identifier JSON string
+ * @returns True if the Fide ID is correctly derived
+ *
+ * @example
+ * ```ts
+ * const isValidId = await verifyAttestationFideId(
+ *   provenanceStatement.objectFideId,
+ *   provenanceStatement.objectRawIdentifier
+ * );
+ * ```
+ */
+export declare function verifyAttestationFideId(attestationFideId: string, rawIdentifier: string): Promise<boolean>;

package/dist/experimental/attestation/create.js

@@ -0,0 +1,188 @@
+/**
+ * FCP SDK Attestation Utilities
+ *
+ * High-level helpers for creating and verifying attestations.
+ * Combines Fide ID calculation, Merkle trees, and signing.
+ */
+import { calculateFideId } from "../../fide-id/index.js";
+import { buildMerkleTree, verifyMerkleProof } from "../merkle/index.js";
+// ============================================================================
+// ATTESTATION CREATION
+// ============================================================================
+/**
+ * Create an attestation for a batch of statement Fide IDs
+ *
+ * This function:
+ * 1. Builds a Merkle tree from the statement Fide IDs
+ * 2. Signs the Merkle root using the provided signing function
+ * 3. Creates the attestation data structure
+ * 4. Derives the Attestation Fide ID
+ *
+ * @param statementFideIds - Array of statement Fide IDs.
+ * @param options - Configuration options for operation.
+ * @paramDefault statementFideIds ["did:fide:0x10...", "did:fide:0x10..."]
+ * @paramDefault options {"method":"ed25519","caip10User":"ed25519:123...","sign":"async (root) => 'signature'"}
+ * @returns Full attestation result including ID, data, and proofs
+ *
+ * @example
+ * ```ts
+ * import { createAttestation, signEd25519 } from '@fide.work/fcp';
+ *
+ * const result = await createAttestation(
+ *   [statement1FideId, statement2FideId],
+ *   {
+ *     method: 'ed25519',
+ *     caip10User: 'ed25519::abc123...',
+ *     sign: (root) => signEd25519(root, privateKey)
+ *   }
+ * );
+ *
+ * console.log('Attestation ID:', result.attestationFideId);
+ * ```
+ */
+export async function createAttestation(statementFideIds, options) {
+    if (statementFideIds.length === 0) {
+        throw new Error('Cannot create attestation from empty statement list');
+    }
+    // 1. Build Merkle tree
+    const merkleResult = await buildMerkleTree(statementFideIds);
+    const merkleRoot = merkleResult.root;
+    // 2. Sign the Merkle root
+    const signature = await options.sign(merkleRoot);
+    // 3. Create attestation data (with short keys, alphabetically ordered)
+    const attestationData = {
+        m: options.method,
+        r: merkleRoot,
+        s: signature,
+        u: options.caip10User
+    };
+    // 4. Create normalized JSON string (alphabetically ordered for determinism)
+    // IMPORTANT: Keys MUST be in alphabetical order (m, r, s, u) for deterministic hashing
+    const rawIdentifier = JSON.stringify({
+        m: attestationData.m,
+        r: attestationData.r,
+        s: attestationData.s,
+        u: attestationData.u
+    });
+    // 5. Derive attestation-like ID with fixed 0xaa prefix.
+    const attestationFideId = await calculateAaPrefixedId(rawIdentifier);
+    return {
+        attestationFideId,
+        attestationData,
+        rawIdentifier,
+        merkleRoot,
+        proofs: merkleResult.proofs
+    };
+}
+/**
+ * Create provenance statements linking each statement to the attestation
+ *
+ * These are the "Statement → prov:wasGeneratedBy → Attestation" triples
+ * that connect content statements to their attestation.
+ *
+ * @param statementFideIds - Array of statement Fide IDs to include in attestation
+ * @param attestationResult - The attestation data structure
+ * @returns Array of provenance statements to publish
+ *
+ * @example
+ * ```ts
+ * const provenance = await createProvenanceStatements(
+ *   statementFideIds,
+ *   attestationResult
+ * );
+ * // Each provenance statement links a content statement to the attestation
+ * ```
+ */
+export async function createProvenanceStatements(statementFideIds, attestationResult) {
+    // Get the prov:wasGeneratedBy predicate ID
+    const wasGeneratedByPredicateId = await calculateFideId('CreativeWork', 'CreativeWork', 'prov:wasGeneratedBy');
+    return statementFideIds.map(statementFideId => ({
+        subjectFideId: statementFideId,
+        predicateFideId: wasGeneratedByPredicateId,
+        objectFideId: attestationResult.attestationFideId,
+        predicateRawIdentifier: 'prov:wasGeneratedBy',
+        objectRawIdentifier: attestationResult.rawIdentifier
+    }));
+}
+// ============================================================================
+// ATTESTATION VERIFICATION
+// ============================================================================
+/**
+ * Verify that a statement is part of an attestation
+ *
+ * This verifies the Merkle proof but does NOT verify the signature.
+ * Signature verification depends on the signing method and should
+ * be done separately using verifyEd25519 or verifyEip712.
+ *
+ * @param statementFideId - The leaf value to verify.
+ * @param proof - The Merkle proof path.
+ * @param attestationData - The attestation data.
+ * @paramDefault statementFideId did:fide:0x10...
+ * @paramDefault proof ["hash1", "hash2"]
+ * @paramDefault attestationData {"r":"root-hash"}
+ * @returns True if the statement is in the attestation
+ *
+ * @example
+ * ```ts
+ * const isInBatch = await verifyStatementInAttestation(
+ *   statementFideId,
+ *   proof,
+ *   attestationData
+ * );
+ * ```
+ */
+export async function verifyStatementInAttestation(statementFideId, proof, attestationData) {
+    return await verifyMerkleProof(statementFideId, proof, attestationData.r);
+}
+/**
+ * Parse attestation data from a raw identifier string
+ *
+ * @param rawIdentifier - The JSON string from objectRawIdentifier
+ * @returns Parsed attestation data
+ * @throws Error if JSON is invalid
+ *
+ * @example
+ * ```ts
+ * const attestationData = parseAttestationData(provenanceStatement.objectRawIdentifier);
+ * ```
+ */
+export function parseAttestationData(rawIdentifier) {
+    const parsed = JSON.parse(rawIdentifier);
+    if (!parsed.m || !parsed.u || !parsed.r || !parsed.s) {
+        throw new Error('Invalid attestation data: missing required fields (m, u, r, s)');
+    }
+    return {
+        m: parsed.m,
+        u: parsed.u,
+        r: parsed.r,
+        s: parsed.s
+    };
+}
+/**
+ * Verify that an attestation's Fide ID is correctly derived
+ *
+ * @param attestationFideId - The claimed attestation Fide ID
+ * @param rawIdentifier - The raw identifier JSON string
+ * @returns True if the Fide ID is correctly derived
+ *
+ * @example
+ * ```ts
+ * const isValidId = await verifyAttestationFideId(
+ *   provenanceStatement.objectFideId,
+ *   provenanceStatement.objectRawIdentifier
+ * );
+ * ```
+ */
+export async function verifyAttestationFideId(attestationFideId, rawIdentifier) {
+    const expectedId = await calculateAaPrefixedId(rawIdentifier);
+    return attestationFideId.toLowerCase() === expectedId.toLowerCase();
+}
+async function calculateAaPrefixedId(rawIdentifier) {
+    const bytes = new TextEncoder().encode(rawIdentifier);
+    const subtle = globalThis.crypto?.subtle ?? (await import("node:crypto")).webcrypto.subtle;
+    const digest = await subtle.digest("SHA-256", bytes);
+    const hashHex = Array.from(new Uint8Array(digest))
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+    return `did:fide:0xaa${hashHex.slice(-38)}`;
+}

package/dist/experimental/attestation/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * FCP SDK - Attestation Module
+ *
+ * Re-exports all attestation utilities.
+ */
+export { createAttestation, createProvenanceStatements, verifyStatementInAttestation, parseAttestationData, verifyAttestationFideId, type SigningMethod, type AttestationData, type AttestationResult, type CreateAttestationOptions, type ProvenanceStatement } from "./create.js";
+export { verifyAttestation, type VerifyAttestationOptions } from "./verify.js";

package/dist/experimental/attestation/index.js

@@ -0,0 +1,7 @@
+/**
+ * FCP SDK - Attestation Module
+ *
+ * Re-exports all attestation utilities.
+ */
+export { createAttestation, createProvenanceStatements, verifyStatementInAttestation, parseAttestationData, verifyAttestationFideId } from "./create.js";
+export { verifyAttestation } from "./verify.js";

package/dist/experimental/attestation/verify.d.ts

@@ -0,0 +1,56 @@
+/**
+ * FCP SDK Attestation Verification Utilities
+ *
+ * Full verification functions that combine Merkle proof and signature verification.
+ */
+import { type AttestationData } from "./create.js";
+import type { MerkleProof } from "../merkle/index.js";
+import type { SigningMethod } from "./create.js";
+/**
+ * Options for verifying an attestation
+ */
+export interface VerifyAttestationOptions {
+    /** The signing method used (`eip712`/`eip191` require `viem` to be installed). */
+    method: SigningMethod;
+    /** Public key or address for signature verification */
+    publicKeyOrAddress: CryptoKey | `0x${string}`;
+}
+/**
+ * Verify a complete attestation (both Merkle proof and signature)
+ *
+ * This function performs full verification:
+ * 1. Verifies the Merkle proof (statement is in the batch)
+ * 2. Verifies the signature (signer authorized the batch)
+ *
+ * @param statementFideId - The leaf value to verify in Merkle tree
+ * @param proof - The Merkle proof path (array of hashes from leaf to root)
+ * @param attestationData - The attestation data structure
+ * @param options - Configuration options for operation (method, public key/address, etc.)
+ * @returns True if both Merkle proof and signature are valid
+ *
+ * @example
+ * ```ts
+ * // With Ed25519
+ * const isValid = await verifyAttestation(
+ *   statementFideId,
+ *   proof,
+ *   attestationData,
+ *   {
+ *     method: 'ed25519',
+ *     publicKeyOrAddress: publicKey
+ *   }
+ * );
+ *
+ * // With EIP-712
+ * const isValid = await verifyAttestation(
+ *   statementFideId,
+ *   proof,
+ *   attestationData,
+ *   {
+ *     method: 'eip712',
+ *     publicKeyOrAddress: address
+ *   }
+ * );
+ * ```
+ */
+export declare function verifyAttestation(statementFideId: string, proof: MerkleProof, attestationData: AttestationData | string, options: VerifyAttestationOptions): Promise<boolean>;