export { d as CAVOS_PAYMASTER_URL, e as Cavos, f as CavosStarknet, a as CavosWallet, C as Chain, c as ConnectOptions, g as ConnectStarknetOptions, h as ConnectStatus, N as NetworkEnv, O as OZ_ACCOUNT_CLASS_HASH, S as STARKNET_NETWORKS, i as StarknetNetwork } from './Cavos-ZrpmxLDl.js';
import { A as AuthProvider, f as AttestationPolicy, I as Identity, S as SocialRecoveryCredential, W as WalletRegistry, R as RegisteredWallet, i as DevicePublicKey, j as RegisterResult, d as PasskeyPrfProvider, h as PasskeyEnrollParams } from './VaultClient-CkzLCyXH.js';
export { k as InMemoryWalletRegistry, l as PasskeyPrfEnrollResult, P as PrivacyOperations, m as PrivacyRequirement, n as PrivacyStatus, o as PrivacySubmission, C as SocialChainAuthorization, p as SocialProviderPolicy, q as SocialRecoveryAction, a as SocialRecoveryClient, r as SocialRecoveryClientOptions, s as SocialRecoveryProvider, t as SocialRecoveryResult, u as StaticIdentity, V as VaultClient, v as createSocialRecoveryCredential } from './VaultClient-CkzLCyXH.js';
import { E as ExecuteOptions } from './signing-BC_pkVbS.js';
export { d as CAVOS_MESSAGE_PREFIX, C as ChainCall, F as FeeMode, M as MessageSignature, e as SignatureCurve, f as SignedTransaction, b as SolanaExecuteOptions, g as SolanaFeeMode, c as SolanaSignedTransaction, S as StarknetSignedTransaction, a as StellarSignedTransaction, p as prefixedMessageBytes } from './signing-BC_pkVbS.js';
export { P as PrivacyFeeMode, b as PrivacyRelayConfig, a as StarknetPrivacyConfig, p as parseStarknetPrivacyConfig } from './nativeConnect-DPJqSwJj.js';
export { starkKeyFromSeed, starkPublicKey, starknetAddressFromPublicKey, starknetAddressFromSeed } from './starknet.js';
export { C as CavosSolana, a as ConnectSolanaOptions, I as InstructionAccount, b as InstructionData, R as RecoverSolanaOptions, S as SOLANA_NETWORKS, c as SolanaNetwork, d as SolanaRelayer, e as SolanaRelayerOptions } from './CavosSolana-DoecLt3K.js';
import { C as CavosStellar } from './CavosStellar-DALNyR2D.js';
export { a as ConnectStellarOptions, H as HORIZON_URL, b as SOROBAN_RPC_URL, c as STELLAR_NETWORKS, d as StellarConnectStatus, e as StellarNetwork, f as StellarRelayKind, S as StellarRelayer, g as StellarRelayerOptions, X as XLM_DECIMALS } from './CavosStellar-DALNyR2D.js';
import { xdr, Keypair } from '@stellar/stellar-sdk';
import { S as StellarAdapter } from './stellar-CiR1FdaS.js';
export { A as AccountEnvelope, a as StellarAdapterOptions, f as fromDataEntries, t as toDataEntries } from './stellar-CiR1FdaS.js';
import { D as DeviceUnwrapKey } from './DeviceUnwrapKey-Ct-JUQrB.js';
export { L as LocalDeviceUnwrapKey, d as deviceSlotId } from './DeviceUnwrapKey-Ct-JUQrB.js';
import 'starknet';
import '@starkware-libs/starknet-privacy-sdk';
import '@solana/web3.js';

interface CavosAuthOptions {
    /** Cavos backend base URL. Defaults to the hosted service (same as @cavos/react). */
    backendUrl?: string;
    /** App identifier registered with Cavos (the `appId` from the dashboard). */
    appId?: string;
    /**
     * `false` keeps the signed-in identity in `sessionStorage`: it survives a
     * reload and the OAuth redirect, and ends when the tab closes. Any identity
     * already in `localStorage` is removed. Defaults to `true` (`localStorage`,
     * signed in across tabs and restarts).
     */
    persistSession?: boolean;
    /**
     * The enclave measurements email login verifies before it sends a code to
     * the enclave. Defaults to the enclave shipped with this package.
     */
    attestation?: AttestationPolicy;
}
/**
 * Hosted login (Privy-like) backed by the Cavos backend — same endpoints
 * `@cavos/react` uses for Google / Apple OAuth, plus an email code the recovery
 * enclave generates and verifies itself. Login only
 * resolves a stable `userId` (the OAuth `sub` claim); it never touches signing.
 * Feed the returned `Identity` to `Cavos.connect`.
 *
 *   const auth = new CavosAuth({ appId });
 *   // social: open the returned URL; user returns, then:
 *   const identity = await auth.handleCallback(window.location.search);
 *   // or email OTP:
 *   await auth.sendOtp(email); const identity = await auth.verifyOtp(email, code);
 *   const cavos = await Cavos.connect({ network, appSalt, identity, paymasterApiKey });
 *
 * Device-signer model note: the backend issues a Cavos JWT (the same one react
 * uses for on-chain RSA verification). Here we only need the stable `sub` claim
 * from it — the RSA/JWKS/nonce machinery react relies on is dead weight for the
 * device model, because the device key (not the JWT) authorizes on-chain calls.
 * The provider token is kept in `sessionStorage` so a reconnect can still
 * authenticate to the wallet registry. The separate social-recovery credential
 * is NOT: it stays in memory, its SHA-256 fingerprint reserves exactly one
 * enclave session, and the token itself travels only through the attested
 * encrypted channel.
 */
declare class CavosAuth implements AuthProvider {
    private readonly opts;
    private readonly backendUrl;
    private readonly identityStorageKey;
    private readonly authTokenKey;
    private readonly loginSecretKey;
    /** The login secret, for a callback this same instance handles. */
    private loginSecret;
    private last;
    /** Fresh OIDC proof retained only in memory for an immediate TEE recovery.
     * Never persisted to localStorage and never sent to the Cavos control plane
     * outside the attested encrypted channel. */
    private recoveryCredential;
    /**
     * The raw provider token from this session's login.
     *
     * Held in `sessionStorage`, not memory alone. The wallet registry
     * authenticates with it, and `resolveAddress` fails closed rather than mint a
     * second wallet for a user who already has one — so a token that does not
     * survive a reload takes every reconnect down with it, and a device with no
     * cached address can never connect at all.
     *
     * `sessionStorage` and not `localStorage`: it dies with the tab, is not shared
     * across tabs, and never reaches another origin. The token is already inside
     * this page's JavaScript either way; what changes is that it now outlives a
     * navigation, which is exactly what the reconnect needs.
     */
    private authTokenValue;
    constructor(opts?: CavosAuthOptions);
    /**
     * Where the identity lives. Resolved on use, not in the constructor, because
     * the provider also builds this during SSR, where there is no `window`.
     */
    private identityStorage;
    /**
     * Restore the last confirmed identity for this app on this browser. This is
     * deliberately only public profile data — never an OAuth token or private
     * key. The device signer remains protected in IndexedDB/WebCrypto.
     */
    restoreIdentity(): Identity | null;
    /** Clear the persisted identity on an explicit user logout. */
    clearStoredIdentity(): void;
    /** Redirect URL for Google login (open it; user returns to your redirectUri). */
    getGoogleOAuthUrl(redirectUri?: string): Promise<string>;
    /** Redirect URL for Apple login. */
    getAppleOAuthUrl(redirectUri?: string): Promise<string>;
    private oauthUrl;
    /**
     * Resolve identity from an OAuth callback. Current callbacks carry only a
     * short-lived one-time code; legacy raw auth data remains readable so apps can
     * roll forward without losing an already-open callback.
     */
    handleCallback(authDataOrSearch: string, redirectUri?: string): Promise<Identity>;
    /**
     * Email a 9-character sign-in code. The code is generated and mailed by the
     * recovery enclave, so the Cavos control plane never sees it.
     */
    sendOtp(email: string): Promise<void>;
    /**
     * Verify the emailed code inside the attested enclave and resolve the
     * identity. The enclave answers with its own signed token, bound to a secret
     * created here, and that token is used exactly like a Google id_token.
     */
    verifyOtp(email: string, code: string): Promise<Identity>;
    /** AuthProvider: returns the identity resolved by the last login step. */
    authenticate(): Promise<Identity>;
    /**
     * Return the fresh social credential the recovery enclave requires.
     * Callers should use it immediately; it is intentionally not restorable
     * after a refresh. A new social login is required for each recovery attempt.
     */
    getSocialRecoveryCredential(): SocialRecoveryCredential;
    /**
     * Take the fresh social credential exactly once. A provider token is bound to
     * one enclave session, so retaining it after recovery only permits accidental
     * replay attempts during the wallet's post-recovery reconnect.
     */
    /**
     * Whether a login proof is available without taking it.
     *
     * The UI has to choose how a device gets authorized before anything runs, and
     * that choice depends on whether the enclave can be used at all. Asking with
     * `consume` would spend the proof to find out.
     */
    hasSocialRecoveryCredential(): boolean;
    consumeSocialRecoveryCredential(): SocialRecoveryCredential;
    /**
     * Accept a provider id_token obtained by the host's own authentication.
     *
     * Apps that sign users in themselves already hold a Google or Apple token;
     * this lets social recovery use it instead of sending the user through a
     * second sign-in. Nothing here grants trust: the token is checked inside the
     * enclave against the issuer and audience sealed for the app, and only Google
     * or Apple can produce a token that passes.
     *
     * Rejected up front if it was not issued by a provider the enclave accepts,
     * so a mistake surfaces here rather than as an opaque enclave failure.
     *
     * The token must be recent — the enclave requires the authentication to be
     * within five minutes — so pass one straight from a sign-in, not a stored one.
     */
    useExternalSocialRecoveryToken(idToken: string): void;
    /**
     * Build an `Identity` from whatever the backend returned. The Cavos backend
     * wraps the user id in a JWT (its `sub` claim); for the device model we only
     * need that stable id — the signature is never checked on-chain.
     */
    private identityFromAuthData;
    /**
     * The provider id_token from this session's login, for the wallet registry.
     * Null on a page reload that restored the identity from storage but not
     * the token — the address cache covers that device; a brand-new device has
     * just logged in and therefore has one.
     */
    getAuthToken(): string | null;
    private setAuthToken;
    /**
     * Begin a Google or Apple login: keep a fresh secret for the trip to the
     * provider and back, and return the nonce that commits to it.
     *
     * `sessionStorage` because the login navigates away and the secret has to be
     * here when the callback lands; it is removed as soon as it is read. Where
     * storage is unavailable only this instance remembers it, so a login that
     * reloads the page is refused at the callback — the safe outcome.
     */
    private startLogin;
    /** The secret of the login in flight, taken exactly once. */
    private takeLoginSecret;
    private remember;
    private get;
    private requireAppId;
    private emailPost;
    private post;
}

interface HttpWalletRegistryOptions {
    /** Cavos backend base URL (e.g. https://cavos.xyz). */
    baseUrl: string;
    /** The Cavos App ID — authenticates the SDK calls (verifyAppId). */
    appId: string;
    /** Optional Cavos console environment. Omitted means production. */
    environment?: "development" | "production";
    /** Network the wallet lives on (e.g. "sepolia"). */
    network: string;
    /**
     * The provider id_token from login (Google / Apple / Cavos). The registry
     * decides who owns an address, so it authenticates the end user, not just the
     * public app id. Read fresh on each call; these tokens expire.
     */
    authToken: () => string | null;
}
/**
 * WalletRegistry backed by the Cavos backend (`/api/wallets`) — the persistent,
 * cross-device source of truth for `user_id -> wallet`. The backend stores
 * authorized device signers in `wallet_devices`; the registry maps a backend
 * `userId` (the OAuth `sub`) onto that single wallet row.
 */
declare class HttpWalletRegistry implements WalletRegistry {
    private readonly opts;
    constructor(opts: HttpWalletRegistryOptions);
    lookup(userId: string): Promise<RegisteredWallet | null>;
    register(params: {
        userId: string;
        address: string;
        initialSigner: DevicePublicKey;
    }): Promise<RegisterResult>;
    private headers;
    addDevice?(params: {
        userId: string;
        address: string;
        signer: DevicePublicKey;
    }): Promise<void>;
    removeDevice?(params: {
        userId: string;
        address: string;
        signer: DevicePublicKey;
    }): Promise<void>;
}

/**
 * Generate a fresh, human-readable recovery code. The caller MUST present this
 * to the user exactly once and never persist it server-side. ~128 bits of
 * entropy encoded as words from a fixed wordlist (BIP39-style but our own list,
 * so we don't pull a dependency on a BIP39 wordfile).
 */
declare function generateRecoveryCode(): string;

/**
 * The Nitro enclave image Cavos runs for hardware-isolated recovery.
 *
 * These values answer one question: *which enclave am I willing to talk to?*
 * They ship here, in a versioned package you install and can audit, rather than
 * arriving from the recovery API — an API that told the client which
 * measurement to trust could simply name its own, and the attestation would
 * prove nothing. The attestation itself is signed by AWS, so authenticity is
 * already anchored outside Cavos; this policy only fixes the workload's
 * identity.
 *
 * `pcr0` is the SHA-384 measurement of the enclave image file, as reported by
 * `nitro-cli build-enclave`. It accepts a list so a rollout can overlap:
 * publish the new measurement alongside the one still deployed, ship the
 * release, then redeploy. Apps on either version keep working through the
 * transition. Order is newest first.
 *
 * Override via `socialRecoveryAttestation` when you run your own enclave.
 */
declare const DEFAULT_SOCIAL_RECOVERY_ATTESTATION: AttestationPolicy;

/**
 * Turnkey wrapper over `CavosStellar.invokeContract` for Trustless Work's
 * single-release milestone escrow (Soroban). Each method maps 1:1 to a contract
 * entrypoint and passes THIS Cavos account's `G…` as the role argument that the
 * contract `require_auth`s — so the account's control key signs the matching
 * Soroban auth entry. See the escrow contract reference for the lifecycle.
 *
 * Gasless by default (the relayer fee-bumps); pass `{ sponsored: false }` to have
 * the account pay its own fee.
 *
 *   const escrow = new TrustlessWorkEscrow(wallet, contractId);
 *   await escrow.approveMilestone(0);   // wallet acts as `approver`
 *   await escrow.releaseFunds(TW_ADDR); // wallet acts as `release_signer`
 */
declare class TrustlessWorkEscrow {
    private readonly wallet;
    private readonly contractId;
    constructor(wallet: CavosStellar, contractId: string);
    /** This account's `G…` as a Soroban address ScVal — the role argument. */
    private self;
    private addr;
    /** `approve_milestone(milestone_index, approver=self)` — the client approves. */
    approveMilestone(milestoneIndex: number, opts?: ExecuteOptions): Promise<string>;
    /** `change_milestone_status(index, new_status, new_evidence?, service_provider=self)`. */
    changeMilestoneStatus(milestoneIndex: number, newStatus: string, newEvidence?: string, opts?: ExecuteOptions): Promise<string>;
    /** `release_funds(release_signer=self, trustless_work_address)`. */
    releaseFunds(trustlessWorkAddress: string, opts?: ExecuteOptions): Promise<string>;
    /** `dispute_escrow(signer=self)` — any role (except resolver) can dispute. */
    disputeEscrow(opts?: ExecuteOptions): Promise<string>;
    /**
     * `fund_escrow(signer=self, expected_escrow, amount)`. `expected_escrow` must be
     * the current on-chain `Escrow` struct as an ScVal — read it via `getEscrow()`
     * and pass the raw simulated value, or build it with `nativeToScVal`.
     */
    fundEscrow(expectedEscrow: xdr.ScVal, amount: bigint, opts?: ExecuteOptions): Promise<string>;
    /**
     * `resolve_dispute(dispute_resolver=self, trustless_work_address, distributions)`.
     * `distributions` is a `Map<Address, i128>` — pass as `{ [gAddress]: amount }`.
     */
    resolveDispute(trustlessWorkAddress: string, distributions: Record<string, bigint>, opts?: ExecuteOptions): Promise<string>;
    /** Read the current on-chain escrow state (roles, milestones, flags, amount).
     *  Read-only simulation — needs an adapter but no signing. */
    getEscrow(adapter: StellarAdapter): Promise<EscrowState>;
}
interface MilestoneInput {
    description: string;
    status?: string;
    evidence?: string;
    approved?: boolean;
}
interface EscrowInput {
    engagementId: string;
    title: string;
    description: string;
    /** Total amount in the trustline token's base units (7-dp for USDC/XLM). */
    amount: bigint;
    /** Platform fee in basis points (e.g. 100 = 1%). */
    platformFeeBps: number;
    roles: {
        approver: string;
        serviceProvider: string;
        platform: string;
        releaseSigner: string;
        disputeResolver: string;
        receiver: string;
    };
    milestones: MilestoneInput[];
    /** Trustline token contract (SAC) address — e.g. USDC's `C…`. */
    trustline: string;
    receiverMemo?: number;
}
/** Decoded `get_escrow` result (native JS shape from `scValToNative`). */
interface EscrowState {
    engagement_id: string;
    title: string;
    description: string;
    amount: bigint;
    platform_fee: number;
    roles: Record<string, string>;
    milestones: {
        description: string;
        status: string;
        evidence: string;
        approved: boolean;
    }[];
    flags: {
        disputed: boolean;
        released: boolean;
        resolved: boolean;
    };
    trustline: {
        address: string;
    };
    receiver_memo: number;
}
/** Encode an `EscrowInput` as the Soroban `Escrow` struct ScVal. */
declare function buildEscrowScVal(input: EscrowInput): xdr.ScVal;
/**
 * Deploy + initialize a fresh escrow instance through a Trustless Work factory
 * contract (`tw_new_single_release_escrow`), signed by a Cavos account. Returns
 * the deployed escrow contract address. This is TW's production pattern: one
 * factory spawns an independent escrow per engagement.
 */
declare function deployEscrow(wallet: CavosStellar, params: {
    factoryId: string;
    wasmHash: string;
    adapter: StellarAdapter;
    escrow: EscrowInput;
    opts?: ExecuteOptions;
}): Promise<{
    escrowId: string;
    txHash: string;
}>;

interface WebCryptoUnwrapKeyOptions {
    /** Storage key for this device's unwrap key (e.g. `${userId}:${appSalt}`). One
     *  ECDH key per (this value, browser profile). */
    keyId: string;
}
/**
 * Browser `DeviceUnwrapKey`: a non-extractable P-256 **ECDH** key generated with
 * WebCrypto and persisted in IndexedDB. Distinct from `WebCryptoSigner` (an ECDSA
 * signing key) — a signing key can't do ECDH, so the classic-G envelope needs its
 * own key here. The private key never leaves WebCrypto: the account DEK is
 * unwrapped via `deriveBits` (raw ECDH), then AES-GCM in `@noble` on the derived
 * KEK. Per-device, non-syncable → losing the device loses only this convenience
 * factor, never the account (the passkey / recovery factors survive).
 */
declare class WebCryptoDeviceUnwrapKey implements DeviceUnwrapKey {
    private readonly privateKey;
    private readonly publicRaw;
    readonly keyId: string;
    private constructor();
    /** Create a fresh device unwrap key and persist it. */
    static create(opts: WebCryptoUnwrapKeyOptions): Promise<WebCryptoDeviceUnwrapKey>;
    /** Load an existing device unwrap key, or null if none exists yet. */
    static load(opts: WebCryptoUnwrapKeyOptions): Promise<WebCryptoDeviceUnwrapKey | null>;
    static remove(keyId: string): Promise<void>;
    /** Load the device unwrap key, creating one on first use. */
    static loadOrCreate(opts: WebCryptoUnwrapKeyOptions): Promise<WebCryptoDeviceUnwrapKey>;
    publicKeySec1(): Uint8Array;
    slotId(): string;
    unwrap(blob: Uint8Array): Promise<Uint8Array>;
}

/**
 * WebAuthn **PRF** factor for the classic-G envelope.
 *
 * Unlike the Soroban passkey path (which needs an on-chain-verifiable *assertion
 * signature*), the classic-G account only needs a stable 32-byte secret to wrap
 * the DEK — exactly what the WebAuthn PRF extension provides: for a given
 * credential + input salt the authenticator returns the same 32 bytes on every
 * device the passkey syncs to (iCloud Keychain / Google Password Manager), and
 * that secret is derived inside the authenticator and never derivable by Cavos or
 * OAuth. That makes it the ideal synced anchor to approve a new device or recover.
 *
 * `getSecret()` returns the raw PRF output; callers pass it to
 * `derivePasskeyKEK` (via `CavosStellar.enrollPasskey` /
 * `approveThisDeviceWithPasskey`). Keeping this class free of any DEK/KEK logic
 * lets the account class stay runtime-agnostic and unit-testable.
 */
interface PasskeyPrfOptions {
    /** Relying-Party id (usually the eTLD+1). Defaults to `window.location.hostname`. */
    rpId?: string;
    /** Human-readable RP name shown in the OS passkey UI. */
    rpName?: string;
}
type PasskeyPrfEnrollParams = PasskeyEnrollParams;
declare class PasskeyPrf implements PasskeyPrfProvider {
    private readonly rpId;
    private readonly rpName;
    constructor(opts?: PasskeyPrfOptions);
    /** True if this platform advertises a usable passkey (platform authenticator). */
    static isSupported(): Promise<boolean>;
    /**
     * Create a new synced, discoverable passkey with the PRF extension enabled, then
     * immediately read its PRF secret. Returns the credential id and the 32-byte
     * secret so the caller can enroll the passkey factor in one step. Some
     * authenticators don't return PRF results on create — in that case `secret` is
     * undefined and the caller should follow up with `getSecret()`.
     */
    enroll(params: PasskeyPrfEnrollParams): Promise<{
        credentialId: Uint8Array;
        secret?: Uint8Array;
    }>;
    /**
     * Get the passkey's 32-byte PRF secret. Uses discoverable credentials (no
     * `allowCredentials`), so it works from a brand-new browser — the OS shows the
     * synced passkey picker. Throws if the authenticator doesn't support PRF.
     */
    getSecret(credentialId?: Uint8Array): Promise<Uint8Array>;
}

/**
 * Key derivation for the classic Stellar (`G…`) multisig account.
 *
 * A partner integration requires classic ed25519 `G…` addresses, which the
 * Soroban device-account (`C…`) model cannot provide. Instead of a smart
 * contract we use a classic account whose UX matches the rest of Cavos (social
 * login → one address per app, silent signing, gasless, self-custodial):
 *
 *   - The **control key** is a random ed25519 key generated on the first device.
 *     Its public key IS the account's `G…` address, and it is the account's
 *     master key (weight 1) — the address is therefore named by the first
 *     device, exactly as the Starknet constructor and the Solana PDA seeds do.
 *   - Its 32-byte seed is never stored in the clear: it lives envelope-encrypted
 *     in the account's own on-chain data entries (see `envelope.ts`), unlocked
 *     per-device by a P-256 device factor, a passkey, or recovery.
 *
 * The address is not derivable from identity. A returning device looks it up in
 * the Cavos registry and then unlocks the control key from the envelope; it
 * never mints a second `G…`.
 *
 * This module is pure `@noble/*` + stellar-sdk keypair math (no WebCrypto/DOM),
 * so the identical derivation runs in the browser and React Native.
 */
/** A freshly generated control key: the real (weight-1) signer of the account.
 *  Returns both the `Keypair` and its raw 32-byte seed (the secret that the
 *  envelope encrypts). Generated once at account creation, then only ever
 *  recovered by decrypting the on-chain envelope. */
declare function generateControlKey(): {
    keypair: Keypair;
    seed: Uint8Array;
};
/** Rebuild the control `Keypair` from a decrypted 32-byte seed. */
declare function controlKeypairFromSeed(seed: Uint8Array): Keypair;

/** A DEK-wrap blob: `nonce || AES-GCM(kek, dek)`. Self-contained (nonce inline). */
type WrappedDEK = Uint8Array;
/** Fresh 256-bit data-encryption key. One per account, generated at creation. */
declare function generateDEK(): Uint8Array;
/** Encrypt the control seed under the DEK → `nonce || ct`. */
declare function sealControlSeed(controlSeed: Uint8Array, dek: Uint8Array): Uint8Array;
/** Decrypt the control seed (`nonce || ct`) under the DEK. Throws on tamper. */
declare function openControlSeed(sealed: Uint8Array, dek: Uint8Array): Uint8Array;
/** Wrap the DEK under a raw 32-byte KEK → `nonce || AES-GCM(kek, dek)`. */
declare function wrapDEK(dek: Uint8Array, kek: Uint8Array): WrappedDEK;
/** Unwrap the DEK from a `nonce || ct` blob under a raw 32-byte KEK. */
declare function unwrapDEK(wrapped: WrappedDEK, kek: Uint8Array): Uint8Array;
/** KEK from a human recovery code (PBKDF2-stretched, then HKDF-scoped). The same
 *  normalised code yields the same KEK on any device. */
declare function deriveRecoveryKEK(code: string): Uint8Array;
/** KEK from a WebAuthn PRF output (32 bytes the authenticator returns for our
 *  fixed PRF salt). HKDF-scoped so the raw PRF secret is never used directly. */
declare function derivePasskeyKEK(prfOutput: Uint8Array): Uint8Array;
/**
 * ECIES-wrap the DEK to a device's P-256 public key (SEC1 uncompressed, 65
 * bytes). Returns `ephPubCompressed(33) || nonce(12) || ct` — self-contained.
 * An ephemeral keypair makes each wrap use a fresh shared secret; the device
 * unwraps with its private scalar. The ephemeral public key is bound into the
 * KEK via the HKDF salt so it can't be swapped.
 */
declare function eciesWrapDEK(dek: Uint8Array, recipientPubSec1: Uint8Array): Uint8Array;
/** ECIES-unwrap the DEK with the device's private scalar (32 bytes). */
declare function eciesUnwrapDEK(blob: Uint8Array, recipientPrivScalar: Uint8Array): Uint8Array;

/** Split a u256 into the `[low, high]` felt pair Cairo expects. */
declare function u256ToFelts(value: bigint): [bigint, bigint];
/** Big-endian bytes -> bigint. */
declare function bytesToBigInt(bytes: Uint8Array): bigint;
declare function bytesToHex(bytes: Uint8Array): string;
declare function hexToBytes(hex: string): Uint8Array;
/** A felt/bigint -> 32-byte big-endian Uint8Array (the tx-hash width). */
declare function bigIntTo32Bytes(value: bigint): Uint8Array;

export { AttestationPolicy, AuthProvider, CavosAuth, type CavosAuthOptions, CavosStellar, DEFAULT_SOCIAL_RECOVERY_ATTESTATION, DevicePublicKey, DeviceUnwrapKey, type EscrowInput, type EscrowState, ExecuteOptions, HttpWalletRegistry, type HttpWalletRegistryOptions, Identity, type MilestoneInput, PasskeyEnrollParams, PasskeyPrf, type PasskeyPrfEnrollParams, type PasskeyPrfOptions, PasskeyPrfProvider, RegisterResult, RegisteredWallet, SocialRecoveryCredential, StellarAdapter, TrustlessWorkEscrow, WalletRegistry, WebCryptoDeviceUnwrapKey, type WebCryptoUnwrapKeyOptions, bigIntTo32Bytes, buildEscrowScVal, bytesToBigInt, bytesToHex, controlKeypairFromSeed, deployEscrow, derivePasskeyKEK, deriveRecoveryKEK, eciesUnwrapDEK, eciesWrapDEK, generateControlKey, generateDEK, generateRecoveryCode, hexToBytes, openControlSeed, sealControlSeed, u256ToFelts, unwrapDEK, wrapDEK };