Class ContractInstanceDecoder

See WireDecoder.decodeLog.

See WireDecoder.decodeTransaction.

This mostly behaves as WireDecoder.events. However, unlike other variants of this function, this one, by default, restricts to events originating from this instance's address. If you don't want to restrict like that, you can explicitly use address: undefined in the options to disable this. (You can also of course set a different address to restrict to that.)

Returns information about the state of the contract, but does not include information about the storage or decoded variables. See the documentation for the ContractState type for more.

Opposite of watchMappingKey; unwatches the specified mapping key. See watchMappingKey for more on how watching mapping keys works, and on how the parameters work.

Note that unwatching a mapping key will also unwatch all its descendants. E.g., if m is of type mapping(uint => mapping(uint => uint)), then unwatching m[0] will also unwatch m[0][0], m[0][1], etc, if these are currently watched.

This function has the same caveats as watchMappingKey.

Decodes an individual contract variable; returns its value as a Result. See the documentation for variables() for various caveats that also apply here.

If the variable can't be located, throws an exception.

example

Consider a contract Derived inheriting from a contract Base. Suppose Derived has a variable x and Base has variables x and y. One can access Derived.x as variable("x") or variable("Derived.x"), can access Base.x as variable("Base.x"), and can access Base.y as variable("y") or variable("Base.y").

Decodes the contract's variables; returns an array of these decoded variables. See the documentation of the [[DecodedVariable]] type for more.

Note that variable decoding can only operate in full mode; if the decoder wasn't able to start up in full mode, this method will throw an exception.

Note that decoding mappings requires first watching mapping keys in order to get any results; see the documentation for watchMappingKey. Additional methods to make mapping decoding a less manual affair are planned for the future.

Also, due to a technical limitation, it is not currently possible to usefully decode internal function pointers. See the FunctionInternalValue documentation and the README for more on how these are handled.

Watches a mapping key; adds it to the decoder's list of watched mapping keys. This affects the results of both variables() and variable(). When a mapping is decoded, only the values at its watched keys will be included in its value.

Note that it is possible to watch mappings that are inside structs, arrays, other mappings, etc; see below for more on how to do this.

Note that watching mapping keys is only possible in full mode; if the decoder wasn't able to start up in full mode, this method will throw an exception.

Warning: At the moment, this function does very little to check its input. Bad input may have unpredictable results. This will be remedied in the future (by having it throw exceptions on bad input), but right now essentially no checking is implemented. Also, there may be slight changes to the format of indices in the future.

(A bad variable name will cause an exception though; that input is checked.)

example

First, a simple example. Say we have a mapping m of type mapping(uint => uint). You could call watchMappingKey("m", 0) to watch m[0].

example

Now for a slightly more complicated example. Say m is of type mapping(uint => mapping(uint => uint)), then to watch m[3][5], you can call watchMappingKey("m", 3, 5). This will also automatically watch m[3]; otherwise, watching m[3][5] wouldn't do much of anything.

example

Now for a well more complicated example. Say we have a struct type MapStruct with a member called map which is a mapping(string => string), and say we have a variable arr of type MapStruct[], then one could watch arr[3].map["hello"] by calling watchMappingKey("arr", 3, "map", "hello").