@fide.work/fcp 0.0.1-alpha.0

package/dist/merkle/index.js

@@ -0,0 +1,6 @@
+/**
+ * FCP SDK - Merkle Tree Module
+ *
+ * Re-exports all Merkle tree utilities.
+ */
+export { buildMerkleTree, verifyMerkleProof } from "./tree.js";

package/dist/merkle/tree.d.ts

@@ -0,0 +1,72 @@
+/**
+ * FCP SDK Merkle Tree Utilities
+ * Build and verify Merkle trees for batch attestations
+ *
+ * Uses SHA-256 for hashing (same as Fide ID derivation).
+ * Zero external dependencies - uses native Web Crypto API.
+ */
+/**
+ * Merkle proof element
+ */
+export interface MerkleProofElement {
+    /** The sibling hash at this level */
+    hash: string;
+    /** Position of the sibling: 'left' or 'right' */
+    position: 'left' | 'right';
+}
+/**
+ * Merkle proof for a specific leaf
+ */
+export type MerkleProof = MerkleProofElement[];
+/**
+ * Result from building a Merkle tree
+ */
+export interface MerkleTreeResult {
+    /** The Merkle root (hex string) */
+    root: string;
+    /** Proofs for each leaf, indexed by leaf value */
+    proofs: Map<string, MerkleProof>;
+    /** The leaves used to build the tree (normalized) */
+    leaves: string[];
+}
+/**
+ * Build a Merkle tree from an array of Fide IDs
+ *
+ * The tree is built bottom-up by iteratively hashing pairs of nodes.
+ * If there's an odd number of nodes, the last node is duplicated.
+ *
+ * @param leaves - Array of statement Fide IDs to include in the tree
+ * @returns MerkleTreeResult with root and proofs for each leaf
+ * @throws Error if leaves array is empty
+ *
+ * @example
+ * ```ts
+ * const result = await buildMerkleTree([
+ *   'did:fide:0x00abc...',
+ *   'did:fide:0x00def...',
+ *   'did:fide:0x00ghi...'
+ * ]);
+ *
+ * console.log('Root:', result.root);
+ * console.log('Proof for first leaf:', result.proofs.get('did:fide:0x00abc...'));
+ * ```
+ */
+export declare function buildMerkleTree(leaves: string[]): Promise<MerkleTreeResult>;
+/**
+ * Verify that a leaf is part of a Merkle tree given its proof
+ *
+ * @param leaf - The leaf value to verify in Merkle tree
+ * @param proof - The Merkle proof path (array of hashes from leaf to root)
+ * @param root - The Merkle tree root hash (0x-prefixed hex)
+ * @returns True if the proof is valid
+ *
+ * @example
+ * ```ts
+ * const isValid = await verifyMerkleProof(
+ *   'did:fide:0x00abc...',
+ *   proof,
+ *   root
+ * );
+ * ```
+ */
+export declare function verifyMerkleProof(leaf: string, proof: MerkleProof, root: string): Promise<boolean>;

package/dist/merkle/tree.js

@@ -0,0 +1,154 @@
+/**
+ * FCP SDK Merkle Tree Utilities
+ * Build and verify Merkle trees for batch attestations
+ *
+ * Uses SHA-256 for hashing (same as Fide ID derivation).
+ * Zero external dependencies - uses native Web Crypto API.
+ */
+/**
+ * Get the Web Crypto API (works in browsers and Node.js)
+ */
+async function getSubtleCrypto() {
+    if (globalThis.crypto?.subtle) {
+        return globalThis.crypto.subtle;
+    }
+    const { webcrypto } = await import("node:crypto");
+    return webcrypto.subtle;
+}
+/**
+ * Hash two values together using SHA-256
+ * Sorts inputs to ensure consistent ordering
+ */
+async function hashPair(left, right) {
+    const subtle = await getSubtleCrypto();
+    // Concatenate left + right (already sorted at construction time)
+    const combined = left + right;
+    const encoder = new TextEncoder();
+    const data = encoder.encode(combined);
+    const hashBuffer = await subtle.digest('SHA-256', data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * Normalize a Fide ID to a consistent hex format for hashing
+ * Accepts: "did:fide:0x..." or "0x..."
+ * Returns: lowercase hex without prefix
+ */
+function normalizeLeaf(fideId) {
+    const trimmed = fideId.trim().toLowerCase();
+    if (trimmed.startsWith('did:fide:0x')) {
+        return trimmed.slice('did:fide:0x'.length);
+    }
+    if (trimmed.startsWith('0x')) {
+        return trimmed.slice(2);
+    }
+    return trimmed;
+}
+/**
+ * Build a Merkle tree from an array of Fide IDs
+ *
+ * The tree is built bottom-up by iteratively hashing pairs of nodes.
+ * If there's an odd number of nodes, the last node is duplicated.
+ *
+ * @param leaves - Array of statement Fide IDs to include in the tree
+ * @returns MerkleTreeResult with root and proofs for each leaf
+ * @throws Error if leaves array is empty
+ *
+ * @example
+ * ```ts
+ * const result = await buildMerkleTree([
+ *   'did:fide:0x00abc...',
+ *   'did:fide:0x00def...',
+ *   'did:fide:0x00ghi...'
+ * ]);
+ *
+ * console.log('Root:', result.root);
+ * console.log('Proof for first leaf:', result.proofs.get('did:fide:0x00abc...'));
+ * ```
+ */
+export async function buildMerkleTree(leaves) {
+    if (leaves.length === 0) {
+        throw new Error('Cannot build Merkle tree from empty array');
+    }
+    // Normalize all leaves
+    const normalizedLeaves = leaves.map(normalizeLeaf);
+    // Initialize proofs map (keyed by original leaf value)
+    const proofs = new Map();
+    leaves.forEach(leaf => proofs.set(leaf, []));
+    // Also map normalized → original for lookup
+    const normalizedToOriginal = new Map();
+    leaves.forEach((original, i) => {
+        normalizedToOriginal.set(normalizedLeaves[i], original);
+    });
+    // Build tree level by level
+    let currentLevel = [...normalizedLeaves];
+    // Track which original leaves each node represents
+    // At level 0, each node represents itself
+    let nodeToLeaves = new Map();
+    normalizedLeaves.forEach(leaf => nodeToLeaves.set(leaf, [leaf]));
+    while (currentLevel.length > 1) {
+        const nextLevel = [];
+        const nextNodeToLeaves = new Map();
+        for (let i = 0; i < currentLevel.length; i += 2) {
+            const left = currentLevel[i];
+            const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : left; // Duplicate if odd
+            const parent = await hashPair(left, right);
+            nextLevel.push(parent);
+            // Track which leaves this parent represents
+            const leftLeaves = nodeToLeaves.get(left) || [];
+            const rightLeaves = nodeToLeaves.get(right) || [];
+            nextNodeToLeaves.set(parent, [...leftLeaves, ...rightLeaves]);
+            // Add proof elements for all leaves on each side
+            // Leaves on the left get right sibling, leaves on the right get left sibling
+            for (const leafNorm of leftLeaves) {
+                const original = normalizedToOriginal.get(leafNorm);
+                const proof = proofs.get(original);
+                proof.push({ hash: right, position: 'right' });
+            }
+            // Only add if right != left (not a duplicate)
+            if (left !== right) {
+                for (const leafNorm of rightLeaves) {
+                    const original = normalizedToOriginal.get(leafNorm);
+                    const proof = proofs.get(original);
+                    proof.push({ hash: left, position: 'left' });
+                }
+            }
+        }
+        currentLevel = nextLevel;
+        nodeToLeaves = nextNodeToLeaves;
+    }
+    return {
+        root: currentLevel[0],
+        proofs,
+        leaves
+    };
+}
+/**
+ * Verify that a leaf is part of a Merkle tree given its proof
+ *
+ * @param leaf - The leaf value to verify in Merkle tree
+ * @param proof - The Merkle proof path (array of hashes from leaf to root)
+ * @param root - The Merkle tree root hash (0x-prefixed hex)
+ * @returns True if the proof is valid
+ *
+ * @example
+ * ```ts
+ * const isValid = await verifyMerkleProof(
+ *   'did:fide:0x00abc...',
+ *   proof,
+ *   root
+ * );
+ * ```
+ */
+export async function verifyMerkleProof(leaf, proof, root) {
+    let currentHash = normalizeLeaf(leaf);
+    for (const element of proof) {
+        if (element.position === 'left') {
+            currentHash = await hashPair(element.hash, currentHash);
+        }
+        else {
+            currentHash = await hashPair(currentHash, element.hash);
+        }
+    }
+    return currentHash === root;
+}

package/dist/schema/evaluations.d.ts

@@ -0,0 +1,31 @@
+/**
+ * FCP SDK Evaluation Method Constants
+ */
+/**
+ * Common Fide evaluation methods.
+ *
+ * These are used as predicates in Evaluation (0xe5) statements.
+ */
+export declare const FIDE_EVALUATION_METHODS: {
+    /**
+     * Trust in an identity resolution (owl:sameAs) claim.
+     * Evaluates a Statement about owl:sameAs.
+     */
+    readonly aliasResolutionTrust: "https://github.com/fide-work/evaluation-methods/alias-resolution-trust/v1";
+    /**
+     * Trust in an owl:sameAs claim specifically for Person entities.
+     */
+    readonly owlSameAsPerson: "https://github.com/fide-work/evaluation-methods/owl-sameas-person/v1";
+    /**
+     * Trust in an owl:sameAs claim specifically for Organization entities.
+     */
+    readonly owlSameAsOrganization: "https://github.com/fide-work/evaluation-methods/owl-sameas-organization/v1";
+    /**
+     * Trust in the accuracy of a statement.
+     */
+    readonly statementAccuracy: "https://github.com/fide-work/evaluation-methods/statement-accuracy/v1";
+    /**
+     * Trust in bridging consensus.
+     */
+    readonly bridgingConsensus: "https://github.com/fide-work/evaluation-methods/bridging-consensus/v1";
+};

package/dist/schema/evaluations.js

@@ -0,0 +1,31 @@
+/**
+ * FCP SDK Evaluation Method Constants
+ */
+/**
+ * Common Fide evaluation methods.
+ *
+ * These are used as predicates in Evaluation (0xe5) statements.
+ */
+export const FIDE_EVALUATION_METHODS = {
+    /**
+     * Trust in an identity resolution (owl:sameAs) claim.
+     * Evaluates a Statement about owl:sameAs.
+     */
+    aliasResolutionTrust: 'https://github.com/fide-work/evaluation-methods/alias-resolution-trust/v1',
+    /**
+     * Trust in an owl:sameAs claim specifically for Person entities.
+     */
+    owlSameAsPerson: 'https://github.com/fide-work/evaluation-methods/owl-sameas-person/v1',
+    /**
+     * Trust in an owl:sameAs claim specifically for Organization entities.
+     */
+    owlSameAsOrganization: 'https://github.com/fide-work/evaluation-methods/owl-sameas-organization/v1',
+    /**
+     * Trust in the accuracy of a statement.
+     */
+    statementAccuracy: 'https://github.com/fide-work/evaluation-methods/statement-accuracy/v1',
+    /**
+     * Trust in bridging consensus.
+     */
+    bridgingConsensus: 'https://github.com/fide-work/evaluation-methods/bridging-consensus/v1'
+};

package/dist/schema/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * FCP SDK - Schema Module
+ *
+ * Re-exports all schema utilities.
+ */
+export { SCHEMA_PREDICATES, PROV_PREDICATES, OWL_PREDICATES, SEC_PREDICATES, expandPredicateIdentifier, type PredicateNamespace } from "./predicates.js";

package/dist/schema/index.js

@@ -0,0 +1,6 @@
+/**
+ * FCP SDK - Schema Module
+ *
+ * Re-exports all schema utilities.
+ */
+export { SCHEMA_PREDICATES, PROV_PREDICATES, OWL_PREDICATES, SEC_PREDICATES, expandPredicateIdentifier } from "./predicates.js";

package/dist/schema/predicates.d.ts

@@ -0,0 +1,110 @@
+/**
+ * FCP SDK Schema Utilities
+ *
+ * Common predicate constants and helpers for working with FCP schema predicates.
+ *
+ * Note: The SDK handles deterministic JSON serialization (RFC 8785) internally
+ * following the json-stable-stringify philosophy - using manually ordered keys
+ * for all Fide ID calculations. No external dependencies are required.
+ */
+/**
+ * Expand shorthand predicate identifiers to full canonical URLs.
+ * `calculateFideId` stays dumb; this provides a convenience layer for predicates.
+ *
+ * Accepts shorthand (e.g. `schema:name`, `owl:sameAs`) and returns the full IRI.
+ * Pass-through for strings that already look like full URLs (contain `://`).
+ *
+ * @param predicate - Shorthand (e.g. `schema:name`) or full URL
+ * @returns Full canonical URL (e.g. `https://schema.org/name`)
+ *
+ * @example
+ * ```ts
+ * expandPredicateIdentifier('schema:name')     // 'https://schema.org/name'
+ * expandPredicateIdentifier('owl:sameAs')      // 'https://www.w3.org/2002/07/owl#sameAs'
+ * expandPredicateIdentifier('https://schema.org/name')  // unchanged
+ * ```
+ */
+export declare function expandPredicateIdentifier(predicate: string): string;
+/**
+ * Predicate namespace identifiers.
+ *
+ * @remarks
+ * Identifies which ontology namespace a predicate belongs to:
+ * - `schema`: Schema.org predicates for common attributes and relationships
+ * - `prov`: PROV-O (Provenance Ontology) predicates for tracking lineage
+ * - `owl`: OWL (Web Ontology Language) predicates for ontology relationships
+ * - `sec`: W3C Security Vocabulary predicates for access control
+ */
+export type PredicateNamespace = 'schema' | 'prov' | 'owl' | 'sec';
+/**
+ * Common Schema.org predicates.
+ *
+ * These are commonly used predicates in FCP statements. For the complete list,
+ * see [Schema.org](https://schema.org/).
+ *
+ * @remarks
+ * This is a record of predicate strings following the `schema:` namespace convention.
+ * Pass directly to functions expecting predicate strings.
+ */
+export declare const SCHEMA_PREDICATES: {
+    readonly name: "schema:name";
+    readonly description: "schema:description";
+    readonly type: "schema:type";
+    readonly url: "schema:url";
+    readonly image: "schema:image";
+    readonly worksFor: "schema:worksFor";
+    readonly memberOf: "schema:memberOf";
+    readonly parentOrganization: "schema:parentOrganization";
+    readonly knows: "schema:knows";
+    readonly follows: "schema:follows";
+    readonly actionStatus: "schema:actionStatus";
+    readonly identifier: "schema:identifier";
+    readonly sameAs: "schema:sameAs";
+};
+/**
+ * PROV-O (Provenance Ontology) predicates.
+ *
+ * Used for tracking provenance and lineage in FCP statements.
+ *
+ * @remarks
+ * This is a record of predicate strings following the `prov:` namespace convention.
+ * Pass directly to functions expecting predicate strings.
+ */
+export declare const PROV_PREDICATES: {
+    readonly wasGeneratedBy: "prov:wasGeneratedBy";
+    readonly wasDerivedFrom: "prov:wasDerivedFrom";
+    readonly wasAssociatedWith: "prov:wasAssociatedWith";
+    readonly wasAttributedTo: "prov:wasAttributedTo";
+    readonly wasRevisionOf: "prov:wasRevisionOf";
+    readonly wasQuotedFrom: "prov:wasQuotedFrom";
+    readonly actedOnBehalfOf: "prov:actedOnBehalfOf";
+};
+/**
+ * OWL (Web Ontology Language) predicates.
+ *
+ * Used for ontology relationships.
+ *
+ * @remarks
+ * This is a record of predicate strings following the `owl:` namespace convention.
+ * Pass directly to functions expecting predicate strings.
+ */
+export declare const OWL_PREDICATES: {
+    readonly sameAs: "owl:sameAs";
+    readonly differentFrom: "owl:differentFrom";
+    readonly equivalentClass: "owl:equivalentClass";
+    readonly equivalentProperty: "owl:equivalentProperty";
+};
+/**
+ * W3C Security Vocabulary predicates.
+ *
+ * Used for security and access control relationships.
+ *
+ * @remarks
+ * This is a record of predicate strings following the `sec:` namespace convention.
+ * Pass directly to functions expecting predicate strings.
+ */
+export declare const SEC_PREDICATES: {
+    readonly controller: "sec:controller";
+    readonly owner: "sec:owner";
+    readonly authorizedBy: "sec:authorizedBy";
+};

package/dist/schema/predicates.js

@@ -0,0 +1,122 @@
+/**
+ * FCP SDK Schema Utilities
+ *
+ * Common predicate constants and helpers for working with FCP schema predicates.
+ *
+ * Note: The SDK handles deterministic JSON serialization (RFC 8785) internally
+ * following the json-stable-stringify philosophy - using manually ordered keys
+ * for all Fide ID calculations. No external dependencies are required.
+ */
+/** Prefix to canonical base URL. Schema uses /, others use #. */
+const PREDICATE_NAMESPACES = {
+    schema: "https://schema.org/",
+    owl: "https://www.w3.org/2002/07/owl#",
+    prov: "https://www.w3.org/ns/prov#",
+    sec: "https://w3id.org/security#",
+    skos: "https://www.w3.org/2004/02/skos/core#"
+};
+/**
+ * Expand shorthand predicate identifiers to full canonical URLs.
+ * `calculateFideId` stays dumb; this provides a convenience layer for predicates.
+ *
+ * Accepts shorthand (e.g. `schema:name`, `owl:sameAs`) and returns the full IRI.
+ * Pass-through for strings that already look like full URLs (contain `://`).
+ *
+ * @param predicate - Shorthand (e.g. `schema:name`) or full URL
+ * @returns Full canonical URL (e.g. `https://schema.org/name`)
+ *
+ * @example
+ * ```ts
+ * expandPredicateIdentifier('schema:name')     // 'https://schema.org/name'
+ * expandPredicateIdentifier('owl:sameAs')      // 'https://www.w3.org/2002/07/owl#sameAs'
+ * expandPredicateIdentifier('https://schema.org/name')  // unchanged
+ * ```
+ */
+export function expandPredicateIdentifier(predicate) {
+    if (predicate.includes("://"))
+        return predicate;
+    const colon = predicate.indexOf(":");
+    if (colon < 1)
+        return predicate;
+    const prefix = predicate.slice(0, colon);
+    const base = PREDICATE_NAMESPACES[prefix];
+    if (!base)
+        return predicate;
+    return base + predicate.slice(colon + 1);
+}
+/**
+ * Common Schema.org predicates.
+ *
+ * These are commonly used predicates in FCP statements. For the complete list,
+ * see [Schema.org](https://schema.org/).
+ *
+ * @remarks
+ * This is a record of predicate strings following the `schema:` namespace convention.
+ * Pass directly to functions expecting predicate strings.
+ */
+export const SCHEMA_PREDICATES = {
+    // Attributes
+    name: 'schema:name',
+    description: 'schema:description',
+    type: 'schema:type',
+    url: 'schema:url',
+    image: 'schema:image',
+    // Relationships
+    worksFor: 'schema:worksFor',
+    memberOf: 'schema:memberOf',
+    parentOrganization: 'schema:parentOrganization',
+    knows: 'schema:knows',
+    follows: 'schema:follows',
+    // Actions
+    actionStatus: 'schema:actionStatus',
+    // Other
+    identifier: 'schema:identifier',
+    sameAs: 'schema:sameAs'
+};
+/**
+ * PROV-O (Provenance Ontology) predicates.
+ *
+ * Used for tracking provenance and lineage in FCP statements.
+ *
+ * @remarks
+ * This is a record of predicate strings following the `prov:` namespace convention.
+ * Pass directly to functions expecting predicate strings.
+ */
+export const PROV_PREDICATES = {
+    wasGeneratedBy: 'prov:wasGeneratedBy',
+    wasDerivedFrom: 'prov:wasDerivedFrom',
+    wasAssociatedWith: 'prov:wasAssociatedWith',
+    wasAttributedTo: 'prov:wasAttributedTo',
+    wasRevisionOf: 'prov:wasRevisionOf',
+    wasQuotedFrom: 'prov:wasQuotedFrom',
+    actedOnBehalfOf: 'prov:actedOnBehalfOf'
+};
+/**
+ * OWL (Web Ontology Language) predicates.
+ *
+ * Used for ontology relationships.
+ *
+ * @remarks
+ * This is a record of predicate strings following the `owl:` namespace convention.
+ * Pass directly to functions expecting predicate strings.
+ */
+export const OWL_PREDICATES = {
+    sameAs: 'owl:sameAs',
+    differentFrom: 'owl:differentFrom',
+    equivalentClass: 'owl:equivalentClass',
+    equivalentProperty: 'owl:equivalentProperty'
+};
+/**
+ * W3C Security Vocabulary predicates.
+ *
+ * Used for security and access control relationships.
+ *
+ * @remarks
+ * This is a record of predicate strings following the `sec:` namespace convention.
+ * Pass directly to functions expecting predicate strings.
+ */
+export const SEC_PREDICATES = {
+    controller: 'sec:controller',
+    owner: 'sec:owner',
+    authorizedBy: 'sec:authorizedBy'
+};

package/dist/signing/ed25519.d.ts

@@ -0,0 +1,116 @@
+/**
+ * FCP SDK Signing Utilities
+ * Ed25519 key generation and signing using native Web Crypto API
+ */
+/**
+ * Ed25519 Key Pair
+ */
+export interface Ed25519KeyPair {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+}
+/**
+ * Exported Ed25519 Keys (hex strings)
+ */
+export interface ExportedEd25519Keys {
+    publicKeyHex: string;
+    privateKeyHex: string;
+    address: string;
+}
+/**
+ * Generate a new Ed25519 key pair for signing
+ *
+ * Uses native Web Crypto API - no external dependencies required.
+ *
+ * @returns Promise resolving to a CryptoKey pair
+ *
+ * @remarks
+ * This is a zero-dependency function that works in both Node.js and browsers.
+ * The generated key pair can be exported as hex strings using {@link exportEd25519Keys}.
+ *
+ * @example
+ * ```ts
+ * const keyPair = await generateEd25519KeyPair();
+ * const exported = await exportEd25519Keys(keyPair);
+ * console.log('Address:', exported.address);
+ * ```
+ */
+export declare function generateEd25519KeyPair(): Promise<Ed25519KeyPair>;
+/**
+ * Export Ed25519 keys as hex strings
+ *
+ * @param keyPair - The Ed25519 key pair (JWK format)
+ * @returns Exported keys with public key, private key, and derived address
+ *
+ * @remarks
+ * Keys are exported in standard formats:
+ * - Public key: SubjectPublicKeyInfo (SPKI) format as hex
+ * - Private key: PKCS8 format as hex
+ * - Address: Derived from the raw public key bytes (last 32 bytes of SPKI key)
+ *
+ * @example
+ * ```ts
+ * const keyPair = await generateEd25519KeyPair();
+ * const { publicKeyHex, privateKeyHex, address } = await exportEd25519Keys(keyPair);
+ * ```
+ */
+export declare function exportEd25519Keys(keyPair: Ed25519KeyPair): Promise<ExportedEd25519Keys>;
+/**
+ * Import Ed25519 keys from hex strings
+ *
+ * @param publicKeyHex - Public key in hex format (SPKI)
+ * @param privateKeyHex - Private key in hex format (PKCS8)
+ * @returns Imported CryptoKey pair
+ *
+ * @remarks
+ * Keys must be in standard formats:
+ * - Public key: SubjectPublicKeyInfo (SPKI) format as hex
+ * - Private key: PKCS8 format as hex
+ *
+ * Use this to restore keys previously exported with {@link exportEd25519Keys}.
+ *
+ * @example
+ * ```ts
+ * const keyPair = await importEd25519Keys(publicKeyHex, privateKeyHex);
+ * ```
+ */
+export declare function importEd25519Keys(publicKeyHex: string, privateKeyHex: string): Promise<Ed25519KeyPair>;
+/**
+ * Sign data using Ed25519 private key
+ *
+ * @param data - The data/message to sign or verify (hex string for EIP standards, plaintext for EIP-191)
+ * @param privateKey - The Ed25519 key pair (JWK format)
+ * @returns Hex-encoded signature
+ *
+ * @remarks
+ * This function:
+ * - UTF-8 encodes the input data
+ * - Signs using the Ed25519 algorithm
+ * - Returns the signature as a hex string
+ *
+ * @example
+ * ```ts
+ * const signature = await signEd25519("Hello, world!", keyPair.privateKey);
+ * ```
+ */
+export declare function signEd25519(data: string, privateKey: CryptoKey): Promise<string>;
+/**
+ * Verify an Ed25519 signature
+ *
+ * @param data - The data/message to sign or verify (hex string for EIP standards, plaintext for EIP-191)
+ * @param signatureHex - The cryptographic signature (0x-prefixed hex string)
+ * @param publicKey - The Ed25519 key pair (JWK format)
+ * @returns True if signature is valid
+ *
+ * @remarks
+ * This function:
+ * - UTF-8 encodes the input data
+ * - Verifies the hex-encoded signature using the Ed25519 algorithm
+ * - Returns true only if the signature is cryptographically valid
+ *
+ * @example
+ * ```ts
+ * const isValid = await verifyEd25519("Hello, world!", signature, keyPair.publicKey);
+ * ```
+ */
+export declare function verifyEd25519(data: string, signatureHex: string, publicKey: CryptoKey): Promise<boolean>;