• Version 3.7.1
  • Published
  • 60.4 kB
  • 2 dependencies
  • Apache-2.0 license


npm i ethereum-types
yarn add ethereum-types
pnpm add ethereum-types


Ethereum types




Type Aliases


interface AbstractBlock

interface AbstractBlock {}

    property difficulty

    difficulty: BigNumber;

      property extraData

      extraData: string;

        property gasLimit

        gasLimit: number;

          property gasUsed

          gasUsed: number;

            property hash

            hash: string | null;

              property logsBloom

              logsBloom: string | null;

                property miner

                miner: string;

                  property nonce

                  nonce: string | null;

                    property number

                    number: number | null;

                      property parentHash

                      parentHash: string;

                        property sha3Uncles

                        sha3Uncles: string;

                          property size

                          size: number;

                            property stateRoot

                            stateRoot: string;

                              property timestamp

                              timestamp: number;

                                property totalDifficulty

                                totalDifficulty: BigNumber;

                                  property transactionsRoot

                                  transactionsRoot: string;

                                    property uncles

                                    uncles: string[];

                                      interface BlockRange

                                      interface BlockRange {}

                                        property fromBlock

                                        fromBlock: BlockParam;

                                          property toBlock

                                          toBlock: BlockParam;

                                            interface BlockWithoutTransactionData

                                            interface BlockWithoutTransactionData extends AbstractBlock {}

                                              property transactions

                                              transactions: string[];

                                                interface BlockWithTransactionData

                                                interface BlockWithTransactionData extends AbstractBlock {}

                                                  property transactions

                                                  transactions: Transaction[];

                                                    interface CallData

                                                    interface CallData extends CallTxDataBase {}

                                                      property from

                                                      from?: string;

                                                        property overrides

                                                        overrides?: GethCallOverrides;

                                                          interface CallTxDataBase

                                                          interface CallTxDataBase {}

                                                            property accessList

                                                            accessList?: TxAccessList;

                                                              property data

                                                              data?: string;

                                                                property gas

                                                                gas?: number | string | BigNumber;

                                                                  property gasPrice

                                                                  gasPrice?: number | string | BigNumber;

                                                                    property maxFeePerGas

                                                                    maxFeePerGas?: number | string | BigNumber;

                                                                      property maxPriorityFeePerGas

                                                                      maxPriorityFeePerGas?: number | string | BigNumber;

                                                                        property nonce

                                                                        nonce?: number;

                                                                          property to

                                                                          to?: string;

                                                                            property value

                                                                            value?: number | string | BigNumber;

                                                                              interface CompilerOptions

                                                                              interface CompilerOptions {}
                                                                              • Options you can specify (as flags or in a compiler.json file) when invoking sol-compiler contractsDir: Directory containing your project's Solidity contracts. Can contain nested directories. artifactsDir: Directory where you want the generated artifacts.json written to compilerSettings: Desired settings to pass to the Solidity compiler during compilation. ( contracts: List of contract names you wish to compile, or alternatively ['*'] to compile all contracts in the specified directory. useDockerisedSolc: If set to true - sol-compiler will try calling a dockerized installations of solc to achieve faster compilation times. Otherwise and by default - solcjs will be used. Defaults to false. isOfflineMode: If set to true - sol-compiler will not fetch the list of solc releases from github. It will use the hardcoded list. Defaults to false. solcVersion: If you don't want to compile each contract with the Solidity version specified in-file, you can force all contracts to compile with the the version specified here. shouldSaveStandardInput: Write the standard JSON input in ${contractsDir}/${contractName}.input.json

                                                                              property artifactsDir

                                                                              artifactsDir?: string;

                                                                                property compilerSettings

                                                                                compilerSettings?: CompilerSettings;

                                                                                  property contracts

                                                                                  contracts?: string[] | '*';

                                                                                    property contractsDir

                                                                                    contractsDir?: string;

                                                                                      property isOfflineMode

                                                                                      isOfflineMode?: boolean;

                                                                                        property shouldCompileIndependently

                                                                                        shouldCompileIndependently?: boolean;

                                                                                          property shouldSaveStandardInput

                                                                                          shouldSaveStandardInput?: boolean;

                                                                                            property solcVersion

                                                                                            solcVersion?: string;

                                                                                              property useDockerisedSolc

                                                                                              useDockerisedSolc?: boolean;

                                                                                                interface CompilerOpts

                                                                                                interface CompilerOpts {}

                                                                                                  property name

                                                                                                  name: 'solc';

                                                                                                    property settings

                                                                                                    settings: CompilerSettings;

                                                                                                      property version

                                                                                                      version: string;

                                                                                                        interface CompilerSettings

                                                                                                        interface CompilerSettings {}

                                                                                                          property evmVersion

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

                                                                                                            property libraries

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

                                                                                                              property metadata

                                                                                                              metadata?: CompilerSettingsMetadata;

                                                                                                                property optimizer

                                                                                                                optimizer?: OptimizerSettings;

                                                                                                                  property outputSelection

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

                                                                                                                    property remappings

                                                                                                                    remappings?: string[];

                                                                                                                      interface CompilerSettingsMetadata

                                                                                                                      interface CompilerSettingsMetadata {}

                                                                                                                        property useLiteralContent

                                                                                                                        useLiteralContent: true;

                                                                                                                          interface ConstructorAbi

                                                                                                                          interface ConstructorAbi {}

                                                                                                                            property inputs

                                                                                                                            inputs: DataItem[];

                                                                                                                              property payable

                                                                                                                              payable?: boolean;

                                                                                                                                property stateMutability

                                                                                                                                stateMutability: ConstructorStateMutability;

                                                                                                                                  property type

                                                                                                                                  type: string;

                                                                                                                                    interface ContractArtifact

                                                                                                                                    interface ContractArtifact extends ContractVersionData {}
                                                                                                                                    • This type defines the schema of the artifact.json file generated by Sol-compiler schemaVersion: The version of the artifact schema contractName: The contract name it represents chains: Chain specific information by chain (address, id, constructor args, etc...) compilerOutput: The Solidity compiler output generated from the specified compiler input description ( compiler: The compiler settings used sourceCodes: The source code of the contract and all it's dependencies sources: A mapping from source filePath to sourceMap id sourceTreeHashHex: A unique hash generated from the contract source and that of it's dependencies. If any of the sources change, the hash would change notifying us that a re-compilation is necessary

                                                                                                                                    property chains

                                                                                                                                    chains: ContractChains;

                                                                                                                                      property contractName

                                                                                                                                      contractName: string;

                                                                                                                                        property schemaVersion

                                                                                                                                        schemaVersion: string;

                                                                                                                                          interface ContractChainData

                                                                                                                                          interface ContractChainData {}

                                                                                                                                            property address

                                                                                                                                            address: string;

                                                                                                                                              property constructorArgs

                                                                                                                                              constructorArgs: string;
                                                                                                                                                links: {
                                                                                                                                                [linkName: string]: string;

                                                                                                                                                  interface ContractChains

                                                                                                                                                  interface ContractChains {}

                                                                                                                                                    index signature

                                                                                                                                                    [chainId: number]: ContractChainData;

                                                                                                                                                      interface ContractVersionData

                                                                                                                                                      interface ContractVersionData {}

                                                                                                                                                        property compiler

                                                                                                                                                        compiler: CompilerOpts;

                                                                                                                                                          property compilerOutput

                                                                                                                                                          compilerOutput: StandardContractOutput;

                                                                                                                                                            property sourceCodes

                                                                                                                                                            sourceCodes: {
                                                                                                                                                            [sourceName: string]: string;

                                                                                                                                                              property sources

                                                                                                                                                              sources: {
                                                                                                                                                              [sourceName: string]: {
                                                                                                                                                              id: number;

                                                                                                                                                                property sourceTreeHashHex

                                                                                                                                                                sourceTreeHashHex: string;

                                                                                                                                                                  interface DataItem

                                                                                                                                                                  interface DataItem {}

                                                                                                                                                                    property components

                                                                                                                                                                    components?: DataItem[];

                                                                                                                                                                      property internalType

                                                                                                                                                                      internalType?: string;

                                                                                                                                                                        property name

                                                                                                                                                                        name: string;

                                                                                                                                                                          property type

                                                                                                                                                                          type: string;

                                                                                                                                                                            interface DecodedLogArgs

                                                                                                                                                                            interface DecodedLogArgs {}

                                                                                                                                                                              index signature

                                                                                                                                                                              [argName: string]: ContractEventArg;

                                                                                                                                                                                interface DecodedLogEntry

                                                                                                                                                                                interface DecodedLogEntry<A> extends LogEntry {}

                                                                                                                                                                                  property args

                                                                                                                                                                                  args: A;

                                                                                                                                                                                    property event

                                                                                                                                                                                    event: string;

                                                                                                                                                                                      interface DecodedLogEntryEvent

                                                                                                                                                                                      interface DecodedLogEntryEvent<A> extends DecodedLogEntry<A> {}

                                                                                                                                                                                        property removed

                                                                                                                                                                                        removed: boolean;

                                                                                                                                                                                          interface DevdocOutput

                                                                                                                                                                                          interface DevdocOutput {}

                                                                                                                                                                                            property author

                                                                                                                                                                                            author?: string;

                                                                                                                                                                                              property methods

                                                                                                                                                                                              methods: {
                                                                                                                                                                                              [signature: string]: {
                                                                                                                                                                                              details?: string;
                                                                                                                                                                                              params?: {
                                                                                                                                                                                              [name: string]: ParamDescription;
                                                                                                                                                                                              return?: string;

                                                                                                                                                                                                property title

                                                                                                                                                                                                title?: string;

                                                                                                                                                                                                  interface EIP1193Provider

                                                                                                                                                                                                  interface EIP1193Provider {}

                                                                                                                                                                                                    property isEIP1193

                                                                                                                                                                                                    isEIP1193: boolean;

                                                                                                                                                                                                      method on

                                                                                                                                                                                                      on: (event: EIP1193Event, listener: (result: any) => void) => this;

                                                                                                                                                                                                        method send

                                                                                                                                                                                                        send: (method: string, params?: any[]) => Promise<any>;

                                                                                                                                                                                                          interface EventAbi

                                                                                                                                                                                                          interface EventAbi {}

                                                                                                                                                                                                            property anonymous

                                                                                                                                                                                                            anonymous: boolean;

                                                                                                                                                                                                              property inputs

                                                                                                                                                                                                              inputs: EventParameter[];

                                                                                                                                                                                                                property name

                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                    interface EventParameter

                                                                                                                                                                                                                    interface EventParameter extends DataItem {}

                                                                                                                                                                                                                      property indexed

                                                                                                                                                                                                                      indexed: boolean;

                                                                                                                                                                                                                        interface EvmBytecodeOutput

                                                                                                                                                                                                                        interface EvmBytecodeOutput {}

                                                                                                                                                                                                                          property linkReferences

                                                                                                                                                                                                                          linkReferences?: EvmBytecodeOutputLinkReferences;

                                                                                                                                                                                                                            property object

                                                                                                                                                                                                                            object: string;

                                                                                                                                                                                                                              property sourceMap

                                                                                                                                                                                                                              sourceMap: string;

                                                                                                                                                                                                                                interface EvmBytecodeOutputLinkReferences

                                                                                                                                                                                                                                interface EvmBytecodeOutputLinkReferences {}

                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                  [sourceFile: string]: {
                                                                                                                                                                                                                                  [libraryName: string]: Array<{
                                                                                                                                                                                                                                  start: number;
                                                                                                                                                                                                                                  length: number;

                                                                                                                                                                                                                                    interface EvmOutput

                                                                                                                                                                                                                                    interface EvmOutput {}

                                                                                                                                                                                                                                      property bytecode

                                                                                                                                                                                                                                      bytecode: EvmBytecodeOutput;

                                                                                                                                                                                                                                        property deployedBytecode

                                                                                                                                                                                                                                        deployedBytecode: EvmBytecodeOutput;

                                                                                                                                                                                                                                          interface FallbackAbi

                                                                                                                                                                                                                                          interface FallbackAbi {}

                                                                                                                                                                                                                                            property payable

                                                                                                                                                                                                                                            payable: boolean;

                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                              type: string;

                                                                                                                                                                                                                                                interface FilterObject

                                                                                                                                                                                                                                                interface FilterObject {}

                                                                                                                                                                                                                                                  property address

                                                                                                                                                                                                                                                  address?: string;

                                                                                                                                                                                                                                                    property blockHash

                                                                                                                                                                                                                                                    blockHash?: string;

                                                                                                                                                                                                                                                      property fromBlock

                                                                                                                                                                                                                                                      fromBlock?: number | string;

                                                                                                                                                                                                                                                        property toBlock

                                                                                                                                                                                                                                                        toBlock?: number | string;

                                                                                                                                                                                                                                                          property topics

                                                                                                                                                                                                                                                          topics?: LogTopic[];

                                                                                                                                                                                                                                                            interface GanacheProvider

                                                                                                                                                                                                                                                            interface GanacheProvider {}

                                                                                                                                                                                                                                                              method sendAsync

                                                                                                                                                                                                                                                              sendAsync: (
                                                                                                                                                                                                                                                              payload: JSONRPCRequestPayload,
                                                                                                                                                                                                                                                              callback: JSONRPCErrorCallback
                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                interface GeneratedCompilerOptions

                                                                                                                                                                                                                                                                interface GeneratedCompilerOptions {}

                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                  name: 'solc';

                                                                                                                                                                                                                                                                    property settings

                                                                                                                                                                                                                                                                    settings: CompilerSettings;

                                                                                                                                                                                                                                                                      property version

                                                                                                                                                                                                                                                                      version: string;

                                                                                                                                                                                                                                                                        interface GethCallOverrides

                                                                                                                                                                                                                                                                        interface GethCallOverrides {}

                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                          [address: string]: {
                                                                                                                                                                                                                                                                          code?: string;
                                                                                                                                                                                                                                                                          nonce?: number;
                                                                                                                                                                                                                                                                          balance?: number | string | BigNumber;

                                                                                                                                                                                                                                                                            interface JSONRPCRequestPayload

                                                                                                                                                                                                                                                                            interface JSONRPCRequestPayload {}

                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                              id: number;

                                                                                                                                                                                                                                                                                property jsonrpc

                                                                                                                                                                                                                                                                                jsonrpc: string;

                                                                                                                                                                                                                                                                                  property method

                                                                                                                                                                                                                                                                                  method: string;

                                                                                                                                                                                                                                                                                    property params

                                                                                                                                                                                                                                                                                    params: any[];

                                                                                                                                                                                                                                                                                      interface JSONRPCResponseError

                                                                                                                                                                                                                                                                                      interface JSONRPCResponseError {}

                                                                                                                                                                                                                                                                                        property code

                                                                                                                                                                                                                                                                                        code: number;

                                                                                                                                                                                                                                                                                          property message

                                                                                                                                                                                                                                                                                          message: string;

                                                                                                                                                                                                                                                                                            interface JSONRPCResponsePayload

                                                                                                                                                                                                                                                                                            interface JSONRPCResponsePayload {}

                                                                                                                                                                                                                                                                                              property error

                                                                                                                                                                                                                                                                                              error?: JSONRPCResponseError;

                                                                                                                                                                                                                                                                                                property id

                                                                                                                                                                                                                                                                                                id: number;

                                                                                                                                                                                                                                                                                                  property jsonrpc

                                                                                                                                                                                                                                                                                                  jsonrpc: string;

                                                                                                                                                                                                                                                                                                    property result

                                                                                                                                                                                                                                                                                                    result: any;

                                                                                                                                                                                                                                                                                                      interface LogEntry

                                                                                                                                                                                                                                                                                                      interface LogEntry {}

                                                                                                                                                                                                                                                                                                        property address

                                                                                                                                                                                                                                                                                                        address: string;

                                                                                                                                                                                                                                                                                                          property blockHash

                                                                                                                                                                                                                                                                                                          blockHash: string | null;

                                                                                                                                                                                                                                                                                                            property blockNumber

                                                                                                                                                                                                                                                                                                            blockNumber: number | null;

                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                              data: string;

                                                                                                                                                                                                                                                                                                                property logIndex

                                                                                                                                                                                                                                                                                                                logIndex: number | null;

                                                                                                                                                                                                                                                                                                                  property topics

                                                                                                                                                                                                                                                                                                                  topics: string[];

                                                                                                                                                                                                                                                                                                                    property transactionHash

                                                                                                                                                                                                                                                                                                                    transactionHash: string;

                                                                                                                                                                                                                                                                                                                      property transactionIndex

                                                                                                                                                                                                                                                                                                                      transactionIndex: number | null;

                                                                                                                                                                                                                                                                                                                        interface LogEntryEvent

                                                                                                                                                                                                                                                                                                                        interface LogEntryEvent extends LogEntry {}

                                                                                                                                                                                                                                                                                                                          property removed

                                                                                                                                                                                                                                                                                                                          removed: boolean;

                                                                                                                                                                                                                                                                                                                            interface LogWithDecodedArgs

                                                                                                                                                                                                                                                                                                                            interface LogWithDecodedArgs<ArgsType extends DecodedLogArgs>
                                                                                                                                                                                                                                                                                                                            extends DecodedLogEntry<ArgsType> {}

                                                                                                                                                                                                                                                                                                                              interface MethodAbi

                                                                                                                                                                                                                                                                                                                              interface MethodAbi {}

                                                                                                                                                                                                                                                                                                                                property constant

                                                                                                                                                                                                                                                                                                                                constant?: boolean;

                                                                                                                                                                                                                                                                                                                                  property inputs

                                                                                                                                                                                                                                                                                                                                  inputs: DataItem[];

                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                      property outputs

                                                                                                                                                                                                                                                                                                                                      outputs: DataItem[];

                                                                                                                                                                                                                                                                                                                                        property payable

                                                                                                                                                                                                                                                                                                                                        payable?: boolean;

                                                                                                                                                                                                                                                                                                                                          property stateMutability

                                                                                                                                                                                                                                                                                                                                          stateMutability: StateMutability;

                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                            type: string;

                                                                                                                                                                                                                                                                                                                                              interface OptimizerSettings

                                                                                                                                                                                                                                                                                                                                              interface OptimizerSettings {}

                                                                                                                                                                                                                                                                                                                                                property enabled

                                                                                                                                                                                                                                                                                                                                                enabled: boolean;

                                                                                                                                                                                                                                                                                                                                                  property runs

                                                                                                                                                                                                                                                                                                                                                  runs?: number;

                                                                                                                                                                                                                                                                                                                                                    interface Provider

                                                                                                                                                                                                                                                                                                                                                    interface Provider {}

                                                                                                                                                                                                                                                                                                                                                      method sendAsync

                                                                                                                                                                                                                                                                                                                                                      sendAsync: (
                                                                                                                                                                                                                                                                                                                                                      payload: JSONRPCRequestPayload,
                                                                                                                                                                                                                                                                                                                                                      callback: JSONRPCErrorCallback
                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                        interface RawLogEntry

                                                                                                                                                                                                                                                                                                                                                        interface RawLogEntry {}

                                                                                                                                                                                                                                                                                                                                                          property address

                                                                                                                                                                                                                                                                                                                                                          address: string;

                                                                                                                                                                                                                                                                                                                                                            property blockHash

                                                                                                                                                                                                                                                                                                                                                            blockHash: string | null;

                                                                                                                                                                                                                                                                                                                                                              property blockNumber

                                                                                                                                                                                                                                                                                                                                                              blockNumber: string | null;

                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                data: string;

                                                                                                                                                                                                                                                                                                                                                                  property logIndex

                                                                                                                                                                                                                                                                                                                                                                  logIndex: string | null;

                                                                                                                                                                                                                                                                                                                                                                    property topics

                                                                                                                                                                                                                                                                                                                                                                    topics: string[];

                                                                                                                                                                                                                                                                                                                                                                      property transactionHash

                                                                                                                                                                                                                                                                                                                                                                      transactionHash: string;

                                                                                                                                                                                                                                                                                                                                                                        property transactionIndex

                                                                                                                                                                                                                                                                                                                                                                        transactionIndex: string | null;

                                                                                                                                                                                                                                                                                                                                                                          interface RevertErrorAbi

                                                                                                                                                                                                                                                                                                                                                                          interface RevertErrorAbi {}

                                                                                                                                                                                                                                                                                                                                                                            property arguments

                                                                                                                                                                                                                                                                                                                                                                            arguments?: DataItem[];

                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                type: 'error';

                                                                                                                                                                                                                                                                                                                                                                                  interface SolcError

                                                                                                                                                                                                                                                                                                                                                                                  interface SolcError {}

                                                                                                                                                                                                                                                                                                                                                                                    property component

                                                                                                                                                                                                                                                                                                                                                                                    component: 'general' | 'ewasm';

                                                                                                                                                                                                                                                                                                                                                                                      property formattedMessage

                                                                                                                                                                                                                                                                                                                                                                                      formattedMessage?: string;

                                                                                                                                                                                                                                                                                                                                                                                        property message

                                                                                                                                                                                                                                                                                                                                                                                        message: string;

                                                                                                                                                                                                                                                                                                                                                                                          property severity

                                                                                                                                                                                                                                                                                                                                                                                          severity: ErrorSeverity;

                                                                                                                                                                                                                                                                                                                                                                                            property sourceLocation

                                                                                                                                                                                                                                                                                                                                                                                            sourceLocation?: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                              type: ErrorType;

                                                                                                                                                                                                                                                                                                                                                                                                interface Source

                                                                                                                                                                                                                                                                                                                                                                                                interface Source {}

                                                                                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                                                                                  id: number;

                                                                                                                                                                                                                                                                                                                                                                                                    interface SourceLocation

                                                                                                                                                                                                                                                                                                                                                                                                    interface SourceLocation {}

                                                                                                                                                                                                                                                                                                                                                                                                      property end

                                                                                                                                                                                                                                                                                                                                                                                                      end: number;

                                                                                                                                                                                                                                                                                                                                                                                                        property file

                                                                                                                                                                                                                                                                                                                                                                                                        file: string;

                                                                                                                                                                                                                                                                                                                                                                                                          property start

                                                                                                                                                                                                                                                                                                                                                                                                          start: number;

                                                                                                                                                                                                                                                                                                                                                                                                            interface StandardContractOutput

                                                                                                                                                                                                                                                                                                                                                                                                            interface StandardContractOutput {}

                                                                                                                                                                                                                                                                                                                                                                                                              property abi

                                                                                                                                                                                                                                                                                                                                                                                                              abi: ContractAbi;

                                                                                                                                                                                                                                                                                                                                                                                                                property devdoc

                                                                                                                                                                                                                                                                                                                                                                                                                devdoc?: DevdocOutput;

                                                                                                                                                                                                                                                                                                                                                                                                                  property evm

                                                                                                                                                                                                                                                                                                                                                                                                                  evm: EvmOutput;

                                                                                                                                                                                                                                                                                                                                                                                                                    interface StandardOutput

                                                                                                                                                                                                                                                                                                                                                                                                                    interface StandardOutput {}

                                                                                                                                                                                                                                                                                                                                                                                                                      property contracts

                                                                                                                                                                                                                                                                                                                                                                                                                      contracts: {
                                                                                                                                                                                                                                                                                                                                                                                                                      [fileName: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                      [contractName: string]: StandardContractOutput;

                                                                                                                                                                                                                                                                                                                                                                                                                        property errors

                                                                                                                                                                                                                                                                                                                                                                                                                        errors: SolcError[];

                                                                                                                                                                                                                                                                                                                                                                                                                          property sources

                                                                                                                                                                                                                                                                                                                                                                                                                          sources: {
                                                                                                                                                                                                                                                                                                                                                                                                                          [fileName: string]: {
                                                                                                                                                                                                                                                                                                                                                                                                                          id: number;
                                                                                                                                                                                                                                                                                                                                                                                                                          ast?: object;
                                                                                                                                                                                                                                                                                                                                                                                                                          legacyAST?: object;

                                                                                                                                                                                                                                                                                                                                                                                                                            interface StructLog

                                                                                                                                                                                                                                                                                                                                                                                                                            interface StructLog {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property depth

                                                                                                                                                                                                                                                                                                                                                                                                                              depth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                property error

                                                                                                                                                                                                                                                                                                                                                                                                                                error: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property gas

                                                                                                                                                                                                                                                                                                                                                                                                                                  gas: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property gasCost

                                                                                                                                                                                                                                                                                                                                                                                                                                    gasCost: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property memory

                                                                                                                                                                                                                                                                                                                                                                                                                                      memory: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                        property op

                                                                                                                                                                                                                                                                                                                                                                                                                                        op: OpCode;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property pc

                                                                                                                                                                                                                                                                                                                                                                                                                                          pc: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property stack

                                                                                                                                                                                                                                                                                                                                                                                                                                            stack: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                              property storage

                                                                                                                                                                                                                                                                                                                                                                                                                                              storage: {
                                                                                                                                                                                                                                                                                                                                                                                                                                              [location: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TraceParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TraceParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property disableMemory

                                                                                                                                                                                                                                                                                                                                                                                                                                                  disableMemory?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property disableStack

                                                                                                                                                                                                                                                                                                                                                                                                                                                    disableStack?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property disableStorage

                                                                                                                                                                                                                                                                                                                                                                                                                                                      disableStorage?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property timeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                        timeout?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tracer

                                                                                                                                                                                                                                                                                                                                                                                                                                                          tracer?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Transaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Transaction {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property blockHash

                                                                                                                                                                                                                                                                                                                                                                                                                                                              blockHash: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property blockNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                blockNumber: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  from: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property gas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gas: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property gasPrice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gasPrice?: BigNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hash: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property input

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          input: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property maxFeePerGas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxFeePerGas?: BigNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property maxPriorityFeePerGas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              maxPriorityFeePerGas?: BigNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property nonce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                nonce: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  to: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property transactionIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transactionIndex: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: BigNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionReceipt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TransactionReceipt {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property blockHash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          blockHash: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property blockNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            blockNumber: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property contractAddress

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              contractAddress: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property cumulativeGasUsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                cumulativeGasUsed: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  from: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property gasUsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gasUsed: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property logs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      logs: LogEntry[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        status: TransactionReceiptStatus;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          to: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property transactionHash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            transactionHash: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property transactionIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              transactionIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TransactionReceiptWithDecodedLogs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TransactionReceiptWithDecodedLogs extends TransactionReceipt {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Contains the logs returned by a TransactionReceipt. We attempt to decode the logs using AbiDecoder. If we have the logs corresponding ABI, we decode it, otherwise we don't.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property logs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                logs: Array<LogWithDecodedArgs<DecodedLogArgs> | LogEntry>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TransactionTrace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TransactionTrace {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property gas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gas: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property returnValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      returnValue: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property structLogs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        structLogs: StructLog[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TupleDataItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TupleDataItem extends DataItem {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property components

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            components: DataItem[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TxAccessList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TxAccessList {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [address: string]: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TxAccessListWithGas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TxAccessListWithGas {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property accessList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    accessList: TxAccessList;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property gasUsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      gasUsed: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TxData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TxData extends CallTxDataBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          from: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TxDataPayable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface TxDataPayable extends TxData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value?: BigNumber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Web3JsV1Provider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Web3JsV1Provider {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Web3.js version 1 provider interface This provider interface was implemented in the pre-1.0Beta releases for Web3.js. This interface allowed sending synchonous requests, support for which was later dropped.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method send

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                send: (payload: JSONRPCRequestPayload) => JSONRPCResponsePayload;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method sendAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sendAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  payload: JSONRPCRequestPayload,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback: JSONRPCErrorCallback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Web3JsV2Provider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Web3JsV2Provider {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Web3.js version 2 provider interface This provider interface was used in a couple of Web3.js 1.0 beta releases before the first attempts to conform to EIP1193

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method send

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    send: (payload: JSONRPCRequestPayload, callback: JSONRPCErrorCallback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Web3JsV3Provider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Web3JsV3Provider {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Web3.js version 3 provider interface This provider interface was implemented with the hopes for conforming to the EIP1193 spec, however it does not conform entirely.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method send

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      send: (method: string, params?: any[]) => Promise<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ZeroExProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ZeroExProvider {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • The interface for the provider used internally by 0x libraries Any property we use from any SupportedProvider should we explicitly add here

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isMetaMask

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isMetaMask?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isParity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isParity?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isZeroExProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isZeroExProvider?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method enable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enable: () => Promise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method sendAsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sendAsync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                payload: JSONRPCRequestPayload,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: JSONRPCErrorCallback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stop: () => void;


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum AbiType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum AbiType {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Function = 'function',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Constructor = 'constructor',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Event = 'event',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Fallback = 'fallback',

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Constructor = 'constructor'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Event = 'event'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Fallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Fallback = 'fallback'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Function

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Function = 'function'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enum BlockParamLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              enum BlockParamLiteral {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Earliest = 'earliest',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Latest = 'latest',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pending = 'pending',

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Earliest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Earliest = 'earliest'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Latest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Latest = 'latest'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Pending

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pending = 'pending'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum OpCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enum OpCode {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Stop = 'STOP',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Add = 'ADD',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Mul = 'MUL',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sub = 'SUB',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Div = 'DIV',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SDiv = 'SDIV',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Mod = 'MOD',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SMod = 'SMOD',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AddMod = 'ADDMOD',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MulMod = 'MULMOD',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Exp = 'EXP',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SignExtend = 'SIGNEXTEND',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Lt = 'LT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Gt = 'GT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SLt = 'SLT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SGt = 'SGT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Eq = 'EQ',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      IsZero = 'ISZERO',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      And = 'AND',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Or = 'OR',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Xor = 'XOR',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Not = 'NOT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Byte = 'BYTE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Sha3 = 'SHA3',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Address = 'ADDRESS',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Balance = 'BALANCE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Origin = 'ORIGIN',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Caller = 'CALLER',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CallValue = 'CALLVALUE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CallDataLoad = 'CALLDATALOAD',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CallDataSize = 'CALLDATASIZE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CallDataCopy = 'CALLDATACOPY',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CodeSize = 'CODESIZE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CodeCopy = 'CODECOPY',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GasPrice = 'GASPRICE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ExtCodeSize = 'EXTCODESIZE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ExtCodeCopy = 'EXTCODECOPY',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ReturnDataSize = 'RETURNDATASIZE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ReturnDataCopy = 'RETURNDATACOPY',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BlockHash = 'BLOCKHASH',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Coinbase = 'COINBASE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TimeStamp = 'TimeStamp',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number = 'NUMBER',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Difficulty = 'DIFFICULTY',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Gaslimit = 'GASLIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pop = 'POP',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MLoad = 'MLOAD',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MStore = 'MSTORE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MStore8 = 'MSTORE8',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SLoad = 'SLOAD',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SStore = 'SSTORE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Jump = 'JUMP',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Jumpi = 'JUMPI',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Pc = 'PC',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MSize = 'MSIZE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Gas = 'GAS',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      JumpDest = 'JUMPDEST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push1 = 'PUSH1',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push2 = 'PUSH2',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push3 = 'PUSH3',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push4 = 'PUSH4',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push5 = 'PUSH5',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push6 = 'PUSH6',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push7 = 'PUSH7',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push8 = 'PUSH8',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push9 = 'PUSH9',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push10 = 'PUSH10',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push11 = 'PUSH11',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push12 = 'PUSH12',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push13 = 'PUSH13',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push14 = 'PUSH14',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push15 = 'PUSH15',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push16 = 'PUSH16',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push17 = 'PUSH17',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push18 = 'PUSH18',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push19 = 'PUSH19',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push20 = 'PUSH20',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push21 = 'PUSH21',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push22 = 'PUSH22',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push23 = 'PUSH23',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push24 = 'PUSH24',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push25 = 'PUSH25',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push26 = 'PUSH26',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push27 = 'PUSH27',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push28 = 'PUSH28',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push29 = 'PUSH29',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push30 = 'PUSH30',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push31 = 'PUSH31',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push32 = 'PUSH32',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup1 = 'DUP1',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup2 = 'DUP2',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup3 = 'DUP3',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup4 = 'DUP4',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup5 = 'DUP5',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup6 = 'DUP6',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup7 = 'DUP7',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup8 = 'DUP8',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup9 = 'DUP9',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup10 = 'DUP10',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup11 = 'DUP11',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup12 = 'DUP12',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup13 = 'DUP13',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup14 = 'DUP14',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup15 = 'DUP15',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup16 = 'DUP16',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap1 = 'SWAP1',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap2 = 'SWAP2',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap3 = 'SWAP3',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap4 = 'SWAP4',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap5 = 'SWAP5',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap6 = 'SWAP6',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap7 = 'SWAP7',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap8 = 'SWAP8',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap9 = 'SWAP9',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap10 = 'SWAP10',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap11 = 'SWAP11',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap12 = 'SWAP12',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap13 = 'SWAP13',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap14 = 'SWAP14',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap15 = 'SWAP15',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap16 = 'SWAP16',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Log1 = 'LOG1',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Log2 = 'LOG2',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Log3 = 'LOG3',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Log4 = 'LOG4',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Create = 'CREATE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Call = 'CALL',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CallCode = 'CALLCODE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Return = 'RETURN',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DelegateCall = 'DELEGATECALL',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      StaticCall = 'STATICCALL',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Revert = 'REVERT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Invalid = 'INVALID',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SelfDestruct = 'SELFDESTRUCT',

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Add = 'ADD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member AddMod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AddMod = 'ADDMOD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Address = 'ADDRESS'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member And

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              And = 'AND'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Balance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Balance = 'BALANCE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member BlockHash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BlockHash = 'BLOCKHASH'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Byte

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Byte = 'BYTE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Call = 'CALL'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member CallCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CallCode = 'CALLCODE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member CallDataCopy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          CallDataCopy = 'CALLDATACOPY'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member CallDataLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CallDataLoad = 'CALLDATALOAD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member CallDataSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CallDataSize = 'CALLDATASIZE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Caller

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Caller = 'CALLER'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member CallValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CallValue = 'CALLVALUE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member CodeCopy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CodeCopy = 'CODECOPY'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member CodeSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CodeSize = 'CODESIZE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Coinbase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Coinbase = 'COINBASE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Create = 'CREATE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member DelegateCall

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DelegateCall = 'DELEGATECALL'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Difficulty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Difficulty = 'DIFFICULTY'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Div

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Div = 'DIV'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Dup1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dup1 = 'DUP1'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Dup10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dup10 = 'DUP10'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Dup11

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup11 = 'DUP11'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Dup12

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dup12 = 'DUP12'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Dup13

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dup13 = 'DUP13'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Dup14

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dup14 = 'DUP14'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Dup15

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dup15 = 'DUP15'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Dup16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dup16 = 'DUP16'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Dup2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dup2 = 'DUP2'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Dup3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Dup3 = 'DUP3'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Dup4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Dup4 = 'DUP4'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Dup5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dup5 = 'DUP5'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Dup6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dup6 = 'DUP6'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Dup7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dup7 = 'DUP7'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Dup8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dup8 = 'DUP8'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Dup9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Dup9 = 'DUP9'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Eq

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Eq = 'EQ'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Exp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exp = 'EXP'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member ExtCodeCopy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ExtCodeCopy = 'EXTCODECOPY'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member ExtCodeSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ExtCodeSize = 'EXTCODESIZE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Gas

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Gas = 'GAS'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Gaslimit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Gaslimit = 'GASLIMIT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member GasPrice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GasPrice = 'GASPRICE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Gt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Gt = 'GT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Invalid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Invalid = 'INVALID'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member IsZero

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IsZero = 'ISZERO'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Jump

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Jump = 'JUMP'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member JumpDest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        JumpDest = 'JUMPDEST'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Jumpi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Jumpi = 'JUMPI'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Log1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Log1 = 'LOG1'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Log2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Log2 = 'LOG2'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Log3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Log3 = 'LOG3'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Log4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Log4 = 'LOG4'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Lt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Lt = 'LT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member MLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MLoad = 'MLOAD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Mod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Mod = 'MOD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member MSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MSize = 'MSIZE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member MStore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MStore = 'MSTORE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member MStore8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MStore8 = 'MSTORE8'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Mul

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Mul = 'MUL'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member MulMod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MulMod = 'MULMOD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Not

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Not = 'NOT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Number = 'NUMBER'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Or

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Or = 'OR'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Origin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Origin = 'ORIGIN'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Pc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pc = 'PC'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Pop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Pop = 'POP'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Push1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Push1 = 'PUSH1'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Push10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Push10 = 'PUSH10'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Push11

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Push11 = 'PUSH11'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Push12

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push12 = 'PUSH12'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Push13

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Push13 = 'PUSH13'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Push14

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Push14 = 'PUSH14'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Push15

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Push15 = 'PUSH15'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Push16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Push16 = 'PUSH16'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Push17

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Push17 = 'PUSH17'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Push18

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Push18 = 'PUSH18'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Push19

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Push19 = 'PUSH19'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Push2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push2 = 'PUSH2'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Push20

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Push20 = 'PUSH20'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Push21

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Push21 = 'PUSH21'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Push22

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Push22 = 'PUSH22'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Push23

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Push23 = 'PUSH23'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Push24

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Push24 = 'PUSH24'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Push25

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Push25 = 'PUSH25'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Push26

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Push26 = 'PUSH26'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Push27

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push27 = 'PUSH27'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Push28

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Push28 = 'PUSH28'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Push29

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Push29 = 'PUSH29'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Push3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Push3 = 'PUSH3'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Push30

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Push30 = 'PUSH30'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Push31

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Push31 = 'PUSH31'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Push32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Push32 = 'PUSH32'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Push4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Push4 = 'PUSH4'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Push5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Push5 = 'PUSH5'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Push6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Push6 = 'PUSH6'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Push7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Push7 = 'PUSH7'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Push8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Push8 = 'PUSH8'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Push9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Push9 = 'PUSH9'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Return

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Return = 'RETURN'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member ReturnDataCopy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ReturnDataCopy = 'RETURNDATACOPY'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member ReturnDataSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReturnDataSize = 'RETURNDATASIZE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Revert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Revert = 'REVERT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member SDiv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SDiv = 'SDIV'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member SelfDestruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SelfDestruct = 'SELFDESTRUCT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member SGt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SGt = 'SGT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Sha3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sha3 = 'SHA3'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member SignExtend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SignExtend = 'SIGNEXTEND'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member SLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SLoad = 'SLOAD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member SLt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SLt = 'SLT'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member SMod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SMod = 'SMOD'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member SStore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SStore = 'SSTORE'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member StaticCall

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          StaticCall = 'STATICCALL'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Stop = 'STOP'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Sub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Sub = 'SUB'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Swap1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Swap1 = 'SWAP1'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Swap10

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Swap10 = 'SWAP10'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Swap11

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Swap11 = 'SWAP11'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Swap12

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap12 = 'SWAP12'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Swap13

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Swap13 = 'SWAP13'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Swap14

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Swap14 = 'SWAP14'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Swap15

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Swap15 = 'SWAP15'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Swap16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Swap16 = 'SWAP16'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Swap2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Swap2 = 'SWAP2'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Swap3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Swap3 = 'SWAP3'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Swap4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Swap4 = 'SWAP4'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Swap5

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Swap5 = 'SWAP5'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Swap6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Swap6 = 'SWAP6'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Swap7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Swap7 = 'SWAP7'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Swap8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Swap8 = 'SWAP8'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member Swap9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Swap9 = 'SWAP9'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member TimeStamp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TimeStamp = 'TimeStamp'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Xor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Xor = 'XOR'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum SolidityTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    enum SolidityTypes {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Address = 'address',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bool = 'bool',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Bytes = 'bytes',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Int = 'int',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    String = 'string',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Tuple = 'tuple',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Uint256 = 'uint256',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Uint8 = 'uint8',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Uint = 'uint',

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Address = 'address'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        member Bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Bool = 'bool'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          member Bytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Bytes = 'bytes'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            member Int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Int = 'int'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              member String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              String = 'string'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                member Tuple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Tuple = 'tuple'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  member Uint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Uint = 'uint'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    member Uint256

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Uint256 = 'uint256'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      member Uint8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Uint8 = 'uint8'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AbiDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type AbiDefinition = FunctionAbi | EventAbi | RevertErrorAbi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BlockParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BlockParam = BlockParamLiteral | number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ConstructorStateMutability

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ConstructorStateMutability = 'nonpayable' | 'payable';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ContractAbi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ContractAbi = AbiDefinition[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ContractEventArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ContractEventArg = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DecodedLogs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DecodedLogs = Array<LogWithDecodedArgs<DecodedLogArgs>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EIP1193Event

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type EIP1193Event =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'accountsChanged'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'networkChanged'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'close'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'connect'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'notification';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Interface for providers that conform to EIP 1193 Source:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ErrorSeverity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ErrorSeverity = 'error' | 'warning';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ErrorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ErrorType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'JSONError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'IOError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'ParserError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'DocstringParsingError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'SyntaxError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'DeclarationError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'TypeError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'UnimplementedFeatureError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'InternalCompilerError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Exception'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'CompilerError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'FatalError'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Warning';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionAbi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FunctionAbi = MethodAbi | ConstructorAbi | FallbackAbi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type JSONRPCErrorCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type JSONRPCErrorCallback = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          result?: JSONRPCResponsePayload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type LogTopic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type LogTopic = null | string | 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 ParamDescription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ParamDescription = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RawLog

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RawLog = LogEntry;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StateMutability

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type StateMutability = 'pure' | 'view' | ConstructorStateMutability;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SupportedProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SupportedProvider =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Web3JsProvider
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | GanacheProvider
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | EIP1193Provider
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ZeroExProvider;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Do not create your own provider. Use an existing provider from a Web3 or ProviderEngine library Read more about Providers in the guides section of the 0x docs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TransactionReceiptStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TransactionReceiptStatus = null | string | 0 | 1;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Unit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Unit =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'kwei'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'ada'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'mwei'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'babbage'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'gwei'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'shannon'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'szabo'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'finney'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'ether'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'kether'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'grand'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'einstein'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'mether'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'gether'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'tether';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Web3JsProvider

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Web3JsProvider = Web3JsV1Provider | Web3JsV2Provider | Web3JsV3Provider;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (7)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.


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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use to create a custom badge linking to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <a href=""><img src="" alt=""></a>