/**
 * @prettier
 */
import * as request from 'superagent';
import { AuditDecryptedKeyParams, BaseCoin, BitGoBase, Eddsa, KeyPair, MPCAlgorithm, MPCRecoveryOptions, MPCSweepRecoveryOptions, MPCSweepTxs, MPCTx, MPCTxs, MultisigType, ParsedTransaction, ParseTransactionOptions as BaseParseTransactionOptions, SignedTransaction, SignTransactionOptions as BaseSignTransactionOptions, TokenEnablementConfig, TssVerifyAddressOptions, VerifyTransactionOptions } from '@bitgo/sdk-core';
import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo/statics';
import { TransactionExplanation } from './lib/iface';
export interface SignTransactionOptions extends BaseSignTransactionOptions {
    txPrebuild: TransactionPrebuild;
    prv: string;
}
export interface TransactionPrebuild {
    txHex: string;
    key: string;
    blockHash: string;
    nonce: bigint;
}
export interface ExplainTransactionOptions {
    txPrebuild: TransactionPrebuild;
    publicKey: string;
    feeInfo: {
        fee: string;
    };
}
export interface VerifiedTransactionParameters {
    txHex: string;
    prv: string;
    signer: string;
}
export interface NearParseTransactionOptions extends BaseParseTransactionOptions {
    txPrebuild: TransactionPrebuild;
    publicKey: string;
    feeInfo: {
        fee: string;
    };
}
/**
 * Options for verifying NEAR TSS/MPC wallet addresses.
 * Extends base TssVerifyAddressOptions with NEAR-specific fields.
 */
export interface TssVerifyNearAddressOptions extends TssVerifyAddressOptions {
    /** The root address of the wallet (for root address verification) */
    rootAddress?: string;
}
interface TransactionOutput {
    address: string;
    amount: string;
}
interface NearTxBuilderParamsFromNode {
    nonce: bigint;
    blockHash: string;
}
interface NearFeeConfig {
    sendSir: number;
    sendNotSir: number;
    execution: number;
}
interface ProtocolConfigOutput {
    storageAmountPerByte: number;
    transferCost: NearFeeConfig;
    receiptConfig: NearFeeConfig;
}
type TransactionInput = TransactionOutput;
export interface NearParsedTransaction extends ParsedTransaction {
    inputs: TransactionInput[];
    outputs: TransactionOutput[];
}
export type NearTransactionExplanation = TransactionExplanation;
export declare class Near extends BaseCoin {
    protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
    constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
    protected static initialized: boolean;
    protected static MPC: Eddsa;
    protected network: string;
    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
    allowsAccountConsolidations(): boolean;
    /**
     * Flag indicating if this coin supports TSS wallets.
     * @returns {boolean} True if TSS Wallets can be created for this coin
     */
    supportsTss(): boolean;
    /** inherited doc */
    getDefaultMultisigType(): MultisigType;
    /**
     * @inheritDoc
     */
    getTokenEnablementConfig(): TokenEnablementConfig;
    getMPCAlgorithm(): MPCAlgorithm;
    getChain(): string;
    getBaseChain(): string;
    getFamily(): CoinFamily;
    getFullName(): string;
    getBaseFactor(): any;
    /**
     * Flag for sending value of 0
     * @returns {boolean} True if okay to send 0 value, false otherwise
     */
    valuelessTransferAllowed(): boolean;
    /**
     * Generate ed25519 key pair
     *
     * @param seed
     * @returns {Object} object with generated pub, prv
     */
    generateKeyPair(seed?: Buffer): KeyPair;
    /**
     * Return boolean indicating whether input is valid public key for the coin.
     *
     * @param {String} pub the pub to be checked
     * @returns {Boolean} is it valid?
     */
    isValidPub(pub: string): boolean;
    /**
     * Return boolean indicating whether the supplied private key is a valid near private key
     *
     * @param {String} prv the prv to be checked
     * @returns {Boolean} is it valid?
     */
    isValidPrv(prv: string): boolean;
    /**
     * Return boolean indicating whether input is valid public key for the coin
     *
     * @param {String} address the pub to be checked
     * @returns {Boolean} is it valid?
     */
    isValidAddress(address: string): boolean;
    /** @inheritDoc */
    signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer>;
    /**
     * Explain/parse transaction
     * @param params
     */
    explainTransaction(params: ExplainTransactionOptions): Promise<NearTransactionExplanation>;
    verifySignTransactionParams(params: SignTransactionOptions): VerifiedTransactionParameters;
    /**
     * Assemble keychain and half-sign prebuilt transaction
     *
     * @param params
     * @param params.txPrebuild {TransactionPrebuild} prebuild object returned by platform
     * @param params.prv {String} user prv
     * @param callback
     * @returns {Bluebird<SignedTransaction>}
     */
    signTransaction(params: SignTransactionOptions): Promise<SignedTransaction>;
    /**
     * Builds a funds recovery transaction without BitGo
     * @param params
     */
    recover(params: MPCRecoveryOptions): Promise<MPCTx | MPCSweepTxs>;
    /**
     * Function to handle near token recovery
     * @param {MPCRecoveryOptions} params mpc recovery options input
     * @param {Nep141Token} token the token object
     * @param {String} senderAddress sender address
     * @param {String} derivationPath the derivation path
     * @param {Number} idx current index
     * @param {String} bitgoKey bitgo key
     * @param {Boolean} isStorageDepositEnabled flag indicating whether storage deposit is enabled on the receiver
     * @param {BigNumber} availableTokenBalance currently available token balance on the address
     * @param {Boolean} isUnsignedSweep flag indicating whether it is an unsigned sweep
     * @returns {Promise<MPCTx | MPCSweepTxs>}
     */
    private recoverNearToken;
    /**
     * Function to build unsigned sweep transaction
     * @param {TransactionBuilder} txBuilder the near transaction builder
     * @param {String} senderAddress sender address
     * @param {String} receiverAddress the receiver address
     * @param {String} bitgoKey bitgo key
     * @param {Number} index current index
     * @param {String} derivationPath the derivation path
     * @param {BigNumber} netAmount net amount to be recovered
     * @param {BigNumber} netGas net gas required
     * @param {Nep141Token} token optional nep141 token instance
     * @returns {Promise<MPCSweepTxs>}
     */
    private buildUnsignedSweepTransaction;
    /**
     * Function to sign the recovery transaction
     * @param {TransactionBuilder} txBuilder the near transaction builder
     * @param {MPCRecoveryOptions} params mpc recovery options input
     * @param {String} derivationPath the derivation path
     * @param {String} senderAddress the sender address
     * @returns {Promise<String>}
     */
    private signRecoveryTransaction;
    createBroadcastableSweepTransaction(params: MPCSweepRecoveryOptions): Promise<MPCTxs>;
    /**
     * Make a request to one of the public EOS nodes available
     * @param params.payload
     */
    protected getDataFromNode(params: {
        payload?: Record<string, unknown>;
    }): Promise<request.Response>;
    protected getAccessKey({ accountId, bs58EncodedPublicKey, }: {
        accountId: string;
        bs58EncodedPublicKey: string;
    }): Promise<NearTxBuilderParamsFromNode>;
    protected getAccountBalance(accountId: string, storageAmountPerByte: number): Promise<string>;
    /**
     * Function to get the fungible token balance for an account
     * @param {String} accountId account for which the ft balance to be fetched
     * @param tokenContractAddress the token contract address
     * @returns {Promise<String>}
     */
    protected getAccountFungibleTokenBalance(accountId: string, tokenContractAddress: string): Promise<string>;
    /**
     * Function to check if storage deposit is enabled on an address for a token
     * @param {String} accountId account for which the storage balance to be fetched
     * @param tokenContractAddress the token contract address
     * @returns {Promise<Boolean>} true if we find the storage balance, false if response is null
     */
    protected checkIfStorageDepositIsEnabled(accountId: string, tokenContractAddress: string): Promise<boolean>;
    protected getProtocolConfig(): Promise<ProtocolConfigOutput>;
    protected getGasPrice(blockHash: string): Promise<string>;
    protected getPublicNodeUrls(): string[];
    parseTransaction(params: NearParseTransactionOptions): Promise<NearParsedTransaction>;
    /**
     * Verifies if the given address belongs to a TSS wallet for NEAR.
     * For NEAR, the address is the public key directly (implicit accounts).
     *
     * @param {TssVerifyNearAddressOptions} params - Verification parameters
     * @returns {Promise<boolean>} True if address belongs to wallet
     * @throws {UnexpectedAddressError} If address doesn't match derived address
     * @throws {Error} If invalid parameters or root address verification with wrong index
     */
    isWalletAddress(params: TssVerifyNearAddressOptions): Promise<boolean>;
    verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
    private getBuilder;
    /** @inheritDoc */
    auditDecryptedKey({ prv, publicKey, multiSigType }: AuditDecryptedKeyParams): void;
    /**
     * Validates a token enablement transaction by performing checks
     * for NEAR protocol compliance and ensuring txParams matches transaction data.
     *
     * @param transaction - The NEAR transaction object to validate
     * @param explainedTx - The same transaction data in explained format with parsed outputs and metadata
     * @param txParams - The transaction parameters containing recipients and configuration
     * @throws {Error} When any validation check fails, with descriptive error messages
     * @private
     */
    private validateTokenEnablementTransaction;
    private validateSigner;
    private validateBeneficiary;
    private validateRawReceiver;
    private validateTokenOutput;
    private validatePublicKey;
    private validateRawActions;
    private validateTxType;
    protected verifyConsolidationToBaseAddress(explainedTx: TransactionExplanation, baseAddress: string): Promise<void>;
}
export {};
//# sourceMappingURL=near.d.ts.map