• Version 5.3.1
  • Published
  • 104 kB
  • 6 dependencies
  • Apache-2.0 license


npm i @0x/typescript-typings
yarn add @0x/typescript-typings
pnpm add @0x/typescript-typings


0x project typescript type definitions



namespace @ledgerhq/hw-app-eth

module '@ledgerhq/hw-app-eth' {}

    class Eth

    class Eth {}


      constructor(transport: LedgerTransport);

        property transport

        transport: LedgerTransport;

          method getAddress

          getAddress: (
          path: string,
          boolDisplay?: boolean,
          boolChaincode?: boolean
          ) => Promise<{ publicKey: string; address: string; chainCode: string }>;

            method getAppConfiguration

            getAppConfiguration: () => Promise<{
            arbitraryDataEnabled: number;
            version: string;

              method signPersonalMessage

              signPersonalMessage: (path: string, messageHex: string) => Promise<ECSignature>;

                method signTransaction

                signTransaction: (path: string, rawTxHex: string) => Promise<ECSignatureString>;

                  namespace @ledgerhq/hw-transport-node-hid

                  module '@ledgerhq/hw-transport-node-hid' {}

                    class TransportNodeHid

                    class TransportNodeHid implements LedgerTransport {}

                      method close

                      close: () => Promise<void>;

                        method create

                        static create: () => Promise<LedgerTransport>;

                          namespace @ledgerhq/hw-transport-u2f

                          module '@ledgerhq/hw-transport-u2f' {}

                            class TransportU2F

                            class TransportU2F implements LedgerTransport {}

                              method close

                              close: () => Promise<void>;

                                method create

                                static create: () => Promise<LedgerTransport>;

                                  namespace async-child-process

                                  module 'async-child-process' {}

                                    namespace chai

                                    module 'chai' {}

                                      variable chai

                                      const chai: Chai.ChaiStatic;

                                        namespace chai-as-promised

                                        module 'chai-as-promised' {}

                                          function chaiAsPromised

                                          chaiAsPromised: (chai: any, utils: any) => void;

                                            namespace chai-bignumber

                                            module 'chai-bignumber' {}

                                              namespace cli-format

                                              module 'cli-format' {}

                                                namespace dirty-chai

                                                module 'dirty-chai' {}

                                                  namespace es6-promisify

                                                  module 'es6-promisify' {}

                                                    namespace ethereumjs-abi

                                                    module 'ethereumjs-abi' {}

                                                      function methodID

                                                      methodID: (name: string, types: string[]) => Buffer;

                                                        function rawDecode

                                                        rawDecode: (signature: string[], data: Buffer) => any[];

                                                          function simpleEncode

                                                          simpleEncode: (signature: string, ...args: any[]) => Buffer;

                                                            function soliditySHA256

                                                            soliditySHA256: (argTypes: string[], args: any[]) => Buffer;

                                                              function soliditySHA3

                                                              soliditySHA3: (argTypes: string[], args: any[]) => Buffer;

                                                                namespace ethereumjs-vm

                                                                module 'ethereumjs-vm' {}

                                                                  class Cache

                                                                  class Cache {}


                                                                    constructor(trie: any);

                                                                      method checkpoint

                                                                      checkpoint: () => void;

                                                                        method clear

                                                                        clear: () => void;

                                                                          method commit

                                                                          commit: () => void;

                                                                            method del

                                                                            del: (key: Buffer) => void;

                                                                              method flush

                                                                              flush: (cb: any) => void;

                                                                                method get

                                                                                get: (key: Buffer) => Account;

                                                                                  method getOrLoad

                                                                                  getOrLoad: (key: Buffer, cb: any) => void;

                                                                                    method lookup

                                                                                    lookup: (key: Buffer) => Account | undefined;

                                                                                      method put

                                                                                      put: (key: Buffer, val: Account, fromTrie: boolean) => void;

                                                                                        method revert

                                                                                        revert: () => void;

                                                                                          method warm

                                                                                          warm: (addresses: string[], cb: any) => void;

                                                                                            class EEI

                                                                                            class EEI {}


                                                                                              constructor(env: Env, state: PStateManager, evm: EVM, common: any, gasLeft: BN);

                                                                                                method call

                                                                                                call: (gasLimit: BN, address: Buffer, value: BN, data: Buffer) => Promise<BN>;

                                                                                                  method callCode

                                                                                                  callCode: (
                                                                                                  gasLimit: BN,
                                                                                                  address: Buffer,
                                                                                                  value: BN,
                                                                                                  data: Buffer
                                                                                                  ) => Promise<BN>;

                                                                                                    method callDelegate

                                                                                                    callDelegate: (
                                                                                                    gasLimit: BN,
                                                                                                    address: Buffer,
                                                                                                    value: BN,
                                                                                                    data: Buffer
                                                                                                    ) => Promise<BN>;

                                                                                                      method callStatic

                                                                                                      callStatic: (
                                                                                                      gasLimit: BN,
                                                                                                      address: Buffer,
                                                                                                      value: BN,
                                                                                                      data: Buffer
                                                                                                      ) => Promise<BN>;

                                                                                                        method create

                                                                                                        create: (
                                                                                                        gasLimit: BN,
                                                                                                        value: BN,
                                                                                                        data: Buffer,
                                                                                                        salt: Buffer | null
                                                                                                        ) => Promise<BN>;

                                                                                                          method create2

                                                                                                          create2: (gasLimit: BN, value: BN, data: Buffer, salt: Buffer) => Promise<BN>;

                                                                                                            method finish

                                                                                                            finish: (returnData: Buffer) => void;

                                                                                                              method getAddress

                                                                                                              getAddress: () => Buffer;

                                                                                                                method getBlockCoinbase

                                                                                                                getBlockCoinbase: () => BN;

                                                                                                                  method getBlockDifficulty

                                                                                                                  getBlockDifficulty: () => BN;

                                                                                                                    method getBlockGasLimit

                                                                                                                    getBlockGasLimit: () => BN;

                                                                                                                      method getBlockHash

                                                                                                                      getBlockHash: (num: BN) => Promise<BN>;

                                                                                                                        method getBlockNumber

                                                                                                                        getBlockNumber: () => BN;

                                                                                                                          method getBlockTimestamp

                                                                                                                          getBlockTimestamp: () => BN;

                                                                                                                            method getCallData

                                                                                                                            getCallData: () => Buffer;

                                                                                                                              method getCallDataSize

                                                                                                                              getCallDataSize: () => BN;

                                                                                                                                method getCaller

                                                                                                                                getCaller: () => BN;

                                                                                                                                  method getCallValue

                                                                                                                                  getCallValue: () => BN;

                                                                                                                                    method getChainId

                                                                                                                                    getChainId: () => BN;

                                                                                                                                      method getCode

                                                                                                                                      getCode: () => Buffer;

                                                                                                                                        method getCodeSize

                                                                                                                                        getCodeSize: () => BN;

                                                                                                                                          method getExternalBalance

                                                                                                                                          getExternalBalance: (address: Buffer) => Promise<BN>;

                                                                                                                                            method getExternalCode

                                                                                                                                            getExternalCode: (address: BN | Buffer) => Promise<Buffer>;

                                                                                                                                              method getExternalCodeSize

                                                                                                                                              getExternalCodeSize: (address: BN) => Promise<BN>;

                                                                                                                                                method getGasLeft

                                                                                                                                                getGasLeft: () => BN;

                                                                                                                                                  method getReturnData

                                                                                                                                                  getReturnData: () => Buffer;

                                                                                                                                                    method getReturnDataSize

                                                                                                                                                    getReturnDataSize: () => BN;

                                                                                                                                                      method getSelfBalance

                                                                                                                                                      getSelfBalance: () => BN;

                                                                                                                                                        method getTxGasPrice

                                                                                                                                                        getTxGasPrice: () => BN;

                                                                                                                                                          method getTxOrigin

                                                                                                                                                          getTxOrigin: () => BN;

                                                                                                                                                            method isAccountEmpty

                                                                                                                                                            isAccountEmpty: (address: Buffer) => Promise<boolean>;

                                                                                                                                                              method isStatic

                                                                                                                                                              isStatic: () => boolean;

                                                                                                                                                                method log

                                                                                                                                                                log: (data: Buffer, numberOfTopics: number, topics: Buffer[]) => void;

                                                                                                                                                                  method refundGas

                                                                                                                                                                  refundGas: (amount: BN) => void;

                                                                                                                                                                    method revert

                                                                                                                                                                    revert: (returnData: Buffer) => void;

                                                                                                                                                                      method selfDestruct

                                                                                                                                                                      selfDestruct: (toAddress: Buffer) => Promise<void>;

                                                                                                                                                                        method storageLoad

                                                                                                                                                                        storageLoad: (key: Buffer) => Promise<Buffer>;

                                                                                                                                                                          method storageStore

                                                                                                                                                                          storageStore: (key: Buffer, value: Buffer) => Promise<void>;

                                                                                                                                                                            method useGas

                                                                                                                                                                            useGas: (amount: BN) => void;

                                                                                                                                                                              class EVM

                                                                                                                                                                              class EVM {}


                                                                                                                                                                                constructor(vm: any, txContext: TxContext, block: any);

                                                                                                                                                                                  method executeMessage

                                                                                                                                                                                  executeMessage: (message: Message) => Promise<EVMResult>;

                                                                                                                                                                                    method getPrecompile

                                                                                                                                                                                    getPrecompile: (address: Buffer) => PrecompileFunc;

                                                                                                                                                                                      method runInterpreter

                                                                                                                                                                                      runInterpreter: (message: Message, opts: InterpreterOpts) => Promise<ExecResult>;

                                                                                                                                                                                        method runPrecompile

                                                                                                                                                                                        runPrecompile: (code: PrecompileFunc, data: Buffer, gasLimit: BN) => ExecResult;

                                                                                                                                                                                          class Memory

                                                                                                                                                                                          class Memory {}



                                                                                                                                                                                              method extend

                                                                                                                                                                                              extend: (offset: number, size: number) => void;

                                                                                                                                                                                                method read

                                                                                                                                                                                                read: (offset: number, size: number) => Buffer;

                                                                                                                                                                                                  method write

                                                                                                                                                                                                  write: (offset: number, size: number, value: Buffer) => void;

                                                                                                                                                                                                    class Message

                                                                                                                                                                                                    class Message {}


                                                                                                                                                                                                      constructor(opts: any);

                                                                                                                                                                                                        property caller

                                                                                                                                                                                                        caller: Buffer;

                                                                                                                                                                                                          property code

                                                                                                                                                                                                          code: any;

                                                                                                                                                                                                            property data

                                                                                                                                                                                                            data: Buffer;

                                                                                                                                                                                                              property delegatecall

                                                                                                                                                                                                              delegatecall: boolean;

                                                                                                                                                                                                                property depth

                                                                                                                                                                                                                depth: number;

                                                                                                                                                                                                                  property gasLimit

                                                                                                                                                                                                                  gasLimit: BN;

                                                                                                                                                                                                                    property isCompiled

                                                                                                                                                                                                                    isCompiled: boolean;

                                                                                                                                                                                                                      property isStatic

                                                                                                                                                                                                                      isStatic: boolean;

                                                                                                                                                                                                                        property salt

                                                                                                                                                                                                                        salt: Buffer;

                                                                                                                                                                                                                          property selfdestruct

                                                                                                                                                                                                                          selfdestruct: any;

                                                                                                                                                                                                                            property to

                                                                                                                                                                                                                            to: Buffer;

                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                              value: BN;

                                                                                                                                                                                                                                method codeAddress

                                                                                                                                                                                                                                codeAddress: () => Buffer;

                                                                                                                                                                                                                                  class PStateManager

                                                                                                                                                                                                                                  class PStateManager {}


                                                                                                                                                                                                                                    constructor(wrapped: StateManager);

                                                                                                                                                                                                                                      method accountIsEmpty

                                                                                                                                                                                                                                      accountIsEmpty: (address: Buffer) => Promise<boolean>;

                                                                                                                                                                                                                                        method checkpoint

                                                                                                                                                                                                                                        checkpoint: () => Promise<void>;

                                                                                                                                                                                                                                          method cleanupTouchedAccounts

                                                                                                                                                                                                                                          cleanupTouchedAccounts: () => Promise<void>;

                                                                                                                                                                                                                                            method clearContractStorage

                                                                                                                                                                                                                                            clearContractStorage: (addr: Buffer) => Promise<void>;

                                                                                                                                                                                                                                              method commit

                                                                                                                                                                                                                                              commit: () => Promise<void>;

                                                                                                                                                                                                                                                method copy

                                                                                                                                                                                                                                                copy: () => PStateManager;

                                                                                                                                                                                                                                                  method dumpStorage

                                                                                                                                                                                                                                                  dumpStorage: (address: Buffer) => Promise<StorageDump>;

                                                                                                                                                                                                                                                    method generateCanonicalGenesis

                                                                                                                                                                                                                                                    generateCanonicalGenesis: () => Promise<void>;

                                                                                                                                                                                                                                                      method generateGenesis

                                                                                                                                                                                                                                                      generateGenesis: (initState: any) => Promise<void>;

                                                                                                                                                                                                                                                        method getAccount

                                                                                                                                                                                                                                                        getAccount: (addr: Buffer) => Promise<Account>;

                                                                                                                                                                                                                                                          method getContractCode

                                                                                                                                                                                                                                                          getContractCode: (addr: Buffer) => Promise<Buffer>;

                                                                                                                                                                                                                                                            method getContractStorage

                                                                                                                                                                                                                                                            getContractStorage: (addr: Buffer, key: Buffer) => Promise<any>;

                                                                                                                                                                                                                                                              method getOriginalContractStorage

                                                                                                                                                                                                                                                              getOriginalContractStorage: (addr: Buffer, key: Buffer) => Promise<any>;

                                                                                                                                                                                                                                                                method getStateRoot

                                                                                                                                                                                                                                                                getStateRoot: () => Promise<Buffer>;

                                                                                                                                                                                                                                                                  method hasGenesisState

                                                                                                                                                                                                                                                                  hasGenesisState: () => Promise<boolean>;

                                                                                                                                                                                                                                                                    method putAccount

                                                                                                                                                                                                                                                                    putAccount: (addr: Buffer, account: Account) => Promise<void>;

                                                                                                                                                                                                                                                                      method putContractCode

                                                                                                                                                                                                                                                                      putContractCode: (addr: Buffer, code: Buffer) => Promise<void>;

                                                                                                                                                                                                                                                                        method putContractStorage

                                                                                                                                                                                                                                                                        putContractStorage: (addr: Buffer, key: Buffer, value: Buffer) => Promise<void>;

                                                                                                                                                                                                                                                                          method revert

                                                                                                                                                                                                                                                                          revert: () => Promise<void>;

                                                                                                                                                                                                                                                                            method setStateRoot

                                                                                                                                                                                                                                                                            setStateRoot: (root: Buffer) => Promise<void>;

                                                                                                                                                                                                                                                                              class Stack

                                                                                                                                                                                                                                                                              class Stack {}



                                                                                                                                                                                                                                                                                  method dup

                                                                                                                                                                                                                                                                                  dup: (position: number) => void;

                                                                                                                                                                                                                                                                                    method length

                                                                                                                                                                                                                                                                                    length: () => number;

                                                                                                                                                                                                                                                                                      method pop

                                                                                                                                                                                                                                                                                      pop: () => BN;

                                                                                                                                                                                                                                                                                        method popN

                                                                                                                                                                                                                                                                                        popN: (num: number) => BN[];

                                                                                                                                                                                                                                                                                          method push

                                                                                                                                                                                                                                                                                          push: (value: BN) => void;

                                                                                                                                                                                                                                                                                            method swap

                                                                                                                                                                                                                                                                                            swap: (position: number) => void;

                                                                                                                                                                                                                                                                                              class StateManager

                                                                                                                                                                                                                                                                                              class StateManager {}


                                                                                                                                                                                                                                                                                                constructor(opts: StateManagerOpts);

                                                                                                                                                                                                                                                                                                  method accountIsEmpty

                                                                                                                                                                                                                                                                                                  accountIsEmpty: (address: Buffer, cb: any) => void;

                                                                                                                                                                                                                                                                                                    method checkpoint

                                                                                                                                                                                                                                                                                                    checkpoint: (cb: any) => void;

                                                                                                                                                                                                                                                                                                      method cleanupTouchedAccounts

                                                                                                                                                                                                                                                                                                      cleanupTouchedAccounts: (cb: any) => void;

                                                                                                                                                                                                                                                                                                        method clearContractStorage

                                                                                                                                                                                                                                                                                                        clearContractStorage: (address: Buffer, cb: any) => void;

                                                                                                                                                                                                                                                                                                          method commit

                                                                                                                                                                                                                                                                                                          commit: (cb: any) => void;

                                                                                                                                                                                                                                                                                                            method copy

                                                                                                                                                                                                                                                                                                            copy: () => StateManager;

                                                                                                                                                                                                                                                                                                              method dumpStorage

                                                                                                                                                                                                                                                                                                              dumpStorage: (address: Buffer, cb: any) => void;

                                                                                                                                                                                                                                                                                                                method generateCanonicalGenesis

                                                                                                                                                                                                                                                                                                                generateCanonicalGenesis: (cb: any) => void;

                                                                                                                                                                                                                                                                                                                  method generateGenesis

                                                                                                                                                                                                                                                                                                                  generateGenesis: (initState: any, cb: any) => void;

                                                                                                                                                                                                                                                                                                                    method getAccount

                                                                                                                                                                                                                                                                                                                    getAccount: (address: Buffer, cb: any) => void;

                                                                                                                                                                                                                                                                                                                      method getContractCode

                                                                                                                                                                                                                                                                                                                      getContractCode: (address: Buffer, cb: any) => void;

                                                                                                                                                                                                                                                                                                                        method getContractStorage

                                                                                                                                                                                                                                                                                                                        getContractStorage: (address: Buffer, key: Buffer, cb: any) => void;

                                                                                                                                                                                                                                                                                                                          method getOriginalContractStorage

                                                                                                                                                                                                                                                                                                                          getOriginalContractStorage: (address: Buffer, key: Buffer, cb: any) => void;

                                                                                                                                                                                                                                                                                                                            method getStateRoot

                                                                                                                                                                                                                                                                                                                            getStateRoot: (cb: any) => void;

                                                                                                                                                                                                                                                                                                                              method hasGenesisState

                                                                                                                                                                                                                                                                                                                              hasGenesisState: (cb: any) => void;

                                                                                                                                                                                                                                                                                                                                method putAccount

                                                                                                                                                                                                                                                                                                                                putAccount: (address: Buffer, account: Account, cb: any) => void;

                                                                                                                                                                                                                                                                                                                                  method putContractCode

                                                                                                                                                                                                                                                                                                                                  putContractCode: (address: Buffer, value: Buffer, cb: any) => void;

                                                                                                                                                                                                                                                                                                                                    method putContractStorage

                                                                                                                                                                                                                                                                                                                                    putContractStorage: (
                                                                                                                                                                                                                                                                                                                                    address: Buffer,
                                                                                                                                                                                                                                                                                                                                    key: Buffer,
                                                                                                                                                                                                                                                                                                                                    value: Buffer,
                                                                                                                                                                                                                                                                                                                                    cb: any
                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                      method revert

                                                                                                                                                                                                                                                                                                                                      revert: (cb: any) => void;

                                                                                                                                                                                                                                                                                                                                        method setStateRoot

                                                                                                                                                                                                                                                                                                                                        setStateRoot: (stateRoot: Buffer, cb: any) => void;

                                                                                                                                                                                                                                                                                                                                          method touchAccount

                                                                                                                                                                                                                                                                                                                                          touchAccount: (address: Buffer) => void;

                                                                                                                                                                                                                                                                                                                                            class TxContext

                                                                                                                                                                                                                                                                                                                                            class TxContext {}


                                                                                                                                                                                                                                                                                                                                              constructor(gasPrice: Buffer, origin: Buffer);

                                                                                                                                                                                                                                                                                                                                                property gasPrice

                                                                                                                                                                                                                                                                                                                                                gasPrice: Buffer;

                                                                                                                                                                                                                                                                                                                                                  property origin

                                                                                                                                                                                                                                                                                                                                                  origin: Buffer;

                                                                                                                                                                                                                                                                                                                                                    class VM

                                                                                                                                                                                                                                                                                                                                                    class VM {}


                                                                                                                                                                                                                                                                                                                                                      constructor(opts: VmOpts);

                                                                                                                                                                                                                                                                                                                                                        property opts

                                                                                                                                                                                                                                                                                                                                                        opts: VmOpts;

                                                                                                                                                                                                                                                                                                                                                          property stateManager

                                                                                                                                                                                                                                                                                                                                                          stateManager: StateManager;

                                                                                                                                                                                                                                                                                                                                                            method runCall

                                                                                                                                                                                                                                                                                                                                                            runCall: (opts: RunCallOpts) => Promise<EVMResult>;

                                                                                                                                                                                                                                                                                                                                                              class VmError

                                                                                                                                                                                                                                                                                                                                                              class VmError {}


                                                                                                                                                                                                                                                                                                                                                                constructor(error: ERROR);

                                                                                                                                                                                                                                                                                                                                                                  property error

                                                                                                                                                                                                                                                                                                                                                                  error: ERROR;

                                                                                                                                                                                                                                                                                                                                                                    property errorType

                                                                                                                                                                                                                                                                                                                                                                    errorType: string;

                                                                                                                                                                                                                                                                                                                                                                      interface Env

                                                                                                                                                                                                                                                                                                                                                                      interface Env {}

                                                                                                                                                                                                                                                                                                                                                                        property address

                                                                                                                                                                                                                                                                                                                                                                        address: Buffer;

                                                                                                                                                                                                                                                                                                                                                                          property block

                                                                                                                                                                                                                                                                                                                                                                          block: any;

                                                                                                                                                                                                                                                                                                                                                                            property blockchain

                                                                                                                                                                                                                                                                                                                                                                            blockchain: Blockchain;

                                                                                                                                                                                                                                                                                                                                                                              property callData

                                                                                                                                                                                                                                                                                                                                                                              callData: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                property caller

                                                                                                                                                                                                                                                                                                                                                                                caller: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                  property callValue

                                                                                                                                                                                                                                                                                                                                                                                  callValue: BN;

                                                                                                                                                                                                                                                                                                                                                                                    property code

                                                                                                                                                                                                                                                                                                                                                                                    code: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                      property contract

                                                                                                                                                                                                                                                                                                                                                                                      contract: Account;

                                                                                                                                                                                                                                                                                                                                                                                        property depth

                                                                                                                                                                                                                                                                                                                                                                                        depth: number;

                                                                                                                                                                                                                                                                                                                                                                                          property gasPrice

                                                                                                                                                                                                                                                                                                                                                                                          gasPrice: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                            property isStatic

                                                                                                                                                                                                                                                                                                                                                                                            isStatic: boolean;

                                                                                                                                                                                                                                                                                                                                                                                              property origin

                                                                                                                                                                                                                                                                                                                                                                                              origin: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                interface EVMResult

                                                                                                                                                                                                                                                                                                                                                                                                interface EVMResult {}

                                                                                                                                                                                                                                                                                                                                                                                                  property createdAddress

                                                                                                                                                                                                                                                                                                                                                                                                  createdAddress?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                    property execResult

                                                                                                                                                                                                                                                                                                                                                                                                    execResult: ExecResult;

                                                                                                                                                                                                                                                                                                                                                                                                      property gasUsed

                                                                                                                                                                                                                                                                                                                                                                                                      gasUsed: BN;

                                                                                                                                                                                                                                                                                                                                                                                                        interface ExecResult

                                                                                                                                                                                                                                                                                                                                                                                                        interface ExecResult {}

                                                                                                                                                                                                                                                                                                                                                                                                          property exceptionError

                                                                                                                                                                                                                                                                                                                                                                                                          exceptionError?: VmError;

                                                                                                                                                                                                                                                                                                                                                                                                            property gas

                                                                                                                                                                                                                                                                                                                                                                                                            gas?: BN;

                                                                                                                                                                                                                                                                                                                                                                                                              property gasRefund

                                                                                                                                                                                                                                                                                                                                                                                                              gasRefund?: BN;

                                                                                                                                                                                                                                                                                                                                                                                                                property gasUsed

                                                                                                                                                                                                                                                                                                                                                                                                                gasUsed: BN;

                                                                                                                                                                                                                                                                                                                                                                                                                  property logs

                                                                                                                                                                                                                                                                                                                                                                                                                  logs?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                    property returnValue

                                                                                                                                                                                                                                                                                                                                                                                                                    returnValue: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                      property runState

                                                                                                                                                                                                                                                                                                                                                                                                                      runState?: RunState;

                                                                                                                                                                                                                                                                                                                                                                                                                        property selfdestruct

                                                                                                                                                                                                                                                                                                                                                                                                                        selfdestruct?: { [k: string]: Buffer };

                                                                                                                                                                                                                                                                                                                                                                                                                          interface InterpreterOpts

                                                                                                                                                                                                                                                                                                                                                                                                                          interface InterpreterOpts {}

                                                                                                                                                                                                                                                                                                                                                                                                                            property pc

                                                                                                                                                                                                                                                                                                                                                                                                                            pc?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                              interface PrecompileFunc

                                                                                                                                                                                                                                                                                                                                                                                                                              interface PrecompileFunc {}

                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                (opts: PrecompileInput): ExecResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PrecompileInput

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PrecompileInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                    data: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property gasLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                      gasLimit: BN;

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RunCallOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RunCallOpts {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property block

                                                                                                                                                                                                                                                                                                                                                                                                                                          block?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property caller

                                                                                                                                                                                                                                                                                                                                                                                                                                            caller?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property code

                                                                                                                                                                                                                                                                                                                                                                                                                                              code?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property compiled

                                                                                                                                                                                                                                                                                                                                                                                                                                                compiled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                  data?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property delegatecall

                                                                                                                                                                                                                                                                                                                                                                                                                                                    delegatecall?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property depth

                                                                                                                                                                                                                                                                                                                                                                                                                                                      depth?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property gasLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                        gasLimit?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property gasPrice

                                                                                                                                                                                                                                                                                                                                                                                                                                                          gasPrice?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property origin

                                                                                                                                                                                                                                                                                                                                                                                                                                                            origin?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property salt

                                                                                                                                                                                                                                                                                                                                                                                                                                                              salt?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property selfdestruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                selfdestruct?: { [k: string]: boolean };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property static

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    to?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RunResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RunResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property gasRefund

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          gasRefund: BN;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property logs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            logs: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property returnValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              returnValue?: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property selfdestruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selfdestruct: { [k: string]: Buffer };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RunState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RunState {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    code: Buffer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property eei

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      eei: EEI;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property highestMemCost

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        highestMemCost: BN;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property memory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          memory: Memory;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property memoryWordCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            memoryWordCount: BN;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property opCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opCode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property programCounter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                programCounter: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property stack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stack: Stack;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stateManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stateManager: StateManager;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property validJumps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      validJumps: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface StateManagerOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface StateManagerOpts {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property common

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          common?: Common;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property trie

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            trie?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StorageDump

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StorageDump {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [key: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VmOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VmOpts {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property activatePrecompiles

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    activatePrecompiles?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allowUnlimitedContractSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      allowUnlimitedContractSize?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property blockchain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        blockchain?: Blockchain;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property chain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          chain?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property common

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            common?: Common;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hardfork

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hardfork?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                state?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property stateManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stateManager?: StateManager;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum ERROR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum ERROR {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OUT_OF_GAS = 'out of gas',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    STACK_UNDERFLOW = 'stack underflow',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    STACK_OVERFLOW = 'stack overflow',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INVALID_JUMP = 'invalid JUMP',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INVALID_OPCODE = 'invalid opcode',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    OUT_OF_RANGE = 'value out of range',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    REVERT = 'revert',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    STATIC_STATE_CHANGE = 'static state change',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    INTERNAL_ERROR = 'internal error',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CREATE_COLLISION = 'create collision',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    STOP = 'stop',

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member CREATE_COLLISION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CREATE_COLLISION = 'create collision'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member INTERNAL_ERROR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        INTERNAL_ERROR = 'internal error'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member INVALID_JUMP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          INVALID_JUMP = 'invalid JUMP'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member INVALID_OPCODE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            INVALID_OPCODE = 'invalid opcode'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member OUT_OF_GAS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              OUT_OF_GAS = 'out of gas'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member OUT_OF_RANGE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                OUT_OF_RANGE = 'value out of range'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member REVERT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  REVERT = 'revert'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member STACK_OVERFLOW

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    STACK_OVERFLOW = 'stack overflow'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member STACK_UNDERFLOW

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      STACK_UNDERFLOW = 'stack underflow'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member STATIC_STATE_CHANGE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        STATIC_STATE_CHANGE = 'static state change'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member STOP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          STOP = 'stop'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Account

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Account = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Blockchain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Blockchain = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Common

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Common = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace ganache-core

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module 'ganache-core' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function provider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    provider: (opts: GanacheOpts) => EthereumTypes.Provider;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GanacheOpts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface GanacheOpts {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property blockTime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        blockTime?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property db_path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          db_path?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fork

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fork?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property gasLimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              gasLimit?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                logger?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                log(msg: string): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property mnemonic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mnemonic?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property network_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    network_id?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property networkId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      networkId?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        port?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property total_accounts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          total_accounts?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property unlocked_accounts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unlocked_accounts?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property verbose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              verbose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property vmErrorsOnRPCResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                vmErrorsOnRPCResponse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace json-rpc-error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module 'json-rpc-error' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class InternalError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class InternalError extends Error {}


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(err: string | Error);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MethodNotFound

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class MethodNotFound extends Error {}



                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace keccak

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            module 'keccak' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace openapi-schema-validation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module 'openapi-schema-validation' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace promisify-child-process

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                module 'promisify-child-process' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace publish-release

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module 'publish-release' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace react-highlight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module 'react-highlight' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace react-popper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module 'react-popper' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Manager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Manager extends React.Component<ManagerProps, {}> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Popper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Popper extends React.Component<PopperProps, {}> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Reference extends React.Component<ReferenceProps, {}> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ManagerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ManagerProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                children: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PopperArrowProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PopperArrowProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ref: RefHandler;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      style: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PopperChildrenProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PopperChildrenProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property arrowProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arrowProps: PopperArrowProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property outOfBoundaries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outOfBoundaries: boolean | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              placement: PopperJS.Placement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ref: RefHandler;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property scheduleUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scheduleUpdate: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    style: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PopperProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PopperProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        children: (props: PopperChildrenProps) => React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property eventsEnabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          eventsEnabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property modifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            modifiers?: PopperJS.Modifiers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              placement?: PopperJS.Placement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property positionFixed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                positionFixed?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property referenceElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  referenceElement?: Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ReferenceChildrenProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ReferenceChildrenProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ref: RefHandler;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ReferenceProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ReferenceProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          children: (props: ReferenceChildrenProps) => React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Placement = PopperJS.Placement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RefHandler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RefHandler = (ref: HTMLElement | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace react-tooltip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                module 'react-tooltip' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace react-typist

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module 'react-typist' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace request-promise-native

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module 'request-promise-native' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace rollbar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module 'rollbar' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace semver-diff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        module 'semver-diff' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace semver-sort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module 'semver-sort' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function desc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            desc: (versions: string[]) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace solc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module 'solc' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function loadRemoteVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loadRemoteVersion: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                versionName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cb: (err: SolcError | null, res?: SolcInstance) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function setupMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setupMethods: (solcBin: any) => SolcInstance;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BaseSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BaseSource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property keccak256

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      keccak256?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CompilationResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CompilationResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property contracts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          contracts: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [contractIdentifier: string]: ContractCompilationResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            errors: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sourceList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourceList: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sources: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [sourceName: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                AST: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CompilerSettings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CompilerSettings {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property evmVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'homestead'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'tangerineWhistle'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'spuriousDragon'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'byzantium'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'constantinople';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property libraries

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      libraries?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [fileName: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [libName: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        metadata?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        useLiteralContent: true;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property optimizer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          optimizer?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          runs?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          details?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          peephole?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          jumpdestRemover?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          orderLiterals?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          deduplicate?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cse?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constantOptimizer?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          yul?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property outputSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outputSelection: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [fileName: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [contractName: string]: OutputField[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property remappings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              remappings?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContractCompilationResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContractCompilationResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property bytecode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bytecode: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property interface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property runtimeBytecode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      runtimeBytecode: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property srcmap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        srcmap: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property srcmapRuntime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          srcmapRuntime: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ImportContents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ImportContents {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property contents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              contents: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface InMemorySource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface InMemorySource extends BaseSource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  content: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InputSources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface InputSources {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sources: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [fileName: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SolcInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface SolcInstance {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method compile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          compile: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sources: InputSources,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findImports?: (importPath: string) => ImportContents
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): CompilationResult;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sources: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          findImports?: (importPath: string) => ImportContents
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            version: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StandardInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StandardInput {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property language

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                language: 'Solidity' | 'serpent' | 'lll' | 'assembly';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property settings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  settings: CompilerSettings;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property sources

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sources: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [fileName: string]: Source;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UrlSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UrlSource extends BaseSource {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property urls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        urls: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type OutputField

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type OutputField =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | '*'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'ast'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'legacyAST'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'abi'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'devdoc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'userdoc'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'metadata'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'ir'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.assembly'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.legacyAssembly'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.bytecode.object'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.bytecode.opcodes'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.bytecode.sourceMap'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.bytecode.linkReferences'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.deployedBytecode.object'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.deployedBytecode.opcodes'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.deployedBytecode.sourceMap'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.deployedBytecode.linkReferences'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.methodIdentifiers'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'evm.gasEstimates'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'ewasm.wast'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'ewasm.wasm';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Source = UrlSource | InMemorySource;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace to-snake-case

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module 'to-snake-case' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function toSnakeCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                toSnakeCase: (str: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace truffle-hdwallet-provider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module 'truffle-hdwallet-provider' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class HDWalletProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class HDWalletProvider implements Provider {}


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(mnemonic: string, rpcUrl: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method sendAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sendAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        payload: JSONRPCRequestPayload,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: (err: Error, result: JSONRPCResponsePayload) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace web3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module 'web3' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Web3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Web3 {}


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              public constructor(provider?: Provider);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property currentProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                currentProvider: Provider;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property eth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  eth: Web3.EthApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property net

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    net: Web3.NetApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property personal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      personal: Web3.PersonalApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property providers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static providers: typeof providers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          version: Web3.VersionApi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method fromAscii

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fromAscii: (ascii: string, padding?: number) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method fromDecimal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fromDecimal: (value: number | string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method fromWei

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fromWei: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (value: number | string, unit: Unit): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (value: BigNumber.BigNumber, unit: Unit): BigNumber.BigNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isAddress: (address: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isChecksumAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isChecksumAddress: (address: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isConnected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isConnected: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reset: (keepIsSyncing: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setProvider: (provider: Provider) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method sha3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sha3: (value: string, options?: Web3.Sha3Options) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method toAscii

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toAscii: (hex: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method toBigNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                toBigNumber: (value: number | string) => BigNumber.BigNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method toDecimal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toDecimal: (hex: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toHex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toHex: (data: MixedData) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toWei

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toWei: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (amount: number | string, unit: Unit): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (amount: BigNumber.BigNumber, unit: Unit): BigNumber.BigNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Contract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Contract<A extends ContractInstance> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method 'new'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          new: (...args: any[]) => A;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            at: (address: string) => A;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getData: (...args: any[]) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContractInstance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ContractInstance {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property abi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abi: ContractAbi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    address: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [name: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface EthApi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface EthApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property accounts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          accounts: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property blockNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            blockNumber: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property coinbase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              coinbase: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property compile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                compile: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sourceString: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cb?: (err: Error, result: any) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultAccount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultAccount?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultBlock: BlockParam;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property gasPrice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gasPrice: BigNumber.BigNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property hashrate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hashrate: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property mining

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          mining: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property syncing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            syncing: Web3.SyncingResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (callData: CallData): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (callData: CallData, callback: (err: Error, result: string) => void): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method contract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                contract: (abi: AbiDefinition[]) => Web3.Contract<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method estimateGas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  estimateGas: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (callData: CallData): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (callData: CallData, callback: (err: Error, gas: number) => void): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    filter: (value: string | FilterObject) => Web3.FilterResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getAccounts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getAccounts: (cd: (err: Error, accounts: string[]) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getBalance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getBalance: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (addressHexString: string): BigNumber.BigNumber;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        addressHexString: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: (err: Error, result: BigNumber.BigNumber) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getBlock: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (hashStringOrBlockNumber: string | BlockParam): BlockWithoutTransactionData;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hashStringOrBlockNumber: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback: (err: Error, blockObj: BlockWithoutTransactionData) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hashStringOrBlockNumber: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          returnTransactionObjects: true
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): BlockWithTransactionData;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hashStringOrBlockNumber: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          returnTransactionObjects: true,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback: (err: Error, blockObj: BlockWithTransactionData) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getBlockNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getBlockNumber: (callback: (err: Error, blockNumber: number) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getBlockTransactionCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getBlockTransactionCount: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (hashStringOrBlockNumber: string | BlockParam): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hashStringOrBlockNumber: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: (err: Error, blockTransactionCount: number) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getCode: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (addressHexString: string): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addressHexString: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (err: Error, code: string) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getGasPrice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getGasPrice: (cd: (err: Error, gasPrice: BigNumber.BigNumber) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getHashrate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getHashrate: (cd: (err: Error, hashrate: number) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getMining

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getMining: (cd: (err: Error, mining: boolean) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getStorageAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getStorageAt: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (address: string, position: number): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        address: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        position: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: (err: Error, storage: string) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getSyncing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getSyncing: (cd: (err: Error, syncing: Web3.SyncingResult) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getTransaction: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (transactionHash: string): Transaction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            transactionHash: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: (err: Error, transaction: Transaction) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getTransactionCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getTransactionCount: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (address: string): number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (address: string, callback: (err: Error, count: number) => void): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getTransactionFromBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getTransactionFromBlock: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hashStringOrBlockNumber: string | BlockParam,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                indexNumber: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): Transaction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hashStringOrBlockNumber: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                indexNumber: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (err: Error, transaction: Transaction) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getTransactionReceipt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getTransactionReceipt: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (txHash: string): TransactionReceipt | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (txHash: string, callback: (err: Error, receipt: any) => void): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getUncle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getUncle: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hashStringOrBlockNumber: string | BlockParam,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    uncleNumber: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): BlockWithoutTransactionData;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hashStringOrBlockNumber: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    uncleNumber: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback: (err: Error, uncle: BlockWithoutTransactionData) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isSyncing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isSyncing: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cb: (err: Error, isSyncing: boolean, syncingState: Web3.SyncingState) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Web3.IsSyncing;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method sendRawTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sendRawTransaction: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rawTxData: string): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (rawTxData: string, callback: (err: Error, value: string) => void): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method sendTransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sendTransaction: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (txData: TxData): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (txData: TxData, callback: (err: Error, value: string) => void): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sign: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (address: string, data: string): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            address: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            data: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: (err: Error, signature: string) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FilterResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface FilterResult {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                get: (callback: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method stopWatching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stopWatching: (callback?: () => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method watch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    watch: (callback: (err: Error, result: LogEntryEvent) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IsSyncing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface IsSyncing {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method addCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        addCallback: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cb: (err: Error, isSyncing: boolean, syncingState: SyncingState) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method stopWatching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stopWatching: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NetApi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NetApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property listening

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              listening: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property peerCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                peerCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getListening

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getListening: (cd: (err: Error, listening: boolean) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getPeerCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getPeerCount: (cd: (err: Error, peerCount: number) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PersonalApi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PersonalApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property listAccounts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        listAccounts: string[] | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method lockAccount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lockAccount: (address: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method newAccount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            newAccount: (password?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sign: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (message: string, account: string, password: string): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hexMessage: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              account: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: (error: Error, signature: string) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method unlockAccount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unlockAccount: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                address: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                password?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                duration?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Sha3Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Sha3Options {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property encoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    encoding: 'hex';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SyncingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SyncingState {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property currentBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        currentBlock: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property highestBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          highestBlock: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property startingBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            startingBlock: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface VersionApi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface VersionApi {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property api

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                api: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ethereum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ethereum: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property network

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    network: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property whisper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        whisper: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getEthereum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getEthereum: (cd: (err: Error, ethereum: string) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getNetwork

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getNetwork: (cd: (err: Error, networkId: string) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getNode: (cd: (err: Error, nodeVersion: string) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getWhisper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getWhisper: (cd: (err: Error, whisper: string) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SyncingResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SyncingResult = false | SyncingState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace web3-eth-abi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module 'web3-eth-abi' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function encodeParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      encodeParameters: (typesArray: string[], parameters: any[]) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (29)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (6)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@0x/typescript-typings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/@0x/typescript-typings"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>