import * as ethers from 'ethers';
import { CHAIN_ID } from './constant';
import { ChainInfo, ERC20, Multicall3, TokenAssistant, TokenInfo, BlockInfo, WrappedNative } from './type';
import { BaseLogger, LogLevel } from './util';
import { ContractParser } from './tx';
import { Provider, TransactionReceipt, TransactionResponse } from '@ethersproject/abstract-provider';
import { CallOverrides } from 'ethers';
import { ErrorDescription } from '@ethersproject/abi/lib/interface';
import { EthGasEstimator } from './gasEstimator/estimator';
export interface CallOption {
    waitReceipt?: boolean;
    waitTimeout?: number;
    gasLimitScaler?: number;
    estimateGas?: boolean;
    gasPriceScaler?: number;
    gasEstimator?: EthGasEstimator;
    useSingleton?: boolean;
    loggerOps?: {
        level?: LogLevel;
        logger?: BaseLogger;
    };
}
export interface ContractCallError {
    raw: any;
    code: string;
    msg: string;
    description?: ErrorDescription;
    receipt?: ethers.providers.TransactionReceipt;
    transaction?: ethers.Transaction;
    response?: ethers.providers.TransactionResponse;
    transactionHash?: string;
}
export declare const DEFAULT_CALL_OPTION: CallOption;
export declare class ChainContext {
    private static instances;
    private constructor();
    static getInstance(chanIdOrName: CHAIN_ID | string, option?: CallOption): ChainContext;
    private static newInstance;
    info: ChainInfo;
    provider: Provider;
    wssProvider?: ethers.providers.WebSocketProvider;
    option: Required<CallOption>;
    tokenInfo: Map<string, TokenInfo>;
    addressToName: Map<string, string>;
    nameToAddress: Map<string, string>;
    parsers: Map<string, ContractParser>;
    wrappedNative: WrappedNative;
    tokenAssistant: TokenAssistant;
    multicall3: Multicall3;
    logger: BaseLogger;
    protected _initLogger(option: CallOption): void;
    protected _init(info: ChainInfo, option: CallOption): void;
    static getChainInfo(nameOrId: string | number): ChainInfo;
    setProvider(provider: Provider): void;
    getContractParser(address: string): ContractParser | undefined;
    registerContractParser(address: string, parser: ContractParser): void;
    get chainId(): CHAIN_ID;
    get chainName(): string;
    get nativeToken(): TokenInfo;
    get wrappedNativeToken(): TokenInfo;
    isNativeToken(symbolOrAddress: string): boolean;
    transferNative(signer: ethers.Signer, to: string, value: ethers.BigNumber): Promise<ethers.ethers.ContractTransaction | ethers.ethers.providers.TransactionReceipt>;
    isWrappedNativeToken(symbolOrAddress: string): boolean;
    getSigner(signerId: string): Promise<ethers.Signer>;
    getAddressName(address: string): string;
    getAddress(source: string): Promise<string>;
    registerAddress(address: string, name: string): void;
    private registerTokenInfo;
    getTokenInfo(symbolOrAddress: string): Promise<TokenInfo>;
    balanceOfTokenBatch(tokens: string[], targets: string[], batch?: number, overrides?: CallOverrides): Promise<{
        blockInfo: BlockInfo;
        balances: ethers.ethers.BigNumber[][];
    }>;
    erc20: {
        getContract: (symbolOrAddress: string) => Promise<ERC20>;
        transfer: (signer: ethers.Signer, erc20Id: string, to: string, amount: ethers.BigNumberish, overrides?: ethers.CallOverrides) => Promise<void>;
        transferAll: (signer: ethers.Signer, erc20Id: string, to: string, overrides?: ethers.CallOverrides) => Promise<void>;
        getBalance: (erc20Id: string, user: string, overrides?: ethers.CallOverrides) => Promise<ethers.ethers.BigNumber>;
        getAllowance: (erc20Id: string, owner: string, spender: string, overrides?: ethers.CallOverrides) => Promise<ethers.ethers.BigNumber>;
        balanceAndAllowance: (erc20Id: string, owner: string, spender: string, overrides?: ethers.CallOverrides) => Promise<{
            balance: any;
            allowance: any;
        }>;
        approveIfNeeded: (signer: ethers.Signer, erc20Address: string, spender: string, amount: ethers.BigNumber, targetAllowance?: ethers.ethers.BigNumber, overrides?: ethers.PayableOverrides) => Promise<void>;
    };
    getExplorerTxLink(txHash: string): string;
    getTokenAssistant(): TokenAssistant;
    getMulticall3(): Multicall3;
    retry<T>(func: () => Promise<T>, retryOption?: {
        retries: number;
        onRetry: (error: Error) => void;
    }): Promise<T>;
    send2Txs(signers: ethers.Signer[], rawTxs: ethers.PopulatedTransaction[] | Promise<ethers.PopulatedTransaction>[]): Promise<ethers.ContractTransaction[] | ethers.providers.TransactionReceipt[]>;
    batchSendTxs(signers: ethers.Signer[], rawTxs: ethers.PopulatedTransaction[] | Promise<ethers.PopulatedTransaction>[]): Promise<ethers.ContractTransaction[] | ethers.providers.TransactionReceipt[]>;
    private setGasLimit;
    private setGasPrice;
    getGasPrice(txType?: import("./type").TxType, scale?: number): Promise<ethers.ethers.Overrides>;
    sendTx(signer: ethers.Signer, rawTx: ethers.PopulatedTransaction | Promise<ethers.PopulatedTransaction>): Promise<ethers.ContractTransaction | ethers.providers.TransactionReceipt>;
    handleRequest(rawTx: ethers.PopulatedTransaction): Promise<void>;
    handleResponse(response: TransactionResponse): Promise<void>;
    static getTransactionFee(receipt: TransactionReceipt): number;
    handleReceipt(receipt: TransactionReceipt, gasLimit?: ethers.BigNumberish): Promise<void>;
    formatOverrides(overrides: ethers.PayableOverrides): string;
    formatGas(gasPrice: ethers.BigNumberish): string;
    deployContract(signer: ethers.Signer, _interface: ethers.utils.Interface, deploymentCode: string, constructorArgs: any[], overrides?: ethers.PayableOverrides): Promise<string>;
    close(): Promise<void>;
    normalizeError(e: any): Promise<ContractCallError>;
}
//# sourceMappingURL=chainContext.d.ts.map