ethereum-types

difficulty: BigNumber;

extraData: string;

gasLimit: number;

gasUsed: number;

hash: string | null;

logsBloom: string | null;

miner: string;

nonce: string | null;

number: number | null;

parentHash: string;

sha3Uncles: string;

size: number;

stateRoot: string;

timestamp: number;

totalDifficulty: BigNumber;

transactionsRoot: string;

uncles: string[];

fromBlock: BlockParam;

toBlock: BlockParam;

transactions: string[];

transactions: Transaction[];

from?: string;

overrides?: GethCallOverrides;

accessList?: TxAccessList;

data?: string;

gas?: number | string | BigNumber;

gasPrice?: number | string | BigNumber;

maxFeePerGas?: number | string | BigNumber;

maxPriorityFeePerGas?: number | string | BigNumber;

nonce?: number;

to?: string;

value?: number | string | BigNumber;

artifactsDir?: string;

compilerSettings?: CompilerSettings;

contracts?: string[] | '*';

contractsDir?: string;

isOfflineMode?: boolean;

shouldCompileIndependently?: boolean;

shouldSaveStandardInput?: boolean;

solcVersion?: string;

useDockerisedSolc?: boolean;

name: 'solc';

settings: CompilerSettings;

version: string;

evmVersion?:
    | 'homestead'
    | 'tangerineWhistle'
    | 'spuriousDragon'
    | 'byzantium'
    | 'constantinople';

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

metadata?: CompilerSettingsMetadata;

optimizer?: OptimizerSettings;

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

remappings?: string[];

useLiteralContent: true;

inputs: DataItem[];

payable?: boolean;

stateMutability: ConstructorStateMutability;

type: string;

chains: ContractChains;

contractName: string;

schemaVersion: string;

address: string;

constructorArgs: string;

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

[chainId: number]: ContractChainData;

compiler: CompilerOpts;

compilerOutput: StandardContractOutput;

sourceCodes: {
    [sourceName: string]: string;
};

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

sourceTreeHashHex: string;

components?: DataItem[];

internalType?: string;

name: string;

type: string;

[argName: string]: ContractEventArg;

args: A;

event: string;

removed: boolean;

author?: string;

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

title?: string;

isEIP1193: boolean;

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

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

anonymous: boolean;

inputs: EventParameter[];

name: string;

type: string;

indexed: boolean;

linkReferences?: EvmBytecodeOutputLinkReferences;

object: string;

sourceMap: string;

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

bytecode: EvmBytecodeOutput;

deployedBytecode: EvmBytecodeOutput;

payable: boolean;

type: string;

address?: string;

blockHash?: string;

fromBlock?: number | string;

toBlock?: number | string;

topics?: LogTopic[];

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

name: 'solc';

settings: CompilerSettings;

version: string;

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

id: number;

jsonrpc: string;

method: string;

params: any[];

code: number;

message: string;

error?: JSONRPCResponseError;

id: number;

jsonrpc: string;

result: any;

address: string;

blockHash: string | null;

blockNumber: number | null;

data: string;

logIndex: number | null;

topics: string[];

transactionHash: string;

transactionIndex: number | null;

removed: boolean;

constant?: boolean;

inputs: DataItem[];

name: string;

outputs: DataItem[];

payable?: boolean;

stateMutability: StateMutability;

type: string;

enabled: boolean;

runs?: number;

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

address: string;

blockHash: string | null;

blockNumber: string | null;

data: string;

logIndex: string | null;

topics: string[];

transactionHash: string;

transactionIndex: string | null;

arguments?: DataItem[];

name: string;

type: 'error';

component: 'general' | 'ewasm';

formattedMessage?: string;

message: string;

severity: ErrorSeverity;

sourceLocation?: SourceLocation;

type: ErrorType;

id: number;

end: number;

file: string;

start: number;

abi: ContractAbi;

devdoc?: DevdocOutput;

evm: EvmOutput;

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

errors: SolcError[];

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

depth: number;

error: string;

gas: number;

gasCost: number;

memory: string[];

op: OpCode;

pc: number;

stack: string[];

storage: {
    [location: string]: string;
};

disableMemory?: boolean;

disableStack?: boolean;

disableStorage?: boolean;

timeout?: string;

tracer?: string;

blockHash: string | null;

blockNumber: number | null;

from: string;

gas: number;

gasPrice?: BigNumber;

hash: string;

input: string;

maxFeePerGas?: BigNumber;

maxPriorityFeePerGas?: BigNumber;

nonce: number;

to: string | null;

transactionIndex: number | null;

value: BigNumber;

blockHash: string;

blockNumber: number;

contractAddress: string | null;

cumulativeGasUsed: number;

from: string;

gasUsed: number;

logs: LogEntry[];

status: TransactionReceiptStatus;

to: string;

transactionHash: string;

transactionIndex: number;

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

gas: number;

returnValue: any;

structLogs: StructLog[];

components: DataItem[];

[address: string]: string[];

accessList: TxAccessList;

gasUsed: number;

from: string;

value?: BigNumber;

send: (payload: JSONRPCRequestPayload) => JSONRPCResponsePayload;

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

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

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

isMetaMask?: boolean;

isParity?: boolean;

isZeroExProvider?: boolean;

enable: () => Promise<void>;

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

stop: () => void;

Constructor = 'constructor'

Event = 'event'

Fallback = 'fallback'

Function = 'function'

Earliest = 'earliest'

Latest = 'latest'

Pending = 'pending'