import { AttachableMemoryCacheDevice } from '../cacheDevices/AttachableMemoryCacheDevice';
export declare const stealthPairCacheDevice: AttachableMemoryCacheDevice<{
    H0: [bigint, bigint];
    H1: [bigint, bigint];
}>;
export declare const stealthAddressCacheDevice: AttachableMemoryCacheDevice<string>;
export interface EncryptionKeyPair {
    privateKey: string;
    publicKey: string;
}
export declare const EncryptionKeyPairDefaultValue: EncryptionKeyPair;
export declare class UserKeys {
    private signature;
    private shieldedPrivateKey;
    constructor(_signature?: string, _shieldedPrivateKey?: string);
    getSignature(): string;
    setSignature(_signature: string): void;
    private requireSignature;
    private requireKeyMaterial;
    verifyMessage(signingMessage: string): string;
    verifySolanaMessage(signingMessage: string, signerPublicKey: string): boolean;
    /**
     * get shielded private key from message signature used to login to the application,
     * this private key is used to generate encryption keypairs as well as public key
     * @retuns 0x-prefixed shielded private key
     */
    getShieldedPrivateKey: () => string;
    /**
     * generate shielded public key from private key
     * @param privateKey the key used to generate the shielded public key, this should be the signature
     * that the user provided
     * @retuns shielded public key in hexstring with 0x prefixed
     */
    getShieldedPublicKey: () => string;
    /**
     * Currently used for creating shielded private keys for deposit UTXOs, which are encrypted and sent to enclave for private send
     * @param nonce Used to deterministically generate new shielded private key
     * @returns new shielded private key in hexstring with 0x prefixed
     */
    getShieldedPrivateKeyFromNonce: (nonce: bigint) => string;
    /**
     * deterministically derive an EVM address from the shielded private key
     */
    getDerivedEthereumAddress: () => string;
    /**
     * deterministically derive a Solana public key from the shielded private key
     */
    getDerivedSolanaPublicKey: () => string;
    /**
     * generate access token, this accessKey is what should be sent to the server for signing
     * @returns accessKey in hexstring with 0x prefixed
     */
    getAccessKey: () => string;
    getSignerPrivateKeyFromNonce: (walletNonce: bigint) => string;
    getSignerSolanaPrivateKeyFromNonce: (walletNonce: bigint) => string;
    getWalletSalt: (walletNonce: bigint) => string;
    /**
     * generate inHinkalAddress - a user unique address linking him with a specific app
     * @returns inHinkalAddress in bigint
     */
    getInHinkalAddress: (interactionAddress: string) => bigint;
    /**
     * generate backend token, which is used for access control on backend
     * @returns accessKey in hexstring with 0x prefixed
     */
    getBackendToken: () => string;
    static getRandomizedStealthPair: (s: bigint, privateKey: string) => {
        H0: [bigint, bigint];
        H1: [bigint, bigint];
    };
    static getStealthAddressCompressedPoints: (s: bigint, privateKey: string) => {
        h0: bigint;
        h1: bigint;
    };
    static getStealthAddress: (s: bigint, privateKey: string) => string;
    static getStealthAddressWithEKey: (s: bigint, privateKey: string) => {
        stealthAddress: string;
        encryptionKey: string;
    };
    static checkSignature: (s: bigint, stealthAddressH0: bigint, stealthAddressH1: bigint, privateKey: string) => boolean;
    /**
     * generate private and public keypair
     * @param seed seed to use to deterministically generate key, must be in DataHexString format
     * and must correspond to 32 bytes
     */
    static getEncryptionKeyPair: (privateKey: string) => EncryptionKeyPair;
}
