import { IBlockchainExplorer, IBlockchainTransferEvent } from './IBlockchainExplorer';
import { IContractDetails } from '../models/IContractDetails';
import { Web3Client } from '../clients/Web3Client';
import { TAddress } from '../models/TAddress';
import { TPlatform } from '../models/TPlatform';
import { TEth } from '../models/TEth';
import { IVerifier } from './verifiers/IVerifier';
import { TExplorer, TExplorerDefinition } from '../models/TExplorer';
/** @deprecated use TExplorerDefinition instead */
export interface IBlockchainExplorerConfig {
    key?: string;
    api?: string;
    host?: string;
    www?: string;
    verification?: boolean | 'fs';
    explorers?: {
        api: string;
        apiKey?: string;
        verification?: boolean | 'fs';
    }[];
}
/** @deprecated use TExplorerDefinition instead */
export interface IBlockchainExplorerFactoryParams extends IBlockchainExplorerConfig {
    platform?: string;
    ABI_CACHE?: string;
    CONTRACTS?: IContractDetails[];
    getWeb3?: (platform?: TPlatform) => Web3Client;
    getConfig?: (platform?: TPlatform) => IBlockchainExplorerConfig;
}
type TxFilter = {
    fromBlockNumber?: number;
    page?: number;
    size?: number;
    sort?: 'asc' | 'desc';
};
export declare class BlockchainExplorer implements IBlockchainExplorer {
    client: HttpClient;
    inMemoryDb: IContractDetails[];
    fsVerification: IVerifier;
    config: TExplorer;
    platform: TPlatform;
    getWeb3: (platform: any) => Web3Client;
    constructor(config: TExplorerDefinition);
    constructor(opts: IBlockchainExplorerFactoryParams);
    getContractMeta(name: string): any;
    getContractMeta(address: string): any;
    private formatUri;
    getContractCreation(address: TAddress): Promise<{
        creator: TAddress;
        txHash: TEth.Hex;
    }>;
    getContractAbi(address: TAddress, params?: {
        implementation: TAddress | string;
    }): Promise<{
        abi: string;
        implementation: TAddress;
    }>;
    submitContractVerification(contractData: {
        address: TAddress;
        sourceCode: string | any;
        contractName: any;
        compilerVersion: any;
        optimizer?: {
            enabled?: boolean;
            runs: number;
        };
        arguments: TEth.Hex;
    }): Promise<any>;
    checkContractVerificationSubmission(submission: {
        guid: any;
    }): Promise<any>;
    submitContractProxyVerification(contractData: {
        address: TEth.Address;
        expectedImplementation?: TEth.Address;
    }): Promise<string>;
    checkContractProxyVerificationSubmission(submission: {
        guid: any;
    }): Promise<string>;
    getContractSource(address: string): Promise<{
        SourceCode: {
            contractName: string;
            files: {
                [filename: string]: {
                    content: string;
                };
            };
        };
        ContractName: string;
        ABI: string;
    }>;
    getTransactions(addr: TAddress, params?: TxFilter): Promise<TEth.Tx[]>;
    getTransactionsAll(addr: TAddress, params?: TxFilter): Promise<TEth.Tx[]>;
    getInternalTransactions(addr: TAddress, params?: TxFilter): Promise<TEth.Tx[]>;
    getInternalTransactionsAll(addr: TAddress): Promise<TEth.Tx[]>;
    getErc20Transfers(addr: TAddress, fromBlockNumber?: number): Promise<IBlockchainTransferEvent[]>;
    getErc20TransfersAll(addr: TAddress, fromBlockNumber?: number): Promise<IBlockchainTransferEvent[]>;
    getSimilarContract(address: TAddress): Promise<`0x${string}`>;
    loadTxs(type: 'tokentx' | 'txlistinternal' | 'txlist', address: TAddress, params?: {
        fromBlockNumber?: number;
        page?: number;
        size?: number;
        sort?: 'asc' | 'desc';
    }): Promise<any>;
    loadTxsAll(type: 'tokentx' | 'txlistinternal' | 'txlist', address: TAddress, params?: TxFilter): Promise<TEth.Tx[]>;
    registerAbi(abis: {
        name: any;
        address: any;
        abi: any;
    }[]): Promise<void>;
}
declare class HttpClient {
    get<TOut>(url: string, params?: any): Promise<any>;
    post(url: string, opts: {
        params?: Record<string, any>;
        body: any;
    }): Promise<any>;
    getHtml(url: string): Promise<any>;
    getPaged(url: string): Promise<any[]>;
    private getInner;
    private postInner;
}
export {};