@entros/pulse-sdk 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,665 @@
+declare const FINGERPRINT_BITS = 256;
+declare const DEFAULT_THRESHOLD = 96;
+declare const DEFAULT_MIN_DISTANCE = 3;
+declare const MIN_CAPTURE_MS = 2000;
+declare const MAX_CAPTURE_MS = 60000;
+declare const DEFAULT_CAPTURE_MS = 7000;
+declare const PROGRAM_IDS: {
+    readonly entrosAnchor: "GZYwTp2ozeuRA5Gof9vs4ya961aANcJBdUzB7LN6q4b2";
+    readonly entrosVerifier: "4F97jNoxQzT2qRbkWpW3ztC3Nz2TtKj3rnKG8ExgnrfV";
+    readonly entrosRegistry: "6VBs3zr9KrfFPGd6j7aGBPQWwZa5tajVfA7HN6MMV9VW";
+};
+interface PulseConfig {
+    cluster: "devnet" | "mainnet-beta" | "localnet";
+    rpcEndpoint?: string;
+    relayerUrl?: string;
+    relayerApiKey?: string;
+    zkeyUrl?: string;
+    wasmUrl?: string;
+    threshold?: number;
+    /** Enable console logging for diagnostics. Default: false. */
+    debug?: boolean;
+}
+
+/** Raw audio samples captured during the Pulse challenge */
+interface AudioCapture {
+    samples: Float32Array;
+    sampleRate: number;
+    duration: number;
+}
+/** Single IMU reading */
+interface MotionSample {
+    timestamp: number;
+    ax: number;
+    ay: number;
+    az: number;
+    gx: number;
+    gy: number;
+    gz: number;
+}
+/** Single touch reading */
+interface TouchSample {
+    timestamp: number;
+    x: number;
+    y: number;
+    pressure: number;
+    width: number;
+    height: number;
+}
+/** Options for event-driven sensor capture */
+interface CaptureOptions {
+    /** AbortSignal to stop capture. If omitted, captures for maxDurationMs. */
+    signal?: AbortSignal;
+    /** Minimum capture duration in ms. Capture continues until this even if signal fires early. Default: 2000 */
+    minDurationMs?: number;
+    /** Maximum capture duration in ms. Auto-stops if signal hasn't fired. Default: 60000 */
+    maxDurationMs?: number;
+    /** Called with RMS audio level (0-1) on each buffer during audio capture (~4x per second). */
+    onAudioLevel?: (rms: number) => void;
+    /** Pre-acquired MediaStream. If provided, captureAudio skips getUserMedia. */
+    stream?: MediaStream;
+    /** If true, captureMotion skips requestMotionPermission (already acquired). */
+    permissionGranted?: boolean;
+}
+/** Stage of a capture session */
+type CaptureStage = "audio" | "motion" | "touch";
+/** State of an individual capture stage */
+type StageState = "idle" | "capturing" | "captured" | "skipped";
+/** Combined sensor data from a Pulse capture session */
+interface SensorData {
+    audio: AudioCapture | null;
+    motion: MotionSample[];
+    touch: TouchSample[];
+    modalities: {
+        audio: boolean;
+        motion: boolean;
+        touch: boolean;
+    };
+}
+
+/** Result of a verification submission */
+interface SubmissionResult {
+    success: boolean;
+    txSignature?: string;
+    attestationTx?: string;
+    error?: string;
+}
+/** Result of a full Pulse verification */
+interface VerificationResult {
+    success: boolean;
+    commitment: Uint8Array;
+    txSignature?: string;
+    attestationTx?: string;
+    isFirstVerification: boolean;
+    error?: string;
+}
+
+type ResolvedConfig = Required<Pick<PulseConfig, "cluster" | "threshold">> & PulseConfig;
+/**
+ * PulseSession — event-driven staged capture session.
+ *
+ * Gives the caller control over when each sensor stage starts and stops.
+ * After all stages complete, call complete() to run the processing pipeline.
+ *
+ * Usage:
+ *   const session = pulse.createSession(touchElement);
+ *   await session.startAudio();
+ *   // ... user speaks ...
+ *   await session.stopAudio();
+ *   await session.startMotion();
+ *   // ... user holds device ...
+ *   await session.stopMotion();
+ *   await session.startTouch();
+ *   // ... user traces curve ...
+ *   await session.stopTouch();
+ *   const result = await session.complete(wallet, connection);
+ */
+declare class PulseSession {
+    private config;
+    private touchElement;
+    private audioStageState;
+    private motionStageState;
+    private touchStageState;
+    private audioController;
+    private motionController;
+    private touchController;
+    private audioPromise;
+    private motionPromise;
+    private touchPromise;
+    private audioData;
+    private motionData;
+    private touchData;
+    constructor(config: ResolvedConfig, touchElement?: HTMLElement);
+    startAudio(onAudioLevel?: (rms: number) => void): Promise<void>;
+    stopAudio(): Promise<AudioCapture | null>;
+    startMotion(): Promise<void>;
+    stopMotion(): Promise<MotionSample[]>;
+    skipMotion(): void;
+    isMotionCapturing(): boolean;
+    startTouch(): Promise<void>;
+    stopTouch(): Promise<TouchSample[]>;
+    skipTouch(): void;
+    complete(wallet?: any, connection?: any, onProgress?: (stage: string) => void): Promise<VerificationResult>;
+    /**
+     * Complete the session as a baseline RESET instead of a normal verify.
+     *
+     * Use when the wallet has an on-chain IdentityState but the device has
+     * no recoverable local baseline (cleared site data, new device, etc).
+     * Skips the Hamming ZK proof; submits `reset_identity_state` on chain,
+     * which rotates the commitment and zeros verification history.
+     *
+     * Requires a connected wallet + Solana connection. Rejects if either
+     * is missing — reset is a wallet-mode-only operation since it writes
+     * to the user's on-chain account.
+     */
+    completeReset(wallet: any, connection: any, onProgress?: (stage: string) => void): Promise<VerificationResult>;
+}
+/**
+ * PulseSDK — main entry point for Entros Protocol verification.
+ *
+ * Two usage modes:
+ *   1. Simple (backward-compatible): pulse.verify(touchElement) — captures all sensors
+ *      for DEFAULT_CAPTURE_MS in parallel, then processes.
+ *   2. Staged (event-driven): pulse.createSession(touchElement) — caller controls
+ *      when each sensor stage starts and stops.
+ */
+declare class PulseSDK {
+    private config;
+    constructor(config: PulseConfig);
+    /**
+     * Create a staged capture session for event-driven control.
+     */
+    createSession(touchElement?: HTMLElement): PulseSession;
+    /**
+     * Run a full verification with automatic timed capture (backward-compatible).
+     * Captures all sensors in parallel for DEFAULT_CAPTURE_MS, then processes.
+     */
+    verify(touchElement?: HTMLElement, wallet?: any, connection?: any): Promise<VerificationResult>;
+    /**
+     * Reset the wallet's on-chain baseline using a fresh capture.
+     *
+     * Convenience wrapper that mirrors `verify()` but routes the captured
+     * sensor data through `reset_identity_state` instead of `update_anchor`.
+     * Use when the wallet has an on-chain IdentityState but the local
+     * encrypted baseline is unrecoverable.
+     *
+     * For fine-grained control, call `createSession()` and `completeReset()`
+     * directly — the session API exposes per-stage start/stop hooks that
+     * this convenience wrapper trades away for simplicity.
+     */
+    resetBaseline(touchElement: HTMLElement | undefined, wallet: any, connection: any, onProgress?: (stage: string) => void): Promise<VerificationResult>;
+}
+
+/** 256-bit Temporal Fingerprint as an array of 0/1 values */
+type TemporalFingerprint = number[];
+/** Temporal-Biometric Hash: commitment + data needed for re-verification */
+interface TBH {
+    fingerprint: TemporalFingerprint;
+    salt: bigint;
+    commitment: bigint;
+    commitmentBytes: Uint8Array;
+}
+/** Packed field elements from bit packing (2 × 128-bit) */
+interface PackedFingerprint {
+    lo: bigint;
+    hi: bigint;
+}
+
+declare function simhash(features: number[]): TemporalFingerprint;
+/**
+ * Compute Hamming distance between two fingerprints.
+ */
+declare function hammingDistance(a: TemporalFingerprint, b: TemporalFingerprint): number;
+
+/**
+ * Pack 256-bit fingerprint into two 128-bit field elements.
+ * Little-endian bit ordering within each chunk (matches circuit's Bits2Num).
+ */
+declare function packBits(fingerprint: TemporalFingerprint): PackedFingerprint;
+/**
+ * Compute Poseidon commitment: Poseidon(pack_lo, pack_hi, salt).
+ * Matches the circuit's CommitmentCheck template exactly.
+ */
+declare function computeCommitment(fingerprint: TemporalFingerprint, salt: bigint): Promise<bigint>;
+/**
+ * Generate a random salt within the BN254 scalar field.
+ */
+declare function generateSalt(): bigint;
+/**
+ * Convert a BigInt to a 32-byte big-endian Uint8Array.
+ */
+declare function bigintToBytes32(n: bigint): Uint8Array;
+/**
+ * Generate a complete TBH from a fingerprint.
+ */
+declare function generateTBH(fingerprint: TemporalFingerprint, salt?: bigint): Promise<TBH>;
+
+/** Statistical summary of a time series */
+interface StatsSummary {
+    mean: number;
+    variance: number;
+    skewness: number;
+    kurtosis: number;
+}
+/** Feature vector from all sensor modalities */
+interface FeatureVector {
+    audio: number[];
+    motion: number[];
+    touch: number[];
+}
+/** Concatenated feature vector for SimHash input */
+type FusedFeatureVector = number[];
+
+declare function mean(values: number[]): number;
+declare function variance(values: number[], mu?: number): number;
+declare function skewness(values: number[]): number;
+declare function kurtosis(values: number[]): number;
+declare function condense(values: number[]): StatsSummary;
+/**
+ * Shannon entropy over histogram bins. Measures information density.
+ * Real human data has moderate entropy (varied but structured).
+ * Synthetic data is either too uniform (high entropy) or too structured (low entropy).
+ */
+declare function entropy(values: number[], bins?: number): number;
+/**
+ * Autocorrelation at a given lag. Detects periodic synthetic patterns.
+ * Real human data has low autocorrelation at most lags (chaotic/noisy).
+ * Synthetic data often has high autocorrelation (periodic/smooth).
+ */
+declare function autocorrelation(values: number[], lag?: number): number;
+/**
+ * Concatenate raw features without normalization.
+ * Used for server-side validation where physical units matter.
+ */
+declare function fuseRawFeatures(audio: number[], motion: number[], touch: number[]): number[];
+/**
+ * Normalize and concatenate features for SimHash computation.
+ */
+declare function fuseFeatures(audio: number[], motion: number[], touch: number[]): number[];
+
+/**
+ * Speaker-dependent audio feature extraction.
+ *
+ * Extracts features that characterize HOW someone speaks (prosody, vocal physiology)
+ * rather than WHAT they say (phonetic content). These features are stable across
+ * different utterances from the same speaker.
+ *
+ * Output: 44 values
+ *   F0 statistics (5) + F0 delta (4) + jitter (4) + shimmer (4) +
+ *   HNR statistics (5) + formant ratios (8) + LTAS (8) + voicing ratio (1) +
+ *   amplitude statistics (5)
+ */
+
+declare const SPEAKER_FEATURE_COUNT = 44;
+/**
+ * Extract speaker-dependent audio features.
+ *
+ * Captures physiological vocal characteristics (F0, jitter, shimmer, HNR, formant
+ * ratios) that are stable across different utterances from the same speaker.
+ * Content-independent by design — different phrases produce similar feature values.
+ *
+ * Returns 44 values.
+ */
+/**
+ * Extracts 44 speaker features AND the raw F0 contour.
+ * The F0 contour is surfaced so Tier 2 cross-modal temporal analysis can be
+ * performed server-side against the motion time-series. Feature vector shape
+ * and semantics are unchanged.
+ */
+declare function extractSpeakerFeaturesDetailed(audio: AudioCapture): Promise<{
+    features: number[];
+    f0Contour: number[];
+}>;
+/**
+ * Extracts 44 speaker features. Backward-compatible wrapper that discards
+ * the F0 contour; use `extractSpeakerFeaturesDetailed` when the contour is
+ * needed (e.g. for Tier 2 server-side cross-modal analysis).
+ */
+declare function extractSpeakerFeatures(audio: AudioCapture): Promise<number[]>;
+
+/**
+ * Compute per-sample acceleration magnitude |a| = √(ax² + ay² + az²) and
+ * linearly resample to a target frame count. Used for Tier 2 cross-modal
+ * temporal analysis against the F0 contour; the two time-series must share
+ * the same frame count for direct correlation.
+ *
+ * Returns an empty array if motion data is absent or too short.
+ */
+declare function extractAccelerationMagnitude(samples: MotionSample[], targetFrameCount: number): number[];
+/**
+ * Extract kinematic features from motion (IMU) data.
+ * Computes jerk (3rd derivative) and jounce (4th derivative) of acceleration,
+ * then condenses each axis into statistics.
+ *
+ * Returns: ~54 values (6 axes × 2 derivatives × 4 stats + 6 jitter variance values)
+ */
+declare function extractMotionFeatures(samples: MotionSample[]): number[];
+/**
+ * Extract kinematic features from touch data.
+ * Computes velocity and acceleration of touch coordinates,
+ * plus pressure and area statistics.
+ *
+ * Returns: ~36 values (32 base + 4 jitter variance for x, y, pressure, area)
+ */
+declare function extractTouchFeatures(samples: TouchSample[]): number[];
+/**
+ * Extract mouse dynamics features as a desktop replacement for motion sensor data.
+ * Captures behavioral patterns from mouse/pointer movement that are user-specific:
+ * path curvature, speed patterns, micro-corrections, pause behavior.
+ *
+ * Returns: 54 values (matches motion feature dimension for consistent SimHash input)
+ */
+declare function extractMouseDynamics(samples: TouchSample[]): number[];
+
+/** Serialized proof ready for on-chain submission */
+interface SolanaProof {
+    proofBytes: Uint8Array;
+    publicInputs: Uint8Array[];
+}
+/** Raw snarkjs proof output */
+interface RawProof {
+    pi_a: string[];
+    pi_b: string[][];
+    pi_c: string[];
+    protocol: string;
+    curve: string;
+}
+/** Circuit input for proof generation */
+interface CircuitInput {
+    ft_new: number[];
+    ft_prev: number[];
+    salt_new: string;
+    salt_prev: string;
+    commitment_new: string;
+    commitment_prev: string;
+    threshold: string;
+    min_distance: string;
+}
+/** Proof generation result */
+interface ProofResult {
+    proof: RawProof;
+    publicSignals: string[];
+}
+
+/**
+ * Convert a decimal string to a 32-byte big-endian Uint8Array.
+ */
+declare function toBigEndian32(decStr: string): Uint8Array;
+/**
+ * Serialize an snarkjs proof into the 256-byte format groth16-solana expects.
+ *
+ * proof_a: 64 bytes (x + negated y)
+ * proof_b: 128 bytes (G2 with reversed coordinate ordering: c1 before c0)
+ * proof_c: 64 bytes (x + y)
+ */
+declare function serializeProof(proof: RawProof, publicSignals: string[]): SolanaProof;
+
+/**
+ * Prepare circuit input from current and previous TBH data.
+ */
+declare function prepareCircuitInput(current: TBH, previous: TBH, threshold?: number, minDistance?: number): CircuitInput;
+/**
+ * Generate a Groth16 proof for the Hamming distance circuit.
+ *
+ * @param input - Circuit input (fingerprints, salts, commitments, threshold)
+ * @param wasmPath - Path or URL to iam_hamming.wasm
+ * @param zkeyPath - Path or URL to iam_hamming_final.zkey
+ */
+declare function generateProof(input: CircuitInput, wasmPath: string, zkeyPath: string): Promise<ProofResult>;
+/**
+ * Generate a proof and serialize it for Solana submission.
+ */
+declare function generateSolanaProof(current: TBH, previous: TBH, wasmPath: string, zkeyPath: string, threshold?: number): Promise<SolanaProof>;
+
+/**
+ * Submit a proof on-chain via a connected wallet (wallet-connected mode).
+ * Uses Anchor SDK to construct and send the transaction.
+ *
+ * Flow for re-verification: single batched transaction containing
+ *   ComputeBudget → create_challenge → verify_proof → update_anchor
+ * Flow for first verification: mint_anchor (already 1 transaction)
+ */
+declare function submitViaWallet(proof: SolanaProof, commitment: Uint8Array, options: {
+    wallet: any;
+    connection: any;
+    isFirstVerification: boolean;
+    relayerUrl?: string;
+    relayerApiKey?: string;
+}): Promise<SubmissionResult>;
+/**
+ * Submit a baseline reset on-chain via a connected wallet.
+ *
+ * Fires when the on-chain IdentityState exists for the wallet but the
+ * device's local encrypted fingerprint envelope is unrecoverable. The
+ * ZK Hamming proof used by `update_anchor` needs the previous
+ * fingerprint's bits as a private witness; without them, re-verification
+ * is blocked. `reset_identity_state` rotates `current_commitment`
+ * in place, zeroes verification_count / trust_score / recent_timestamps,
+ * and sets a 7-day cooldown before the next reset.
+ *
+ * Transaction shape: single instruction (no challenge / verify_proof /
+ * ZK proof required). Humanness evidence comes from the Tier 1
+ * validation pipeline invoked at the /attest step (same as mint and
+ * update).
+ */
+declare function submitResetViaWallet(commitment: Uint8Array, options: {
+    wallet: any;
+    connection: any;
+    relayerUrl?: string;
+    relayerApiKey?: string;
+}): Promise<SubmissionResult>;
+
+/**
+ * Submit a proof via the Entros relayer API (walletless mode).
+ * The relayer submits the on-chain transaction using the integrator's funded account.
+ * The user needs no wallet, no SOL, no crypto knowledge.
+ */
+declare function submitViaRelayer(proof: SolanaProof, commitment: Uint8Array, options: {
+    relayerUrl: string;
+    apiKey?: string;
+    isFirstVerification: boolean;
+}): Promise<SubmissionResult>;
+
+/** Decoded Entros attestation from the Solana Attestation Service */
+interface EntrosAttestation {
+    isHuman: boolean;
+    trustScore: number;
+    verifiedAt: number;
+    mode: string;
+    expired: boolean;
+}
+/**
+ * Check if a wallet has a valid Entros attestation via SAS.
+ *
+ * Derives the attestation PDA, fetches the account, deserializes
+ * the attestation data, and checks expiry.
+ *
+ * @param walletAddress - Base58 Solana wallet address
+ * @param connection - Solana web3.js Connection instance
+ * @returns Decoded attestation or null if none exists
+ */
+declare function verifyEntrosAttestation(walletAddress: string, connection: any): Promise<EntrosAttestation | null>;
+
+/** Metadata written to an AI agent linking it to a verified human operator */
+interface AgentHumanOperator {
+    anchorPda: string;
+    trustScore: number;
+    verifiedAt: number;
+    wallet: string;
+}
+/**
+ * Attest that a verified Entros human operates an AI agent on the Solana Agent Registry.
+ *
+ * Reads the user's on-chain IdentityState PDA, builds metadata JSON, and writes
+ * it to the agent's metadata via a manually constructed set_metadata_pda instruction.
+ * The metadata is immutable once set, permanently linking the agent to its human operator.
+ *
+ * The wallet must own both the Entros Anchor and the agent's Metaplex Core NFT.
+ *
+ * @param agentAsset - Base58 pubkey of the agent's Metaplex Core NFT
+ * @param options - Wallet adapter and Solana connection
+ * @returns Transaction signature on success
+ */
+declare function attestAgentOperator(agentAsset: string, options: {
+    wallet: any;
+    connection: any;
+    cluster?: PulseConfig["cluster"];
+}): Promise<{
+    success: boolean;
+    signature?: string;
+    error?: string;
+}>;
+/**
+ * Query whether an AI agent has a verified human operator via Entros.
+ *
+ * Reads the "iam:human-operator" metadata from the agent's on-chain record
+ * and returns the operator's Entros Anchor details.
+ *
+ * @param agentAsset - Base58 pubkey of the agent's Metaplex Core NFT
+ * @param connection - Solana connection (optional, defaults to devnet)
+ * @returns Operator metadata or null if no Entros attestation exists
+ */
+declare function getAgentHumanOperator(agentAsset: string, connection?: any, cluster?: PulseConfig["cluster"]): Promise<AgentHumanOperator | null>;
+
+/** On-chain identity state (mirrors the Anchor program's IdentityState) */
+interface IdentityState {
+    owner: string;
+    creationTimestamp: number;
+    lastVerificationTimestamp: number;
+    verificationCount: number;
+    trustScore: number;
+    currentCommitment: Uint8Array;
+    mint: string;
+    /**
+     * Unix timestamp of the most recent `reset_identity_state` call.
+     * Zero for accounts that have never been reset (freshly minted or
+     * minted before the reset feature was deployed).
+     */
+    lastResetTimestamp: number;
+}
+/** Local storage of previous verification data (needed for re-verification) */
+interface StoredVerificationData {
+    fingerprint: number[];
+    salt: string;
+    commitment: string;
+    timestamp: number;
+}
+
+/**
+ * Fetch identity state from the on-chain IdentityState PDA.
+ */
+declare function fetchIdentityState(walletPubkey: string, connection: any): Promise<IdentityState | null>;
+/**
+ * Store verification data locally for re-verification.
+ * Encrypts with AES-256-GCM when Web Crypto is available.
+ * Falls back to plaintext with a warning otherwise.
+ */
+declare function storeVerificationData(data: StoredVerificationData): Promise<void>;
+/**
+ * Load previously stored verification data.
+ * Decrypts if encrypted, migrates plaintext to encrypted on first load.
+ */
+declare function loadVerificationData(): Promise<StoredVerificationData | null>;
+
+/**
+ * Generate a random phonetically-balanced phrase for the voice challenge.
+ * Each phrase is 5-6 syllable pairs, forming nonsensical but speakable words.
+ * Uses crypto.getRandomValues for unpredictable challenge generation.
+ */
+declare function generatePhrase(wordCount?: number): string;
+/**
+ * Generate a sequence of phrases for dynamic mid-session switching.
+ * Each phrase uses a different syllable subset to prevent pre-computation.
+ */
+declare function generatePhraseSequence(count?: number, wordCount?: number): string[];
+
+/**
+ * Generate Lissajous curve points for the touch tracing challenge.
+ * The user traces this shape on screen while speaking the phrase.
+ *
+ * x(t) = A * sin(a*t + delta)
+ * y(t) = B * sin(b*t)
+ */
+interface LissajousParams {
+    a: number;
+    b: number;
+    delta: number;
+    points: number;
+}
+interface Point2D {
+    x: number;
+    y: number;
+}
+/**
+ * Generate random Lissajous parameters for a challenge.
+ */
+declare function randomLissajousParams(): LissajousParams;
+/**
+ * Generate Lissajous curve points normalized to [0, 1] range.
+ */
+declare function generateLissajousPoints(params: LissajousParams): Point2D[];
+/**
+ * Generate a sequence of Lissajous curves for dynamic mid-session switching.
+ * Each curve uses different parameters, preventing pre-computation.
+ */
+declare function generateLissajousSequence(count?: number): {
+    params: LissajousParams;
+    points: Point2D[];
+}[];
+
+/**
+ * Fetch the server-issued challenge from the executor.
+ *
+ * The executor's `/challenge` endpoint returns a fresh nonce + nonsense phrase
+ * bound to the wallet for a short TTL (default 60s). The phrase is shown to
+ * the user as the voice challenge and is looked up server-side at
+ * `/validate-features` to run phoneme-distance matching against the submitted
+ * audio (master-list #89, phrase content binding via STT).
+ *
+ * Server-issued phrases are the only safe design for content binding: if the
+ * client generated the phrase and sent it to the server alongside the audio,
+ * an attacker would submit their own phrase matching whatever content they
+ * captured. With server issuance, the phrase is bound to the nonce and the
+ * client cannot substitute it.
+ */
+/**
+ * Server-issued challenge artifacts. Returned by `fetchChallenge`.
+ */
+interface ChallengeResponse {
+    /** 32-byte nonce used for on-chain `create_challenge` and the `/attest` handshake. */
+    nonce: Uint8Array;
+    /** Nonsense phrase (5 space-separated words of 2-3 syllables each) the user must speak aloud. */
+    phrase: string;
+    /** Nonce TTL in seconds (default 60). */
+    expiresIn: number;
+}
+/**
+ * Fetch a fresh nonce + phrase from the executor. Throws on network error or
+ * non-2xx response so the caller can surface a retry UX.
+ *
+ * @param executorUrl - Base URL of the executor (e.g. `https://executor.entros.io`).
+ * @param walletAddress - Base58-encoded wallet public key.
+ * @param apiKey - Optional executor API key (`X-API-Key` header).
+ */
+declare function fetchChallenge(executorUrl: string, walletAddress: string, apiKey?: string): Promise<ChallengeResponse>;
+
+/**
+ * Encode captured Float32 audio samples as base64 int16 PCM for transmission
+ * to the validation service (master-list #89 phrase content binding).
+ *
+ * Audio is captured as `Float32Array` with values in `[-1.0, 1.0]` by the
+ * Pulse SDK (`sensor/audio.ts`). The validation service's phrase-binding
+ * module decodes base64 → Vec<i16> → Vec<f32> before feeding Whisper-tiny.
+ * int16 is the standard compact representation: 2 bytes per sample vs 4 for
+ * f32, halving wire size without perceptible quality loss for 16kHz speech.
+ *
+ * Byte layout: little-endian int16 samples, contiguous, no header.
+ */
+/**
+ * Convert Float32 PCM samples to base64-encoded 16-bit little-endian PCM.
+ * Samples are clamped to [-1, 1] and scaled. Uses `btoa`, a DOM global
+ * available in browser runtimes and in Node 16+.
+ */
+declare function encodeAudioAsBase64(samples: Float32Array): string;
+
+export { type AgentHumanOperator, type AudioCapture, type CaptureOptions, type CaptureStage, type ChallengeResponse, type CircuitInput, DEFAULT_CAPTURE_MS, DEFAULT_MIN_DISTANCE, DEFAULT_THRESHOLD, type EntrosAttestation, FINGERPRINT_BITS, type FeatureVector, type FusedFeatureVector, type IdentityState, type LissajousParams, MAX_CAPTURE_MS, MIN_CAPTURE_MS, type MotionSample, PROGRAM_IDS, type PackedFingerprint, type Point2D, type ProofResult, type PulseConfig, PulseSDK, PulseSession, SPEAKER_FEATURE_COUNT, type SensorData, type SolanaProof, type StageState, type StatsSummary, type StoredVerificationData, type SubmissionResult, type TBH, type TemporalFingerprint, type TouchSample, type VerificationResult, attestAgentOperator, autocorrelation, bigintToBytes32, computeCommitment, condense, encodeAudioAsBase64, entropy, extractAccelerationMagnitude, extractMotionFeatures, extractMouseDynamics, extractSpeakerFeatures, extractSpeakerFeaturesDetailed, extractTouchFeatures, fetchChallenge, fetchIdentityState, fuseFeatures, fuseRawFeatures, generateLissajousPoints, generateLissajousSequence, generatePhrase, generatePhraseSequence, generateProof, generateSalt, generateSolanaProof, generateTBH, getAgentHumanOperator, hammingDistance, kurtosis, loadVerificationData, mean, packBits, prepareCircuitInput, randomLissajousParams, serializeProof, simhash, skewness, storeVerificationData, submitResetViaWallet, submitViaRelayer, submitViaWallet, toBigEndian32, variance, verifyEntrosAttestation };