ethers.js/dist/ethers.d.ts

// Generated by dts-bundle v0.7.3

declare module 'ethers' {
    import { Contract, Interface } from 'ethers/contracts';
    import * as providers from 'ethers/providers';
    import { getNetwork } from 'ethers/providers/networks';
    import * as utils from 'ethers/utils';
    import { HDNode, SigningKey, Wallet } from 'ethers/wallet';
    import * as wordlists from 'ethers/wordlists';
    import * as types from 'ethers/utils/types';
    import * as errors from 'ethers/utils/errors';
    import { version } from 'ethers/_version';
    const constants: {
        AddressZero: string;
        HashZero: string;
        NegativeOne: utils.BigNumber;
        Zero: utils.BigNumber;
        One: utils.BigNumber;
        Two: utils.BigNumber;
        WeiPerEther: utils.BigNumber;
    };
    export { Wallet, HDNode, SigningKey, Contract, Interface, getNetwork, providers, types, errors, constants, utils, wordlists, version };
    const _default: {
        Wallet: typeof Wallet;
        HDNode: typeof HDNode;
        SigningKey: typeof SigningKey;
        Contract: typeof Contract;
        Interface: typeof Interface;
        getNetwork: typeof getNetwork;
        providers: typeof providers;
        types: typeof types;
        errors: typeof utils.errors;
        constants: {
            AddressZero: string;
            HashZero: string;
            NegativeOne: utils.BigNumber;
            Zero: utils.BigNumber;
            One: utils.BigNumber;
            Two: utils.BigNumber;
            WeiPerEther: utils.BigNumber;
        };
        utils: typeof utils;
        wordlists: typeof wordlists;
        version: string;
    };
    export default _default;
}

declare module 'ethers/contracts' {
    import { Contract } from 'ethers/contracts/contract';
    import { Interface } from 'ethers/contracts/interface';
    export { Contract, Interface };
}

declare module 'ethers/providers' {
    import { Provider } from 'ethers/providers/provider';
    import { EtherscanProvider } from 'ethers/providers/etherscan-provider';
    import { FallbackProvider } from 'ethers/providers/fallback-provider';
    import { IpcProvider } from 'ethers/providers/ipc-provider';
    import { InfuraProvider } from 'ethers/providers/infura-provider';
    import { JsonRpcProvider, JsonRpcSigner } from 'ethers/providers/json-rpc-provider';
    import { Web3Provider } from 'ethers/providers/web3-provider';
    import { Network } from 'ethers/utils/types';
    function getDefaultProvider(network?: Network | string): FallbackProvider;
    export { Provider, getDefaultProvider, FallbackProvider, EtherscanProvider, InfuraProvider, JsonRpcProvider, Web3Provider, IpcProvider, JsonRpcSigner };
}

declare module 'ethers/providers/networks' {
    import { Network, Networkish } from 'ethers/utils/types';
    export { Network, Networkish };
    /**
      *  getNetwork
      *
      *  Converts a named common networks or chain ID (network ID) to a Network
      *  and verifies a network is a valid Network..
      */
    export function getNetwork(network: Networkish): Network;
}

declare module 'ethers/utils' {
    import { getAddress, getContractAddress, getIcapAddress } from 'ethers/utils/address';
    import { AbiCoder, defaultAbiCoder, formatSignature, formatParamType, parseSignature, parseParamType } from 'ethers/utils/abi-coder';
    import * as base64 from 'ethers/utils/base64';
    import { BigNumber, bigNumberify } from 'ethers/utils/bignumber';
    import { arrayify, concat, hexDataSlice, hexDataLength, hexlify, hexStripZeros, hexZeroPad, joinSignature, padZeros, splitSignature, stripZeros } from 'ethers/utils/bytes';
    import { hashMessage, id, namehash } from 'ethers/utils/hash';
    import { keccak256 } from 'ethers/utils/keccak256';
    import { sha256 } from 'ethers/utils/sha2';
    import { keccak256 as solidityKeccak256, pack as solidityPack, sha256 as soliditySha256 } from 'ethers/utils/solidity';
    import { randomBytes } from 'ethers/utils/random-bytes';
    import { defineFrozen, defineReadOnly, resolveProperties, shallowCopy } from 'ethers/utils/properties';
    import * as RLP from 'ethers/utils/rlp';
    import { parse as parseTransaction, serialize as serializeTransaction } from 'ethers/utils/transaction';
    import { toUtf8Bytes, toUtf8String } from 'ethers/utils/utf8';
    import { formatEther, parseEther, formatUnits, parseUnits } from 'ethers/utils/units';
    import { fetchJson } from 'ethers/utils/web';
    import * as errors from 'ethers/utils/errors';
    const etherSymbol = "\u039E";
    const constants: {
        AddressZero: string;
        HashZero: string;
        NegativeOne: BigNumber;
        Zero: BigNumber;
        One: BigNumber;
        Two: BigNumber;
        WeiPerEther: BigNumber;
    };
    export { AbiCoder, defaultAbiCoder, formatSignature, formatParamType, parseSignature, parseParamType, constants, RLP, fetchJson, defineReadOnly, defineFrozen, resolveProperties, shallowCopy, etherSymbol, arrayify, concat, padZeros, stripZeros, base64, bigNumberify, BigNumber, hexlify, hexStripZeros, hexZeroPad, hexDataLength, hexDataSlice, toUtf8Bytes, toUtf8String, hashMessage, namehash, id, getAddress, getIcapAddress, getContractAddress, formatEther, parseEther, formatUnits, parseUnits, keccak256, sha256, randomBytes, solidityPack, solidityKeccak256, soliditySha256, splitSignature, joinSignature, parseTransaction, serializeTransaction, errors };
}

declare module 'ethers/wallet' {
    import { Wallet } from 'ethers/wallet/wallet';
    import * as HDNode from 'ethers/wallet/hdnode';
    import { SigningKey } from 'ethers/wallet/signing-key';
    export { HDNode, SigningKey, Wallet };
}

declare module 'ethers/wordlists' {
    import { Wordlist } from 'ethers/wordlists/wordlist';
    const en: Wordlist;
    const ko: Wordlist;
    const it: Wordlist;
    const ja: Wordlist;
    const zh: Wordlist;
    const zh_cn: Wordlist;
    const zh_tw: Wordlist;
    export { en, it, ja, ko, zh, zh_cn, zh_tw };
    const _default: {
        en: Wordlist;
        it: Wordlist;
        ja: Wordlist;
        ko: Wordlist;
        zh: Wordlist;
        zh_cn: Wordlist;
        zh_tw: Wordlist;
    };
    export default _default;
}

declare module 'ethers/utils/types' {
    export type Arrayish = string | ArrayLike<number>;
    export interface BigNumber {
            fromTwos(value: number): BigNumber;
            toTwos(value: number): BigNumber;
            add(other: BigNumberish): BigNumber;
            sub(other: BigNumberish): BigNumber;
            div(other: BigNumberish): BigNumber;
            mul(other: BigNumberish): BigNumber;
            mod(other: BigNumberish): BigNumber;
            pow(other: BigNumberish): BigNumber;
            maskn(value: number): BigNumber;
            eq(other: BigNumberish): boolean;
            lt(other: BigNumberish): boolean;
            lte(other: BigNumberish): boolean;
            gt(other: BigNumberish): boolean;
            gte(other: BigNumberish): boolean;
            isZero(): boolean;
            toNumber(): number;
            toString(): string;
            toHexString(): string;
    }
    export type BigNumberish = BigNumber | string | number | Arrayish;
    export type ConnectionInfo = {
            url: string;
            user?: string;
            password?: string;
            allowInsecure?: boolean;
    };
    export type SupportedAlgorithms = 'sha256' | 'sha512';
    export interface Signature {
            r: string;
            s: string;
            recoveryParam: number;
            v?: number;
    }
    export type Network = {
            name: string;
            chainId: number;
            ensAddress?: string;
    };
    export type Networkish = Network | string | number;
    export type CoerceFunc = (type: string, value: any) => any;
    export type ParamType = {
            name?: string;
            type: string;
            indexed?: boolean;
            components?: Array<any>;
    };
    export type EventFragment = {
            type: string;
            name: string;
            anonymous: boolean;
            inputs: Array<ParamType>;
    };
    export type FunctionFragment = {
            type: string;
            name: string;
            constant: boolean;
            inputs: Array<ParamType>;
            outputs: Array<ParamType>;
            payable: boolean;
            stateMutability: string;
    };
    export type UnsignedTransaction = {
            to?: string;
            nonce?: number;
            gasLimit?: BigNumberish;
            gasPrice?: BigNumberish;
            data?: Arrayish;
            value?: BigNumberish;
            chainId?: number;
    };
    export interface Transaction {
            hash?: string;
            to?: string;
            from?: string;
            nonce: number;
            gasLimit: BigNumber;
            gasPrice: BigNumber;
            data: string;
            value: BigNumber;
            chainId: number;
            r?: string;
            s?: string;
            v?: number;
    }
    export type BlockTag = string | number;
    export interface Block {
            hash: string;
            parentHash: string;
            number: number;
            timestamp: number;
            nonce: string;
            difficulty: number;
            gasLimit: BigNumber;
            gasUsed: BigNumber;
            miner: string;
            extraData: string;
            transactions: Array<string>;
    }
    export type Filter = {
            fromBlock?: BlockTag;
            toBlock?: BlockTag;
            address?: string;
            topics?: Array<string | Array<string>>;
    };
    export interface Log {
            blockNumber?: number;
            blockHash?: string;
            transactionIndex?: number;
            removed?: boolean;
            transactionLogIndex?: number;
            address: string;
            data: string;
            topics: Array<string>;
            transactionHash?: string;
            logIndex?: number;
    }
    export interface TransactionReceipt {
            contractAddress?: string;
            transactionIndex?: number;
            root?: string;
            gasUsed?: BigNumber;
            logsBloom?: string;
            blockHash?: string;
            transactionHash?: string;
            logs?: Array<Log>;
            blockNumber?: number;
            cumulativeGasUsed?: BigNumber;
            byzantium: boolean;
            status?: number;
    }
    export type TransactionRequest = {
            to?: string | Promise<string>;
            from?: string | Promise<string>;
            nonce?: number | string | Promise<number | string>;
            gasLimit?: BigNumberish | Promise<BigNumberish>;
            gasPrice?: BigNumberish | Promise<BigNumberish>;
            data?: Arrayish | Promise<Arrayish>;
            value?: BigNumberish | Promise<BigNumberish>;
            chainId?: number | Promise<number>;
    };
    export interface TransactionResponse extends Transaction {
            blockNumber?: number;
            blockHash?: string;
            timestamp?: number;
            from: string;
            raw?: string;
            wait: (timeout?: number) => Promise<TransactionReceipt>;
    }
    export class Indexed {
            hash: string;
    }
    export interface DeployDescription {
            type: "deploy";
            inputs: Array<ParamType>;
            payable: boolean;
            encode(bytecode: string, params: Array<any>): string;
    }
    export interface FunctionDescription {
            type: "call" | "transaction";
            name: string;
            signature: string;
            sighash: string;
            inputs: Array<ParamType>;
            outputs: Array<ParamType>;
            payable: boolean;
            encode(params: Array<any>): string;
            decode(data: string): any;
    }
    export interface EventDescription {
            type: "event";
            name: string;
            signature: string;
            inputs: Array<ParamType>;
            anonymous: boolean;
            topic: string;
            encodeTopics(params: Array<any>): Array<string>;
            decode(data: string, topics?: Array<string>): any;
    }
    export type EventFilter = {
            address?: string;
            topics?: Array<string>;
    };
    export interface Event extends Log {
            args: Array<any>;
            decode: (data: string, topics?: Array<string>) => any;
            event: string;
            eventSignature: string;
            removeListener: () => void;
            getBlock: () => Promise<Block>;
            getTransaction: () => Promise<TransactionResponse>;
            getTransactionReceipt: () => Promise<TransactionReceipt>;
    }
    export type EventType = string | Array<string> | Filter;
    export type Listener = (...args: Array<any>) => void;
    /**
        *  Provider
        *
        *  Note: We use an abstract class so we can use instanceof to determine if an
        *        object is a Provider.
        */
    export abstract class MinimalProvider {
            abstract getNetwork(): Promise<Network>;
            abstract getBlockNumber(): Promise<number>;
            abstract getGasPrice(): Promise<BigNumber>;
            abstract getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
            abstract getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
            abstract getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
            abstract getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
            abstract sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
            abstract call(transaction: TransactionRequest): Promise<string>;
            abstract estimateGas(transaction: TransactionRequest): Promise<BigNumber>;
            abstract getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
            abstract getTransaction(transactionHash: string): Promise<TransactionResponse>;
            abstract getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt>;
            abstract getLogs(filter: Filter): Promise<Array<Log>>;
            abstract resolveName(name: string | Promise<string>): Promise<string>;
            abstract lookupAddress(address: string | Promise<string>): Promise<string>;
            abstract on(eventName: EventType, listener: Listener): MinimalProvider;
            abstract once(eventName: EventType, listener: Listener): MinimalProvider;
            abstract listenerCount(eventName?: EventType): number;
            abstract listeners(eventName: EventType): Array<Listener>;
            abstract removeAllListeners(eventName: EventType): MinimalProvider;
            abstract removeListener(eventName: EventType, listener: Listener): MinimalProvider;
            abstract waitForTransaction(transactionHash: string, timeout?: number): Promise<TransactionReceipt>;
    }
    export type AsyncProvider = {
            isMetaMask: boolean;
            host?: string;
            path?: string;
            sendAsync: (request: any, callback: (error: any, response: any) => void) => void;
    };
    export type ProgressCallback = (percent: number) => void;
    export type EncryptOptions = {
            iv?: Arrayish;
            entropy?: Arrayish;
            mnemonic?: string;
            path?: string;
            client?: string;
            salt?: Arrayish;
            uuid?: string;
            scrypt?: {
                    N?: number;
                    r?: number;
                    p?: number;
            };
    };
    /**
        *  Signer
        *
        *  Note: We use an abstract class so we can use instanceof to determine if an
        *        object is a Signer.
        */
    export abstract class Signer {
            provider?: MinimalProvider;
            abstract getAddress(): Promise<string>;
            abstract signMessage(transaction: Arrayish | string): Promise<string>;
            abstract sendTransaction(transaction: TransactionRequest): Promise<TransactionResponse>;
    }
    export interface Wordlist {
            locale: string;
            getWord(index: number): string;
            getWordIndex(word: string): number;
            split(mnemonic: string): Array<string>;
            join(words: Array<string>): string;
    }
}

declare module 'ethers/utils/errors' {
    export const UNKNOWN_ERROR = "UNKNOWN_ERROR";
    export const NOT_IMPLEMENTED = "NOT_IMPLEMENTED";
    export const MISSING_NEW = "MISSING_NEW";
    export const CALL_EXCEPTION = "CALL_EXCEPTION";
    export const INVALID_ARGUMENT = "INVALID_ARGUMENT";
    export const MISSING_ARGUMENT = "MISSING_ARGUMENT";
    export const UNEXPECTED_ARGUMENT = "UNEXPECTED_ARGUMENT";
    export const NUMERIC_FAULT = "NUMERIC_FAULT";
    export const UNSUPPORTED_OPERATION = "UNSUPPORTED_OPERATION";
    export function throwError(message: string, code: string, params: any): never;
    export function checkNew(self: any, kind: any): void;
    export function checkArgumentCount(count: number, expectedCount: number, suffix?: string): void;
    export function setCensorship(censorship: boolean, permanent?: boolean): void;
}

declare module 'ethers/_version' {
    export const version = "4.0.0";
}

declare module 'ethers/contracts/contract' {
    import { Interface } from 'ethers/contracts/interface';
    import { ParamType } from 'ethers/utils/abi-coder';
    import { BigNumber } from 'ethers/utils/bignumber';
    import { MinimalProvider, Signer } from 'ethers/utils/types';
    import { EventDescription, EventFilter, Listener, Log, TransactionRequest, TransactionResponse } from 'ethers/utils/types';
    interface Bucket<T> {
        [name: string]: T;
    }
    type _EventFilter = {
        decode: (log: Log) => Array<any>;
        event?: EventDescription;
        eventTag: string;
        filter: EventFilter;
    };
    export class Contract {
        readonly address: string;
        readonly interface: Interface;
        readonly signer: Signer;
        readonly provider: MinimalProvider;
        readonly estimate: Bucket<(...params: Array<any>) => Promise<BigNumber>>;
        readonly functions: Bucket<(...params: Array<any>) => Promise<any>>;
        readonly filters: Bucket<(...params: Array<any>) => EventFilter>;
        readonly addressPromise: Promise<string>;
        readonly deployTransaction: TransactionResponse;
        constructor(addressOrName: string, contractInterface: Array<string | ParamType> | string | Interface, signerOrProvider: Signer | MinimalProvider);
        deployed(): Promise<Contract>;
        fallback(overrides?: TransactionRequest): Promise<TransactionResponse>;
        connect(signerOrProvider: Signer | MinimalProvider): Contract;
        attach(addressOrName: string): Contract;
        deploy(bytecode: string, ...args: Array<any>): Promise<Contract>;
        _getEventFilter(eventName: EventFilter | string): _EventFilter;
        _addEventListener(eventFilter: _EventFilter, listener: Listener, once: boolean): void;
        on(event: EventFilter | string, listener: Listener): Contract;
        once(event: EventFilter | string, listener: Listener): Contract;
        addEventLisener(eventName: EventFilter | string, listener: Listener): Contract;
        emit(eventName: EventFilter | string, ...args: Array<any>): boolean;
        listenerCount(eventName?: EventFilter | string): number;
        listeners(eventName: EventFilter | string): Array<Listener>;
        removeAllListeners(eventName: EventFilter | string): Contract;
        removeListener(eventName: any, listener: Listener): Contract;
    }
    export {};
}

declare module 'ethers/contracts/interface' {
    import { EventFragment, FunctionFragment, ParamType } from 'ethers/utils/abi-coder';
    import { BigNumber, BigNumberish } from 'ethers/utils/bignumber';
    import { DeployDescription, EventDescription, FunctionDescription } from 'ethers/utils/types';
    class _Description {
        readonly type: string;
        constructor(info: any);
    }
    class TransactionDescription extends _Description {
        readonly name: string;
        readonly args: Array<any>;
        readonly signature: string;
        readonly sighash: string;
        readonly decode: (data: string) => any;
        readonly value: BigNumber;
    }
    class LogDescription extends _Description {
        readonly name: string;
        readonly signature: string;
        readonly topic: string;
        readonly values: Array<any>;
    }
    export class Interface {
        readonly abi: Array<EventFragment | FunctionFragment>;
        readonly functions: {
            [name: string]: FunctionDescription;
        };
        readonly events: {
            [name: string]: EventDescription;
        };
        readonly deployFunction: DeployDescription;
        constructor(abi: Array<string | ParamType> | string);
        parseTransaction(tx: {
            data: string;
            value?: BigNumberish;
        }): TransactionDescription;
        parseLog(log: {
            topics: Array<string>;
            data: string;
        }): LogDescription;
    }
    export {};
}

declare module 'ethers/providers/provider' {
    import { Network, Networkish } from 'ethers/providers/networks';
    import { BigNumber, BigNumberish } from 'ethers/utils/bignumber';
    import { Transaction } from 'ethers/utils/transaction';
    import { MinimalProvider } from 'ethers/utils/types';
    import { Block, BlockTag, EventType, Filter, Listener, Log, TransactionReceipt, TransactionRequest, TransactionResponse } from 'ethers/utils/types';
    export class Provider extends MinimalProvider {
        protected _emitted: any;
        /**
          *  ready
          *
          *  A Promise<Network> that resolves only once the provider is ready.
          *
          *  Sub-classes that call the super with a network without a chainId
          *  MUST set this. Standard named networks have a known chainId.
          *
          */
        protected ready: Promise<Network>;
        constructor(network: Networkish | Promise<Network>);
        resetEventsBlock(blockNumber: number): void;
        readonly network: Network;
        getNetwork(): Promise<Network>;
        readonly blockNumber: number;
        polling: boolean;
        pollingInterval: number;
        waitForTransaction(transactionHash: string, timeout?: number): Promise<TransactionReceipt>;
        getBlockNumber(): Promise<number>;
        getGasPrice(): Promise<BigNumber>;
        getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
        getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
        getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
        getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
        sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
        _wrapTransaction(tx: Transaction, hash?: string): TransactionResponse;
        call(transaction: TransactionRequest): Promise<string>;
        estimateGas(transaction: TransactionRequest): Promise<BigNumber>;
        getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
        getTransaction(transactionHash: string): Promise<TransactionResponse>;
        getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt>;
        getLogs(filter: Filter): Promise<Array<Log>>;
        getEtherPrice(): Promise<number>;
        _resolveNames(object: any, keys: Array<string>): Promise<{
            [key: string]: string;
        }>;
        _getResolver(name: string): Promise<string>;
        resolveName(name: string | Promise<string>): Promise<string>;
        lookupAddress(address: string | Promise<string>): Promise<string>;
        static checkTransactionResponse(transaction: any): TransactionResponse;
        doPoll(): void;
        perform(method: string, params: any): Promise<any>;
        _startPending(): void;
        _stopPending(): void;
        _addEventListener(eventName: EventType, listener: Listener, once: boolean): void;
        on(eventName: EventType, listener: Listener): Provider;
        once(eventName: EventType, listener: Listener): Provider;
        addEventListener(eventName: EventType, listener: Listener): Provider;
        emit(eventName: EventType, ...args: Array<any>): boolean;
        listenerCount(eventName?: EventType): number;
        listeners(eventName: EventType): Array<Listener>;
        removeAllListeners(eventName: EventType): Provider;
        removeListener(eventName: EventType, listener: Listener): Provider;
    }
}

declare module 'ethers/providers/etherscan-provider' {
    import { Provider } from 'ethers/providers/provider';
    import { BlockTag, Networkish, TransactionResponse } from 'ethers/utils/types';
    export class EtherscanProvider extends Provider {
        readonly baseUrl: string;
        readonly apiKey: string;
        constructor(network?: Networkish, apiKey?: string);
        perform(method: string, params: any): Promise<any>;
        getHistory(addressOrName: string | Promise<string>, startBlock?: BlockTag, endBlock?: BlockTag): Promise<Array<TransactionResponse>>;
    }
}

declare module 'ethers/providers/fallback-provider' {
    import { Provider } from 'ethers/providers/provider';
    export class FallbackProvider extends Provider {
        constructor(providers: Array<Provider>);
        readonly providers: Array<Provider>;
        perform(method: string, params: any): any;
    }
}

declare module 'ethers/providers/ipc-provider' {
    import { JsonRpcProvider } from 'ethers/providers/json-rpc-provider';
    import { Networkish } from 'ethers/utils/types';
    export class IpcProvider extends JsonRpcProvider {
        readonly path: string;
        constructor(path: string, network?: Networkish);
        send(method: string, params: any): Promise<any>;
    }
}

declare module 'ethers/providers/infura-provider' {
    import { JsonRpcProvider, JsonRpcSigner } from 'ethers/providers/json-rpc-provider';
    import { Networkish } from 'ethers/utils/types';
    export class InfuraProvider extends JsonRpcProvider {
        readonly apiAccessToken: string;
        constructor(network?: Networkish, apiAccessToken?: string);
        _startPending(): void;
        getSigner(address?: string): JsonRpcSigner;
        listAccounts(): Promise<Array<string>>;
    }
}

declare module 'ethers/providers/json-rpc-provider' {
    import { Provider } from 'ethers/providers/provider';
    import { BigNumber } from 'ethers/utils/bignumber';
    import { Arrayish } from 'ethers/utils/bytes';
    import { BlockTag, Networkish, Signer, TransactionRequest, TransactionResponse } from 'ethers/utils/types';
    import { ConnectionInfo } from 'ethers/utils/web';
    export class JsonRpcSigner extends Signer {
        readonly provider: JsonRpcProvider;
        constructor(provider: JsonRpcProvider, address?: string);
        readonly address: string;
        getAddress(): Promise<string>;
        getBalance(blockTag?: BlockTag): Promise<BigNumber>;
        getTransactionCount(blockTag?: BlockTag): Promise<number>;
        sendTransaction(transaction: TransactionRequest): Promise<TransactionResponse>;
        signMessage(message: Arrayish | string): Promise<string>;
        unlock(password: string): Promise<boolean>;
    }
    export class JsonRpcProvider extends Provider {
        readonly connection: ConnectionInfo;
        constructor(url?: ConnectionInfo | string, network?: Networkish);
        getSigner(address?: string): JsonRpcSigner;
        listAccounts(): Promise<Array<string>>;
        send(method: string, params: any): Promise<any>;
        perform(method: string, params: any): Promise<any>;
        _startPending(): void;
        _stopPending(): void;
        static hexlifyTransaction(transaction: TransactionRequest): any;
    }
}

declare module 'ethers/providers/web3-provider' {
    import { Networkish } from 'ethers/providers/networks';
    import { JsonRpcProvider } from 'ethers/providers/json-rpc-provider';
    import { AsyncProvider } from 'ethers/utils/types';
    export class Web3Provider extends JsonRpcProvider {
        readonly _web3Provider: AsyncProvider;
        constructor(web3Provider: AsyncProvider, network?: Networkish);
        send(method: string, params: any): Promise<any>;
    }
}

declare module 'ethers/utils/address' {
    import { BigNumber } from 'ethers/utils/bignumber';
    import { Arrayish } from 'ethers/utils/bytes';
    export function getAddress(address: string): string;
    export function getIcapAddress(address: string): string;
    export function getContractAddress(transaction: {
        from: string;
        nonce: Arrayish | BigNumber | number;
    }): string;
}

declare module 'ethers/utils/abi-coder' {
    import { Arrayish } from 'ethers/utils/bytes';
    import { CoerceFunc, EventFragment, FunctionFragment, ParamType } from 'ethers/utils/types';
    export { CoerceFunc, EventFragment, FunctionFragment, ParamType };
    export const defaultCoerceFunc: CoerceFunc;
    export function parseParamType(type: string): ParamType;
    export function formatParamType(paramType: ParamType): string;
    export function formatSignature(fragment: EventFragment | FunctionFragment): string;
    export function parseSignature(fragment: string): EventFragment | FunctionFragment;
    export class AbiCoder {
        readonly coerceFunc: CoerceFunc;
        constructor(coerceFunc?: CoerceFunc);
        encode(types: Array<string | ParamType>, values: Array<any>): string;
        decode(types: Array<string | ParamType>, data: Arrayish): Array<any>;
    }
    export const defaultAbiCoder: AbiCoder;
}

declare module 'ethers/utils/base64' {
    import { Arrayish } from 'ethers/utils/bytes';
    export function decode(textData: string): Uint8Array;
    export function encode(data: Arrayish): string;
}

declare module 'ethers/utils/bignumber' {
    import { BigNumber, BigNumberish } from 'ethers/utils/types';
    export { BigNumber, BigNumberish };
    export function isBigNumber(value: any): boolean;
    export function bigNumberify(value: BigNumberish): BigNumber;
    export const ConstantNegativeOne: BigNumber;
    export const ConstantZero: BigNumber;
    export const ConstantOne: BigNumber;
    export const ConstantTwo: BigNumber;
    export const ConstantWeiPerEther: BigNumber;
}

declare module 'ethers/utils/bytes' {
    /**
      *  Conversion Utilities
      *
      */
    import { BigNumber } from 'ethers/utils/bignumber';
    import { Arrayish, Signature } from 'ethers/utils/types';
    export { Arrayish, Signature };
    export const AddressZero = "0x0000000000000000000000000000000000000000";
    export const HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
    export function isArrayish(value: any): boolean;
    export function arrayify(value: Arrayish | BigNumber): Uint8Array;
    export function concat(objects: Array<Arrayish>): Uint8Array;
    export function stripZeros(value: Arrayish): Uint8Array;
    export function padZeros(value: Arrayish, length: number): Uint8Array;
    export function isHexString(value: any, length?: number): boolean;
    export function hexlify(value: Arrayish | BigNumber | number): string;
    export function hexDataLength(data: string): number;
    export function hexDataSlice(data: string, offset: number, length?: number): string;
    export function hexStripZeros(value: string): string;
    export function hexZeroPad(value: string, length: number): string;
    export function splitSignature(signature: Arrayish | Signature): Signature;
    export function joinSignature(signature: Signature): string;
}

declare module 'ethers/utils/hash' {
    import { Arrayish } from 'ethers/utils/bytes';
    export function namehash(name: string): string;
    export function id(text: string): string;
    export function hashMessage(message: Arrayish | string): string;
}

declare module 'ethers/utils/keccak256' {
    import { Arrayish } from 'ethers/utils/bytes';
    export function keccak256(data: Arrayish): string;
}

declare module 'ethers/utils/sha2' {
    import { Arrayish } from 'ethers/utils/bytes';
    export function sha256(data: Arrayish): string;
    export function sha512(data: Arrayish): string;
}

declare module 'ethers/utils/solidity' {
    export function pack(types: Array<string>, values: Array<any>): string;
    export function keccak256(types: Array<string>, values: Array<any>): string;
    export function sha256(types: Array<string>, values: Array<any>): string;
}

declare module 'ethers/utils/random-bytes' {
    export function randomBytes(length: number): Uint8Array;
}

declare module 'ethers/utils/properties' {
    export function defineReadOnly(object: any, name: string, value: any): void;
    export function defineFrozen(object: any, name: string, value: any): void;
    export function resolveProperties(object: any): Promise<any>;
    export function shallowCopy(object: any): any;
    export function jsonCopy(object: any): any;
}

declare module 'ethers/utils/rlp' {
    import { Arrayish } from 'ethers/utils/bytes';
    export function encode(object: any): string;
    export function decode(data: Arrayish): any;
}

declare module 'ethers/utils/transaction' {
    import { Arrayish, Signature } from 'ethers/utils/bytes';
    import { Transaction, UnsignedTransaction } from 'ethers/utils/types';
    export { Transaction, UnsignedTransaction };
    export function serialize(transaction: UnsignedTransaction, signature?: Arrayish | Signature): string;
    export function parse(rawTransaction: Arrayish): Transaction;
}

declare module 'ethers/utils/utf8' {
    import { Arrayish } from 'ethers/utils/bytes';
    export enum UnicodeNormalizationForm {
        current = "",
        NFC = "NFC",
        NFD = "NFD",
        NFKC = "NFKC",
        NFKD = "NFKD"
    }
    export function toUtf8Bytes(str: string, form?: UnicodeNormalizationForm): Uint8Array;
    export function toUtf8String(bytes: Arrayish): string;
}

declare module 'ethers/utils/units' {
    import { BigNumber, BigNumberish } from 'ethers/utils/bignumber';
    export function formatUnits(value: BigNumberish, unitType?: string | number, options?: any): string;
    export function parseUnits(value: string, unitType?: string | number): BigNumber;
    export function formatEther(wei: BigNumberish, options: any): string;
    export function parseEther(ether: string): BigNumber;
}

declare module 'ethers/utils/web' {
    import { ConnectionInfo } from 'ethers/utils/types';
    export { ConnectionInfo };
    export function fetchJson(connection: string | ConnectionInfo, json: string, processFunc: (value: any) => any): Promise<any>;
    export interface OnceBlockable {
        once(eventName: "block", handler: () => void): void;
    }
    export type PollOptions = {
        timeout?: number;
        floor?: number;
        ceiling?: number;
        interval?: number;
        onceBlock?: OnceBlockable;
    };
    export function poll(func: () => Promise<any>, options?: PollOptions): Promise<any>;
}

declare module 'ethers/wallet/wallet' {
    import { HDNode } from 'ethers/wallet/hdnode';
    import { SigningKey } from 'ethers/wallet/signing-key';
    import { Provider } from 'ethers/providers/provider';
    import { Wordlist } from 'ethers/wordlists/wordlist';
    import { BigNumber } from 'ethers/utils/bignumber';
    import { Arrayish } from 'ethers/utils/bytes';
    import { BlockTag, ProgressCallback, Signer, TransactionRequest, TransactionResponse } from 'ethers/utils/types';
    export class Wallet extends Signer {
            readonly provider: Provider;
            constructor(privateKey: SigningKey | HDNode | Arrayish, provider?: Provider);
            readonly address: string;
            readonly mnemonic: string;
            readonly path: string;
            readonly privateKey: string;
            /**
                *  Create a new instance of this Wallet connected to provider.
                */
            connect(provider: Provider): Wallet;
            getAddress(): Promise<string>;
            sign(transaction: TransactionRequest): Promise<string>;
            signMessage(message: Arrayish | string): Promise<string>;
            getBalance(blockTag?: BlockTag): Promise<BigNumber>;
            getTransactionCount(blockTag?: BlockTag): Promise<number>;
            sendTransaction(transaction: TransactionRequest): Promise<TransactionResponse>;
            encrypt(password: Arrayish | string, options: any, progressCallback: ProgressCallback): Promise<string>;
            /**
                *  Static methods to create Wallet instances.
                */
            static createRandom(options: any): Wallet;
            static fromEncryptedJson(json: string, password: Arrayish, progressCallback: ProgressCallback): Promise<Wallet>;
            static fromMnemonic(mnemonic: string, path?: string, wordlist?: Wordlist): Wallet;
            /**
                *  Determine if this is an encryped JSON wallet.
                */
            static isEncryptedWallet(json: string): boolean;
            /**
                *  Verify a signed message, returning the address of the signer.
                */
            static verifyMessage(message: Arrayish | string, signature: string): string;
    }
}

declare module 'ethers/wallet/hdnode' {
    import { Arrayish } from 'ethers/utils/bytes';
    import { Wordlist } from 'ethers/utils/types';
    export const defaultPath = "m/44'/60'/0'/0/0";
    export class HDNode {
        readonly privateKey: string;
        readonly publicKey: string;
        readonly mnemonic: string;
        readonly path: string;
        readonly chainCode: string;
        readonly index: number;
        readonly depth: number;
        /**
          *  This constructor should not be called directly.
          *
          *  Please use:
          *   - fromMnemonic
          *   - fromSeed
          */
        constructor(privateKey: Arrayish, chainCode: Uint8Array, index: number, depth: number, mnemonic: string, path: string);
        derivePath(path: string): HDNode;
    }
    export function fromMnemonic(mnemonic: string, wordlist?: Wordlist): HDNode;
    export function fromSeed(seed: Arrayish): HDNode;
    export function mnemonicToSeed(mnemonic: string, password?: string): string;
    export function mnemonicToEntropy(mnemonic: string, wordlist?: Wordlist): string;
    export function entropyToMnemonic(entropy: Arrayish, wordlist?: Wordlist): string;
    export function isValidMnemonic(mnemonic: string, wordlist?: Wordlist): boolean;
}

declare module 'ethers/wallet/signing-key' {
    /**
      *  SigningKey
      *
      *
      */
    import { Arrayish, Signature } from 'ethers/utils/bytes';
    import { HDNode } from 'ethers/wallet/hdnode';
    export class SigningKey {
        readonly privateKey: string;
        readonly publicKey: string;
        readonly address: string;
        readonly mnemonic: string;
        readonly path: string;
        constructor(privateKey: Arrayish | HDNode);
        signDigest(digest: Arrayish): Signature;
    }
}

declare module 'ethers/wordlists/wordlist' {
    import { Wordlist as _Wordlist } from 'ethers/utils/types';
    export function check(wordlist: _Wordlist): string;
    export abstract class Wordlist implements _Wordlist {
        locale: string;
        constructor(locale: string);
        abstract getWord(index: number): string;
        abstract getWordIndex(word: string): number;
        split(mnemonic: string): Array<string>;
        join(words: Array<string>): string;
    }
    export function register(lang: Wordlist, name?: string): void;
}