/// <reference types="node" />
import BigNumber from 'bignumber.js';
import { IRequestTracer } from '../../api';
import { IEnterprises } from '../enterprise';
import { Keychain, IKeychains } from '../keychain';
import { IMarkets } from '../market';
import { IPendingApprovals } from '../pendingApproval';
import { InitiateRecoveryOptions } from '../recovery';
import { EcdsaUtils } from '../utils/tss/ecdsa';
import EddsaUtils from '../utils/tss/eddsa';
import { IWallet, IWallets, WalletData } from '../wallet';
import { IWebhooks } from '../webhook/iWebhooks';
import { BaseTokenConfig } from '@bitgo-beta/statics';
export interface Output extends ITransactionRecipient {
    address: string;
    coinName?: string;
    isPayGo?: boolean;
    value?: number;
    wallet?: string;
    walletV1?: string;
    baseAddress?: string;
    enterprise?: string;
    valueString: string;
    data?: string;
    change?: boolean;
}
export declare type Input = {
    derivationIndex?: number;
    value: number;
    address?: string;
    valueString: string;
    chain?: number;
    index?: number;
};
export declare type UnsignedTransaction = {
    serializedTxHex: string;
    signableHex: string;
    feeInfo?: {
        fee: number | BigNumber;
        feeString: string;
    };
    derivationPath: string;
    coinSpecific?: Record<string, unknown>;
    entryValues: any;
    parsedTx: UnsignedParsedTransaction;
};
export interface ExplanationResult extends ITransactionExplanation {
    sequenceId: number;
    type?: string;
    outputs: Output[];
    blockNumber: number | unknown;
}
export interface ITransactionRecipient {
    address: string;
    amount: string | number;
    tokenName?: string;
    memo?: string;
}
export interface ITransactionFee<TAmount = string> {
    fee: TAmount;
    feeRate?: number;
    size?: number;
}
export interface ITransactionExplanation<TFee = any, TAmount = any> {
    displayOrder: string[];
    id: string;
    outputs: ITransactionRecipient[];
    outputAmount: TAmount;
    changeOutputs: ITransactionRecipient[];
    changeAmount: TAmount;
    fee: TFee;
    proxy?: string;
    producers?: string[];
}
export interface KeyPair {
    pub?: string;
    prv: string;
}
export interface IBlsKeyPair extends KeyPair {
    secretShares?: string[];
    chaincode: string;
    seed?: string;
}
export interface VerifyAddressOptions {
    address: string;
    addressType?: string;
    keychains?: {
        pub: string;
    }[];
    error?: string;
    coinSpecific?: AddressCoinSpecific;
    impliedForwarderVersion?: number;
}
export interface TransactionParams {
    recipients?: ITransactionRecipient[];
    walletPassphrase?: string;
    type?: string;
}
export interface AddressVerificationData {
    coinSpecific?: AddressCoinSpecific;
    chain?: number;
    index?: number;
}
export interface VerificationOptions {
    disableNetworking?: boolean;
    keychains?: {
        user?: Keychain;
        backup?: Keychain;
        bitgo?: Keychain;
    };
    addresses?: {
        [address: string]: AddressVerificationData;
    };
    allowPaygoOutput?: boolean;
    considerMigratedFromAddressInternal?: boolean;
}
export interface VerifyTransactionOptions {
    txPrebuild: TransactionPrebuild;
    txParams: TransactionParams;
    wallet: IWallet;
    verification?: VerificationOptions;
    reqId?: IRequestTracer;
    walletType?: 'onchain' | 'tss';
}
export interface SupplementGenerateWalletOptions {
    label: string;
    m: number;
    n: number;
    enterprise?: string;
    disableTransactionNotifications?: boolean;
    gasPrice?: number | string;
    eip1559?: {
        maxFeePerGas: number | string;
        maxPriorityFeePerGas?: number | string;
    };
    walletVersion?: number;
    keys: string[];
    isCold: boolean;
    keySignatures?: {
        backup: string;
        bitgo: string;
    };
    rootPrivateKey?: string;
    disableKRSEmail?: boolean;
    multisigType?: 'tss' | 'onchain' | 'blsdkg';
}
export interface FeeEstimateOptions {
    numBlocks?: number;
    hop?: boolean;
    recipient?: string;
    data?: string;
    amount?: string;
}
export interface ExtraPrebuildParamsOptions {
    [index: string]: unknown;
}
export interface PresignTransactionOptions {
    txPrebuild?: TransactionPrebuild;
    walletData: WalletData;
    tssUtils: EcdsaUtils | EddsaUtils | undefined;
    [index: string]: unknown;
}
export interface PrecreateBitGoOptions {
    [index: string]: unknown;
}
export interface VerifyRecoveryTransactionOptions {
    [index: string]: unknown;
}
export interface ParseTransactionOptions {
    [index: string]: unknown;
}
export interface ParsedTransaction {
    [index: string]: unknown;
}
export declare type UnsignedParsedTransaction = {
    inputs: Input[];
    minerFee: number | string;
    outputs: Output[];
    spendAmount: number | string;
    hasUnvalidatedData?: boolean;
    payGoFee?: number;
    type?: string;
    sequenceId: number;
    id: string;
};
export interface SignTransactionOptions {
    [index: string]: unknown;
}
export interface KeychainsTriplet {
    userKeychain: Keychain;
    backupKeychain: Keychain;
    bitgoKeychain: Keychain;
}
interface BaseSignable {
    wallet?: IWallet;
    buildParams?: any;
    consolidateId?: string;
    txRequestId?: string;
}
export interface TransactionPrebuild extends BaseSignable {
    txBase64?: string;
    txHex?: string;
    txInfo?: unknown;
}
export interface MessagePrebuild extends BaseSignable {
    message: string;
}
export interface AddressCoinSpecific {
    outputScript?: string;
    redeemScript?: string;
    witnessScript?: string;
    baseAddress?: string;
    pendingChainInitialization?: boolean;
    forwarderVersion?: number;
}
export interface FullySignedTransaction {
    txHex: string;
}
export interface HalfSignedUtxoTransaction {
    txHex: string;
}
export interface HalfSignedAccountTransaction {
    halfSigned?: {
        txHex?: string;
        payload?: string;
        txBase64?: string;
    };
}
export interface HalfSignedTransaction extends HalfSignedAccountTransaction {
    halfSigned: {
        recipients: Recipient[];
        expireTime: number;
        contractSequenceId: number;
        sequenceId: number;
        txHex?: never;
    };
}
export interface SignedTransactionRequest {
    txRequestId: string;
}
export interface DeriveKeyWithSeedOptions {
    key: string;
    seed: string;
}
export interface ValidMofNOptions {
    m?: number;
    n?: number;
}
export declare type SignedTransaction = HalfSignedAccountTransaction | HalfSignedUtxoTransaction | FullySignedTransaction | SignedTransactionRequest;
export declare type SignedMessage = SignedTransactionRequest | string;
export interface RecoverWalletTokenOptions {
    tokenContractAddress: string;
    wallet: IWallet;
    recipient: string;
    broadcast?: boolean;
    walletPassphrase?: string;
    prv?: string;
}
export interface Recipient {
    address: string;
    amount: string;
    data?: string;
}
export interface RecoverTokenTransaction {
    halfSigned: {
        recipient: Recipient;
        expireTime: number;
        contractSequenceId: number;
        operationHash: string;
        signature: string;
        gasLimit: number;
        gasPrice: number;
        tokenContractAddress: string;
        walletId: string;
    };
}
export interface TokenEnablementConfig {
    requiresTokenEnablement: boolean;
    supportsMultipleTokenEnablements: boolean;
}
export declare type MPCAlgorithm = 'ecdsa' | 'eddsa';
export interface IBaseCoin {
    type: string;
    tokenConfig?: BaseTokenConfig;
    url(suffix: string): string;
    wallets(): IWallets;
    enterprises(): IEnterprises;
    keychains(): IKeychains;
    webhooks(): IWebhooks;
    pendingApprovals(): IPendingApprovals;
    markets(): IMarkets;
    getChain(): string;
    getFamily(): string;
    getFullName(): string;
    valuelessTransferAllowed(): boolean;
    sweepWithSendMany(): boolean;
    transactionDataAllowed(): boolean;
    allowsAccountConsolidations(): boolean;
    getTokenEnablementConfig(): TokenEnablementConfig;
    supportsTss(): boolean;
    supportsStaking(): boolean;
    supportsBlsDkg(): boolean;
    getBaseFactor(): number | string;
    baseUnitsToBigUnits(baseUnits: string | number): string;
    bigUnitsToBaseUnits(bigUnits: string | number): string;
    signMessage(key: {
        prv: string;
    }, message: string): Promise<Buffer>;
    explainTransaction(options: Record<string, any>): Promise<ITransactionExplanation<any, string | number> | undefined>;
    verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
    verifyAddress(params: VerifyAddressOptions): boolean;
    isWalletAddress(params: VerifyAddressOptions): boolean;
    canonicalAddress(address: string, format: unknown): string;
    supportsBlockTarget(): boolean;
    supportsLightning(): boolean;
    supportsMessageSigning(): boolean;
    supplementGenerateWallet(walletParams: SupplementGenerateWalletOptions, keychains: KeychainsTriplet): Promise<any>;
    getExtraPrebuildParams(buildParams: ExtraPrebuildParamsOptions): Promise<Record<string, unknown>>;
    postProcessPrebuild(prebuildResponse: TransactionPrebuild): Promise<TransactionPrebuild>;
    presignTransaction(params: PresignTransactionOptions): Promise<PresignTransactionOptions>;
    newWalletObject(walletParams: any): IWallet;
    feeEstimate(params: FeeEstimateOptions): Promise<any>;
    deriveKeyWithSeed(params: DeriveKeyWithSeedOptions): {
        key: string;
        derivationPath: string;
    };
    keyIdsForSigning(): number[];
    preCreateBitGo(params: PrecreateBitGoOptions): void;
    initiateRecovery(params: InitiateRecoveryOptions): never;
    parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
    generateKeyPair(seed?: Buffer): KeyPair;
    isValidPub(pub: string): boolean;
    isValidMofNSetup(params: ValidMofNOptions): boolean;
    isValidAddress(address: string): boolean;
    signTransaction(params: SignTransactionOptions): Promise<SignedTransaction>;
    getSignablePayload(serializedTx: string): Promise<Buffer>;
    getMPCAlgorithm(): MPCAlgorithm;
    recoverToken(params: RecoverWalletTokenOptions): Promise<RecoverTokenTransaction>;
}
export {};
//# sourceMappingURL=iBaseCoin.d.ts.map