@cryptforge/core 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,772 @@
+interface KeyData {
+    mnemonic: string;
+    seed: Uint8Array;
+    privateKey: Uint8Array;
+    privateKeyHex: string;
+    publicKey: Uint8Array;
+    publicKeyHex: string;
+    address: string;
+    path: string;
+}
+interface ChainData {
+    name: string;
+    symbol: string;
+    chainId: number;
+    tokenStandard?: string;
+    decimals: number;
+    cmc_id: number;
+}
+interface Chain {
+    id: string;
+    name: string;
+    symbol: string;
+}
+interface Identity {
+    id: string;
+    publicKey: string;
+    fingerprint: string;
+    label?: string;
+    metadata: Record<string, any>;
+    createdAt: Date;
+    lastAccess?: Date;
+}
+interface StoredIdentity {
+    id: string;
+    fingerprint: string;
+    publicKey: string;
+    label?: string;
+    metadata: Record<string, any>;
+    keystore: string;
+    createdAt: string;
+    lastAccess?: string;
+}
+interface Keys {
+    privateKey: Uint8Array;
+    privateKeyHex: string;
+    publicKey: Uint8Array;
+    publicKeyHex: string;
+    address: string;
+    derivationPath: string;
+    chain: Chain;
+    expiresAt: Date;
+    expiresIn: number;
+    identity: Identity;
+}
+interface AuthState {
+    identity: Identity | null;
+    keys: Keys | null;
+    currentChain: Chain | null;
+    isLocked: boolean;
+}
+interface CreateIdentityOptions {
+    mnemonic: string;
+    password: string;
+    metadata?: Record<string, any>;
+    label?: string;
+}
+interface GenerateMnemonicOptions {
+    wordCount?: 12 | 24;
+    language?: string;
+}
+interface RestoreIdentityOptions {
+    mnemonic: string;
+    password: string;
+    metadata?: Record<string, any>;
+    label?: string;
+}
+interface UnlockOptions {
+    password: string;
+    identityId?: string;
+    chainId?: string;
+    derivationPath?: string;
+    duration?: number;
+}
+interface SignMessageOptions {
+    message: string | Uint8Array;
+    derivationPath?: string;
+}
+interface SignTransactionOptions {
+    transaction: any;
+    derivationPath?: string;
+}
+interface DeriveKeyOptions {
+    path: string;
+    hardened?: boolean;
+}
+interface DeriveDataKeyOptions {
+    purpose: string;
+    version?: number;
+    algorithm?: "AES-GCM" | "AES-CBC";
+    length?: 128 | 192 | 256;
+    extractable?: boolean;
+}
+type AuthEvent = "IDENTITY_CREATED" | "IDENTITY_IMPORTED" | "IDENTITY_SWITCHED" | "IDENTITY_DELETED" | "PASSWORD_CHANGED" | "UNLOCKED" | "LOCKED" | "KEYS_ROTATED" | "IDENTITY_UPDATED" | "KEY_DERIVED" | "KEYS_EXPIRED" | "CHAIN_SWITCHED";
+type AuthChangeCallback = (event: AuthEvent, keys: Keys | null) => void;
+interface AuthAdapter {
+    registerAdapter: (chainId: string, adapter: any) => void;
+    getRegisteredChains: () => string[];
+    generateMnemonic: (options?: GenerateMnemonicOptions) => string;
+    createIdentity: (options: CreateIdentityOptions & {
+        chainId?: string;
+    }) => Promise<{
+        identity: Identity;
+        keys: Keys;
+    }>;
+    listIdentities: () => Promise<Array<Identity>>;
+    switchIdentity: (identityId: string) => Promise<{
+        identity: Identity;
+    }>;
+    updateIdentity: (identityId: string, updates: {
+        label?: string;
+        metadata?: Record<string, any>;
+    }) => Promise<{
+        identity: Identity;
+    }>;
+    deleteIdentity: (identityId: string, password: string) => Promise<void>;
+    changePassword: (identityId: string, oldPassword: string, newPassword: string) => Promise<void>;
+    exportMnemonic: (identityId: string, password: string) => Promise<string>;
+    exportKeystore: (identityId: string) => Promise<string>;
+    exportIdentity: (identityId: string) => Promise<StoredIdentity>;
+    importMnemonic: (mnemonic: string, password: string, label?: string) => Promise<{
+        identity: Identity;
+    }>;
+    importKeystore: (keystoreJson: string, password: string, label?: string) => Promise<{
+        identity: Identity;
+    }>;
+    importIdentity: (storedIdentity: StoredIdentity) => Promise<{
+        identity: Identity;
+    }>;
+    unlock: (options: UnlockOptions) => Promise<{
+        keys: Keys;
+    }>;
+    lock: () => Promise<void>;
+    verifyPassword: (password: string) => Promise<boolean>;
+    switchChain: (chainId: string, password?: string) => Promise<{
+        keys: Keys;
+    }>;
+    rotateKeys: (newDerivationPath?: string) => Promise<{
+        keys: Keys;
+    }>;
+    deriveKey: (options: DeriveKeyOptions) => Promise<{
+        privateKey: string;
+        publicKey: string;
+        address: string;
+        path: string;
+    }>;
+    deriveBIP44DocumentID: (options: {
+        appId: number;
+        account?: number;
+        purpose?: number;
+        index?: number;
+    }) => Promise<string>;
+    deriveDataEncryptionKey: (options: DeriveDataKeyOptions) => Promise<CryptoKey>;
+    getAddressForChain: (chainId: string, index?: number) => Promise<{
+        address: string;
+        publicKey: string;
+        derivationPath: string;
+    }>;
+    getAddresses: (chainId: string, start?: number, count?: number) => Promise<Array<{
+        address: string;
+        path: string;
+        index: number;
+    }>>;
+    findUsedAddresses: (chainId: string, checkBalance: (address: string) => Promise<boolean>) => Promise<Array<{
+        address: string;
+        path: string;
+        index: number;
+    }>>;
+    signMessage: (options: SignMessageOptions) => Promise<{
+        signature: string;
+        address: string;
+        publicKey: string;
+    }>;
+    signTransaction: (options: SignTransactionOptions) => Promise<{
+        signedTransaction: any;
+        signature: string;
+    }>;
+    verifySignature: (message: string | Uint8Array, signature: string, publicKey: string) => Promise<boolean>;
+    onAuthStateChange: (callback: AuthChangeCallback) => () => void;
+    readonly currentIdentity: Identity | null;
+    readonly currentKeys: Keys | null;
+    readonly currentChain: Chain | null;
+    readonly currentAddress: string | null;
+    readonly currentPublicKey: string | null;
+    readonly currentExpiresAt: Date | null;
+    readonly currentExpiresIn: number | null;
+    readonly isLocked: boolean;
+    readonly isUnlocked: boolean;
+    readonly hasIdentity: boolean;
+    readonly masterPublicKey: string | null;
+}
+
+type BlockchainType = "Bitcoin" | "Ethereum" | "Sonic" | "Kaspa";
+interface TransactionReceipt {
+    /** Transaction hash - can be used to track on explorer */
+    hash: string;
+    /** Sender address */
+    from: string;
+    /** Recipient address (or contract address for token transfers) */
+    to: string;
+    /** Value transferred in wei (for native) or "0" (for token transfers) */
+    value: string;
+    /** Chain ID */
+    chainId: number;
+    /** Initial status - will be "pending" on return */
+    status: "pending";
+    /** Nonce used */
+    nonce: number;
+}
+interface TransactionStatusUpdate {
+    /** Transaction hash */
+    hash: string;
+    /** Current status */
+    status: "pending" | "confirmed" | "failed";
+    /** Block number if confirmed */
+    blockNumber?: number;
+    /** Number of confirmations if confirmed */
+    confirmations?: number;
+    /** Error message if failed */
+    error?: string;
+    /** Gas used (if confirmed) */
+    gasUsed?: string;
+}
+interface TokenBalance {
+    /** Token contract address */
+    contractAddress: string;
+    /** Balance in smallest unit (e.g., wei for 18 decimals) */
+    balance: string;
+    /** Human-readable balance (balance / 10^decimals) */
+    balanceFormatted: string;
+    /** Token symbol (e.g., "USDC") */
+    symbol: string;
+    /** Token name (e.g., "USD Coin") */
+    name: string;
+    /** Token decimals */
+    decimals: number;
+    /** Token logo URL (optional) */
+    logo?: string;
+    /**
+     * Whether this is an NFT (ERC-721/ERC-1155)
+     * Currently false for all ERC-20 tokens. Will be populated when dedicated NFT methods are implemented.
+     */
+    isNFT: boolean;
+}
+interface Transaction {
+    /** Transaction hash */
+    hash: string;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Value transferred in wei */
+    value: string;
+    /** Unix timestamp */
+    timestamp: number;
+    /** Block number */
+    blockNumber: number;
+    /** Gas used */
+    gasUsed: string;
+    /** Gas price in wei */
+    gasPrice: string;
+    /** Transaction status */
+    status: "success" | "failed" | "pending";
+    /** Whether transaction failed */
+    isError: boolean;
+}
+interface TokenTransfer {
+    /** Transaction hash */
+    hash: string;
+    /** Sender address */
+    from: string;
+    /** Recipient address */
+    to: string;
+    /** Amount transferred in smallest unit */
+    value: string;
+    /** Unix timestamp */
+    timestamp: number;
+    /** Block number */
+    blockNumber: number;
+    /** Token contract address */
+    tokenAddress: string;
+    /** Token symbol */
+    tokenSymbol: string;
+    /** Token name */
+    tokenName: string;
+    /** Token decimals */
+    tokenDecimal: string;
+}
+interface TransactionOptions {
+    /** Starting block number (default: 0) */
+    startBlock?: number;
+    /** Ending block number (default: latest) */
+    endBlock?: number;
+    /** Page number for pagination (default: 1) */
+    page?: number;
+    /** Number of results per page (default: 100) */
+    offset?: number;
+    /** Sort order (default: 'desc') */
+    sort?: "asc" | "desc";
+}
+interface BlockchainAdapter {
+    readonly chainData: ChainData;
+    deriveKeys: (mnemonic: string) => Promise<KeyData>;
+    /**
+     * Derive keys at a specific address index
+     * @param mnemonic - BIP39 mnemonic phrase
+     * @param addressIndex - Address index in the BIP44 path
+     * @returns KeyData with derived keys
+     */
+    deriveKeysAtIndex: (mnemonic: string, addressIndex: number) => Promise<KeyData>;
+    /**
+     * Derive keys at a custom derivation path
+     * @param mnemonic - BIP39 mnemonic phrase
+     * @param path - Full BIP44 derivation path
+     * @returns KeyData with derived keys
+     */
+    deriveKeysAtPath: (mnemonic: string, path: string) => Promise<KeyData>;
+    /**
+     * Get address at a specific index (read-only, no private key)
+     * @param mnemonic - BIP39 mnemonic phrase
+     * @param index - Address index
+     * @returns Address and public key information
+     */
+    getAddressAtIndex: (mnemonic: string, index: number) => Promise<{
+        address: string;
+        publicKey: string;
+        path: string;
+    }>;
+    /**
+     * Get multiple addresses starting from an index
+     * @param mnemonic - BIP39 mnemonic phrase
+     * @param startIndex - Starting address index
+     * @param count - Number of addresses to generate
+     * @returns Array of addresses with metadata
+     */
+    getAddresses: (mnemonic: string, startIndex: number, count: number) => Promise<Array<{
+        address: string;
+        path: string;
+        index: number;
+    }>>;
+    /**
+     * Sign a message with a private key
+     * @param privateKey - Private key as Uint8Array
+     * @param message - Message to sign (string or Uint8Array)
+     * @returns Signature
+     */
+    signMessage: (privateKey: Uint8Array, message: string | Uint8Array) => Promise<{
+        signature: string;
+    }>;
+    /**
+     * Sign a transaction with a private key
+     * @param privateKey - Private key as Uint8Array
+     * @param transaction - Chain-specific transaction object
+     * @returns Signed transaction and signature
+     */
+    signTransaction: (privateKey: Uint8Array, transaction: any) => Promise<{
+        signedTransaction: any;
+        signature: string;
+    }>;
+    /**
+     * Verify a signature against a public key
+     * @param message - Original message
+     * @param signature - Signature to verify
+     * @param publicKey - Public key (hex string)
+     * @returns True if signature is valid
+     */
+    verifySignature: (message: string | Uint8Array, signature: string, publicKey: string) => Promise<boolean>;
+    /**
+     * Get native token balance (ETH, BTC, etc.) with metadata
+     * @param address - Wallet address
+     * @returns TokenBalance object with balance and metadata
+     */
+    getNativeBalance: (address: string) => Promise<TokenBalance>;
+    /**
+     * Get all ERC-20/token balances with metadata
+     * @param address - Wallet address
+     * @returns Array of token balances
+     */
+    getTokenBalances: (address: string) => Promise<TokenBalance[]>;
+    /**
+     * Get balance for a specific token contract
+     * @param address - Wallet address
+     * @param tokenAddress - Token contract address
+     * @returns Balance in smallest unit as string
+     */
+    getTokenBalance: (address: string, tokenAddress: string) => Promise<string>;
+    /**
+     * Get all native token transactions (send/receive)
+     * @param address - Wallet address
+     * @param options - Optional filtering and pagination
+     * @returns Array of transactions
+     */
+    getTransactions: (address: string, options?: TransactionOptions) => Promise<Transaction[]>;
+    /**
+     * Get all token transfer events
+     * @param address - Wallet address
+     * @param options - Optional filtering and pagination
+     * @returns Array of token transfers
+     */
+    getTokenTransfers: (address: string, options?: TransactionOptions) => Promise<TokenTransfer[]>;
+    /**
+     * Send native tokens (ETH, BTC, etc.)
+     * Private key must be obtained from AuthClient after password verification
+     * @param params - Transaction parameters including private key
+     * @returns Transaction receipt with pending status
+     */
+    sendNativeToken: (params: {
+        privateKey: Uint8Array;
+        to: string;
+        amount: string;
+    }) => Promise<TransactionReceipt>;
+    /**
+     * Send tokens (ERC-20, etc.)
+     * Private key must be obtained from AuthClient after password verification
+     * @param params - Transaction parameters including private key and token address
+     * @returns Transaction receipt with pending status
+     */
+    sendToken: (params: {
+        privateKey: Uint8Array;
+        to: string;
+        tokenAddress: string;
+        amount: string;
+    }) => Promise<TransactionReceipt>;
+    /**
+     * Get transaction status by hash
+     * @param hash - Transaction hash
+     * @returns Current transaction status with confirmations
+     */
+    getTransactionStatus: (hash: string) => Promise<TransactionStatusUpdate>;
+}
+
+/**
+ * Base document type that developers work with.
+ * Includes managed metadata fields (id, createdAt, updatedAt) that are automatically set by the library.
+ * Users should extend this interface to define their document types.
+ *
+ * @example
+ * ```typescript
+ * interface UserDocument extends BaseDocument {
+ *   type: 'user'
+ *   name: string
+ *   email: string
+ *   // id, createdAt, updatedAt are automatically available
+ * }
+ * ```
+ */
+interface BaseDocument {
+    /** The document type identifier (e.g., 'note', 'task', 'user') */
+    type: string;
+    /** The Automerge document URL - automatically set by the library */
+    id: string;
+    /** Timestamp when the document was created - automatically set by the library */
+    createdAt: number;
+    /** Timestamp of the last update - automatically set by the library */
+    updatedAt: number;
+    /** Additional fields can be added as needed */
+    [key: string]: any;
+}
+/**
+ * Helper type to ensure user's document type doesn't include managed fields.
+ * This prevents conflicts and ensures the library controls these fields.
+ * Users cannot pass id, createdAt, or updatedAt when creating documents.
+ */
+type ExternalDocument<T extends BaseDocument> = Omit<T, "id" | "createdAt" | "updatedAt">;
+/**
+ * Internal encrypted document wrapper.
+ * This structure is what's actually stored in Automerge.
+ * The encryption/decryption is handled transparently by the store.
+ *
+ * @template T - The type of the decrypted document content (used for type safety, not stored in interface)
+ */
+interface EncryptedDocument<_T> extends BaseDocument {
+    /** Always 'encrypted' to identify this as an encrypted wrapper */
+    type: "encrypted";
+    /** Base64-encoded encrypted data containing the actual document */
+    encryptedData: string;
+    /**
+     * Optional owner identifier (e.g., master public key from auth).
+     * Stored unencrypted for server-side ownership verification without decryption.
+     */
+    owner?: string;
+    /** Metadata about the encrypted document */
+    metadata: {
+        /** The original document type before encryption */
+        contentType: string;
+        /** Timestamp when the document was last encrypted */
+        encryptedAt: number;
+        /** User ID who encrypted the document */
+        encryptedBy: string;
+    };
+}
+/**
+ * Configuration for subscribing to document changes.
+ *
+ * @template T - The type of document being subscribed to
+ */
+interface SubscribeConfig<T extends BaseDocument> {
+    /** The Automerge document URL/ID to subscribe to */
+    id: string;
+    /**
+     * Unique context identifier for this subscription.
+     * Allows multiple subscriptions to the same document (e.g., 'sidebar', 'main-view').
+     */
+    context: string;
+    /**
+     * Callback invoked with the decrypted document whenever it changes.
+     * Receives null if the document doesn't exist or was deleted.
+     * The document includes id, createdAt, and updatedAt fields automatically.
+     */
+    onUpdate: (doc: T | null) => void;
+    /**
+     * Optional error handler for subscription failures.
+     * Called when decryption fails or other errors occur.
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Configuration for unsubscribing from document changes.
+ */
+interface UnsubscribeConfig {
+    /** The document ID to unsubscribe from */
+    id: string;
+    /** The context identifier of the subscription to remove */
+    context: string;
+}
+/**
+ * Generic interface for cryptographic operations.
+ *
+ * @template TKey - The encryption key type (CryptoKey for browser, Buffer for Node.js)
+ */
+interface CryptoOperations<TKey = unknown> {
+    /**
+     * Encryption key for all document operations.
+     * All documents are encrypted at rest using this key.
+     * Browser implementations use CryptoKey, Node.js implementations use Buffer.
+     */
+    setEncryptionKey?: (key: TKey) => void;
+    /**
+     * Creates an encryption function that encrypts string data using AES-GCM encryption.
+     * Returns a curried function that uses the instance's encryption key from `getEncryptionKey`.
+     *
+     * The returned function signature:
+     * - `data`: The plaintext string to encrypt
+     * - Returns: A promise resolving to the encrypted data as a string
+     */
+    encrypt: () => (data: string) => Promise<string>;
+    /**
+     * Creates a decryption function that decrypts encrypted string data using AES-GCM decryption.
+     * Returns a curried function that uses the instance's encryption key from `getEncryptionKey`.
+     *
+     * The returned function signature:
+     * - `encryptedData`: The encrypted string data to decrypt
+     * - Returns: A promise resolving to the decrypted plaintext string
+     */
+    decrypt: () => (encryptedData: string) => Promise<string>;
+}
+/**
+ * Interface for document store adapters.
+ * Provides a standard interface for document storage, retrieval, modification, and subscription operations.
+ *
+ * @template TKey - The encryption key type (CryptoKey for browser, Buffer for Node.js)
+ */
+interface StoreAdapter {
+    /**
+     * Optional: Gets the network adapter for stores that support network synchronization.
+     * Returns null if no network adapter is configured.
+     * This property is only available on stores that implement network synchronization.
+     * The type is `any` to avoid coupling core types to Automerge-specific types.
+     */
+    readonly networkAdapter?: any | null;
+    /**
+     * Sets the encryption key for the store. Store operations aren't possible until the encryption key is set.
+     *
+     * @template TKey - The encryption key type (CryptoKey for browser, Buffer for Node.js)
+     * @param key - The encryption key to set
+     */
+    setEncryptionKey<TKey = unknown>(key: TKey): void;
+    /**
+     * Sets the owner identifier for document ownership (e.g., auth.masterPublicKey).
+     * Stored unencrypted in EncryptedDocument for server-side verification.
+     * Should be chain-independent for multi-blockchain applications.
+     *
+     * @param publicKey - The owner's public key
+     */
+    setOwnerPublicKey(publicKey: string): void;
+    /**
+     * Creates a new document with automatic encryption.
+     *
+     * The document is encrypted before being stored.
+     * Returns the document URL which can be used to retrieve or subscribe to the document.
+     *
+     * @template T - The document type (must extend BaseDocument)
+     * @param doc - The document to create (must include a 'type' field)
+     * @param url - Optional Automerge URL for deterministic document IDs
+     * @returns Promise resolving to the document URL
+     * @throws {Error} If document is missing 'type' field or encryption fails
+     */
+    create<T extends BaseDocument>(doc: ExternalDocument<T>, url?: string): Promise<string>;
+    /**
+     * Retrieves and decrypts a document by ID.
+     *
+     * @template T - The expected document type
+     * @param id - The document URL/ID
+     * @returns Promise resolving to the decrypted document, or null if not found
+     * @throws {Error} If document ID is invalid or decryption fails
+     */
+    get<T extends BaseDocument>(id: string): Promise<T | null>;
+    /**
+     * Modifies a document with automatic re-encryption.
+     *
+     * The document is decrypted, modified via the callback, then re-encrypted.
+     * Changes are applied atomically.
+     * The document includes id, createdAt, and updatedAt fields automatically.
+     *
+     * **Protected Fields**: The fields `id`, `createdAt`, and `updatedAt` are managed
+     * by the library and cannot be modified. Any attempts to change these fields in
+     * the callback will be ignored and restored to their original values. The library
+     * automatically updates `updatedAt` when changes are made.
+     *
+     * @template T - The document type
+     * @param id - The document ID to modify
+     * @param callback - Function that receives the decrypted document to modify
+     * @returns Promise that resolves when the change is applied
+     * @throws {Error} If document not found or encryption fails
+     */
+    change<T extends BaseDocument>(id: string, callback: (doc: T) => void): Promise<void>;
+    /**
+     * Deletes a document and cleans up all associated subscriptions.
+     *
+     * This removes the document from storage and automatically
+     * unsubscribes all active listeners to prevent memory leaks.
+     *
+     * @param id - The document ID to delete
+     * @returns Promise that resolves when deletion is complete
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Subscribes to document changes with automatic decryption.
+     *
+     * The callback receives the decrypted document whenever it changes.
+     * Multiple subscriptions to the same document are supported via different contexts.
+     *
+     * @template T - The document type
+     * @param config - Subscription configuration
+     * @returns Unsubscribe function to stop receiving updates
+     */
+    subscribe<T extends BaseDocument>(config: SubscribeConfig<T>): () => void;
+    /**
+     * Unsubscribes from document changes using document ID and context.
+     *
+     * Alternative to calling the unsubscribe function returned by subscribe().
+     *
+     * @param config - Object containing document ID and context
+     * @returns true if subscription was found and removed, false otherwise
+     */
+    unsubscribe(config: UnsubscribeConfig): boolean;
+    /**
+     * Gets all active subscription contexts for a document.
+     * Useful for debugging subscription state.
+     *
+     * @param id - The document ID
+     * @returns Array of context identifiers currently subscribed to this document
+     */
+    getActiveSubscriptions(id: string): string[];
+    /**
+     * Gets all active subscriptions across all documents.
+     * Useful for debugging memory leaks or subscription issues.
+     *
+     * @returns Object mapping document IDs to arrays of context identifiers
+     */
+    getAllActiveSubscriptions(): Record<string, string[]>;
+}
+
+type ActionType = "primary" | "secondary";
+interface SlideAction {
+    type: ActionType;
+    title: string;
+    action: () => void;
+}
+interface WalkthroughStep {
+    image?: string;
+    title: string;
+    description: string;
+    actions?: SlideAction[];
+}
+interface AppInfo {
+    appId: number;
+    icon: string;
+    name: string;
+    secret: string;
+    description: string;
+    steps: WalkthroughStep[];
+}
+
+interface KeyTransportAdapter {
+    enableBroadcast: () => Promise<string>;
+    connect: (topic: string, name: string, app: string) => Promise<void>;
+    onClientConnection: (callback: (response: Record<string, any>) => void) => Promise<void> | Promise<() => void>;
+    requestKeystore: (pin: string) => Promise<void>;
+    onKeystoreRequestInvalidPIN: (callback: (response: Record<string, any>) => void) => Promise<void> | Promise<() => void>;
+    onKeystoreRequestValidPIN: (callback: (response: Record<string, any>) => void) => Promise<void> | Promise<() => void>;
+    onKeystoreRequest: (callback: (response: Record<string, any>) => void) => Promise<void> | Promise<() => void>;
+    approveRequest: (data: {
+        identity: StoredIdentity;
+        appId: number;
+    }) => Promise<void>;
+    onClientApproval: (callback: (response: Record<string, any>) => void) => Promise<void> | Promise<() => void>;
+    denyRequest: () => Promise<void>;
+    onClientDenial: (callback: (response: Record<string, any>) => void) => Promise<void> | Promise<() => void>;
+    onCompletion: (callback: (response: Record<string, any>) => void) => Promise<void> | Promise<() => void>;
+    disableBroadcast: () => Promise<void>;
+    onBroadcastDisable: (callback: (response: Record<string, any>) => void) => Promise<void> | Promise<() => void>;
+    getDeviceInfo: () => Promise<Record<string, any>>;
+    getHostname: () => Promise<string>;
+    connectPresence: (topic: string) => Promise<void>;
+    broadcastClientState: (id: string, state: ClientConnectionState) => Promise<void>;
+    onClientStateRequest: (callback: () => void) => Promise<void> | Promise<() => void>;
+    onClientStateUpdate: (callback: (response: {
+        id: string;
+        state: ClientConnectionState;
+    }) => void) => Promise<void> | Promise<() => void>;
+    getPeerState: (id: string) => ClientConnectionState | undefined;
+    getAllPeers: () => ReadonlyMap<string, ClientConnectionState>;
+}
+type OnSetupEventCallback = (options: {
+    route: string;
+    data: Record<string, any>;
+}) => void;
+
+interface PresenceAdapter {
+    connectPresence: (topic: string) => Promise<void>;
+    broadcastClientState: (id: string, state: ClientConnectionState) => Promise<void>;
+    onClientStateRequest: (callback: () => void) => Promise<void> | Promise<() => void>;
+    onClientStateUpdate: (callback: (response: {
+        id: string;
+        state: ClientConnectionState;
+    }) => void) => Promise<void> | Promise<() => void>;
+    getPeerState: (id: string) => ClientConnectionState | undefined;
+    getAllPeers: () => ReadonlyMap<string, ClientConnectionState>;
+}
+
+interface CryptForgeClientOptions {
+    secrets: KeyTransportAdapter;
+    presence: PresenceAdapter;
+    data: StoreAdapter;
+    appInfo: AppInfo;
+    blockchain: BlockchainAdapter;
+    auth: AuthAdapter;
+}
+interface CryptForgeClient {
+    secrets: KeyTransportAdapter;
+    presence: PresenceAdapter;
+    data: StoreAdapter;
+    appInfo: AppInfo;
+    blockchain: BlockchainAdapter;
+    auth: AuthAdapter;
+}
+declare function createCryptForgeClient(options: CryptForgeClientOptions): CryptForgeClient;
+type ClientConnectionState = "unknown" | "connecting" | "connected" | "idle" | "disconnected";
+
+declare const version = "0.1.0";
+
+export { type ActionType, type AppInfo, type AuthAdapter, type AuthChangeCallback, type AuthEvent, type AuthState, type BaseDocument, type BlockchainAdapter, type BlockchainType, type Chain, type ChainData, type ClientConnectionState, type CreateIdentityOptions, type CryptForgeClient, type CryptForgeClientOptions, type CryptoOperations, type DeriveDataKeyOptions, type DeriveKeyOptions, type EncryptedDocument, type ExternalDocument, type GenerateMnemonicOptions, type Identity, type KeyData, type KeyTransportAdapter, type Keys, type OnSetupEventCallback, type PresenceAdapter, type RestoreIdentityOptions, type SignMessageOptions, type SignTransactionOptions, type SlideAction, type StoreAdapter, type StoredIdentity, type SubscribeConfig, type TokenBalance, type TokenTransfer, type Transaction, type TransactionOptions, type TransactionReceipt, type TransactionStatusUpdate, type UnlockOptions, type UnsubscribeConfig, type WalkthroughStep, createCryptForgeClient, version };