/// <reference types="node" />
import { AirGapTransactionStatus, IAirGapTransaction } from '../../../interfaces/IAirGapTransaction';
import { SignedTezosTransaction } from '../../../serializer/schemas/definitions/signed-transaction-tezos';
import { UnsignedTezosTransaction } from '../../../serializer/schemas/definitions/unsigned-transaction-tezos';
import { UnsignedTezosSaplingTransaction } from '../../../serializer/schemas/definitions/unsigned-transaction-tezos-sapling';
import { RawTezosSaplingTransaction, RawTezosTransaction } from '../../../serializer/types';
import { ProtocolSymbols } from '../../../utils/ProtocolSymbols';
import { CurrencyUnit, FeeDefaults, ICoinProtocol } from '../../ICoinProtocol';
import { ICoinSubProtocol } from '../../ICoinSubProtocol';
import { NonExtendedProtocol } from '../../NonExtendedProtocol';
import { TezosContract } from '../contract/TezosContract';
import { TezosContractCall } from '../contract/TezosContractCall';
import { TezosProtocol } from '../TezosProtocol';
import { TezosTransactionParameters } from '../types/operations/Transaction';
import { TezosSaplingTransactionCursor } from '../types/sapling/TezosSaplingTransactionCursor';
import { TezosSaplingTransactionResult } from '../types/sapling/TezosSaplingTransactionResult';
import { TezosSaplingWrappedTransaction } from '../types/sapling/TezosSaplingWrappedTransaction';
import { TezosSaplingNodeClient } from './node/TezosSaplingNodeClient';
import { TezosSaplingAddress } from './TezosSaplingAddress';
import { TezosSaplingCryptoClient } from './TezosSaplingCryptoClient';
import { TezosSaplingProtocolOptions } from './TezosSaplingProtocolOptions';
import { TezosSaplingBookkeeper } from './utils/TezosSaplingBookkeeper';
import { TezosSaplingEncoder } from './utils/TezosSaplingEncoder';
import { TezosSaplingForger } from './utils/TezosSaplingForger';
import { TezosSaplingState } from './utils/TezosSaplingState';
export declare abstract class TezosSaplingProtocol extends NonExtendedProtocol implements ICoinProtocol {
    readonly options: TezosSaplingProtocolOptions;
    private static readonly TRANSACTION_PLACEHOLDER;
    readonly symbol: string;
    readonly name: string;
    readonly marketSymbol: string;
    readonly feeSymbol: string;
    readonly feeDefaults: FeeDefaults;
    readonly decimals: number;
    readonly feeDecimals: number;
    readonly identifier: ProtocolSymbols;
    readonly units: CurrencyUnit[];
    readonly supportsHD: boolean;
    readonly standardDerivationPath: string;
    readonly addressIsCaseSensitive: boolean;
    readonly addressValidationPattern: string;
    readonly addressPlaceholder: string;
    readonly cryptoClient: TezosSaplingCryptoClient;
    readonly nodeClient: TezosSaplingNodeClient;
    readonly contract: TezosContract;
    readonly bookkeeper: TezosSaplingBookkeeper;
    readonly encoder: TezosSaplingEncoder;
    readonly forger: TezosSaplingForger;
    readonly state: TezosSaplingState;
    protected readonly tezosProtocol: TezosProtocol;
    constructor(options: TezosSaplingProtocolOptions);
    abstract prepareContractCalls(transactions: TezosSaplingWrappedTransaction[]): Promise<TezosContractCall[]>;
    abstract parseParameters(parameters: TezosTransactionParameters): Promise<TezosSaplingWrappedTransaction[]>;
    initParameters(spendParams: Buffer, outputParams: Buffer): Promise<void>;
    getBlockExplorerLinkForTxId(txId: string): Promise<string>;
    getPublicKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string | undefined): Promise<string>;
    getPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string | undefined): Promise<Buffer>;
    private getSeedFromMnemonic;
    getPublicKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
    getPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<Buffer>;
    getAddressFromPublicKey(viewingKey: string): Promise<TezosSaplingAddress>;
    getAddressesFromPublicKey(viewingKey: string): Promise<TezosSaplingAddress[]>;
    getAddressFromViewingKey(viewingKey: string, index: string): Promise<TezosSaplingAddress>;
    getNextAddressFromPublicKey(viewingKey: string, current: TezosSaplingAddress): Promise<TezosSaplingAddress>;
    getTransactionsFromPublicKey(publicKey: string, limit: number, cursor?: TezosSaplingTransactionCursor): Promise<TezosSaplingTransactionResult>;
    signWithPrivateKey(privateKey: Buffer, transaction: RawTezosSaplingTransaction): Promise<string>;
    getTransactionDetails(transaction: UnsignedTezosTransaction | UnsignedTezosSaplingTransaction, data?: {
        knownViewingKeys: string[];
    }): Promise<IAirGapTransaction[]>;
    getTransactionDetailsFromSigned(transaction: SignedTezosTransaction, data?: {
        knownViewingKeys: string[];
    }): Promise<IAirGapTransaction[]>;
    private getTransactionDetailsFromWrappedOperation;
    private getPartialDetailsFromContractParameters;
    private filterOutPaybacks;
    getBalanceOfPublicKey(publicKey: string): Promise<string>;
    getTransactionStatuses(transactionHash: string[]): Promise<AirGapTransactionStatus[]>;
    estimateMaxTransactionValueFromPublicKey(publicKey: string, recipients: string[], fee?: string | undefined): Promise<string>;
    prepareTransactionFromPublicKey(publicKey: string, recipients: string[], values: string[], fee: string, data?: any): Promise<RawTezosSaplingTransaction>;
    wrapSaplingTransactions(publicKey: string, transactions: TezosSaplingWrappedTransaction[] | string, fee: string, overrideFees?: boolean): Promise<RawTezosTransaction>;
    private prepareTezosOperation;
    prepareShieldTransaction(publicKey: string, recipient: string, value: string, fee: string, data?: {
        overrideFees?: boolean;
    }): Promise<RawTezosTransaction>;
    prepareUnshieldTransaction(viewingKey: string, recipient: string, value: string, data?: any): Promise<RawTezosSaplingTransaction>;
    prepareSaplingTransaction(viewingKey: string, recipient: string, value: string, data?: any): Promise<RawTezosSaplingTransaction>;
    private chooseInputs;
    private preparePartialContractCall;
    private createDummyInput;
    private createDummyOutput;
    private getDummyAddress;
    private getAntiReplay;
    broadcastTransaction(rawTransaction: any): Promise<string>;
    signMessage(message: string, keypair: {
        publicKey?: string | undefined;
        privateKey: Buffer;
    }): Promise<string>;
    verifyMessage(message: string, signature: string, publicKey: string): Promise<boolean>;
    encryptAsymmetric(payload: string, publicKey: string): Promise<string>;
    decryptAsymmetric(encryptedPayload: string, keypair: {
        publicKey?: string | undefined;
        privateKey: Buffer;
    }): Promise<string>;
    encryptAES(payload: string, privateKey: Buffer): Promise<string>;
    decryptAES(encryptedPayload: string, privateKey: Buffer): Promise<string>;
    getBlockExplorerLinkForAddress(address: string): Promise<string>;
    getTransactionsFromAddresses(addresses: string[], limit: number, cursor?: TezosSaplingTransactionCursor): Promise<TezosSaplingTransactionResult>;
    getBalanceOfAddresses(addresses: string[]): Promise<string>;
    getAvailableBalanceOfAddresses(addresses: string[]): Promise<string>;
    getBalanceOfPublicKeyForSubProtocols(publicKey: string, subProtocols: ICoinSubProtocol[]): Promise<string[]>;
    estimateFeeDefaultsFromPublicKey(publicKey: string, recipients: string[], values: string[], data?: any): Promise<FeeDefaults>;
    private isRawTezosSaplingTransaction;
}