A record type to represent an evaluation plan and result of a single action.
An immutable key–value data structure to represent states of multiple accounts. Keys are an account Address, and values are their state.
Since this implements IImmutableDictionary<TKey,TValue> interface, the usage is same.
A decorator to enable subtype polymorphism for action classes.
By convention, concrete action subclasses are named with verb
One downside of this compared to the vanilla IAction is the fact that it uses reflection under the hood. This may cause compatibility issues on certain platforms, and is slightly slower.
An interface to manipulate account states with maintaining the set of UpdatedAddresses.
It is like a map which is virtually initialized such
that every possible Address exists and
is mapped to
null. That means that:
An in-game action. Every action should be replayable, because multiple nodes in a network should execute an action and get the same result.
A “class” which implements this interface is analogous to a function, and its instance is analogous to a partial function application, in other words, a function with some bound arguments. Those parameters that will be bound at runtime should be represented as fields or properties in an action class, and bound argument values to these parameters should be received through a constructor parameters of that class.
From a perspective of security, an action class belongs to the network protocol, and property values in an action belong to a node's will (i.e., a user/player's choice). That means if you define an action class it also defines what every honest node can do in the network. Even if a malicious node changes their own action code it won't affect other honest nodes in the network.
For example, where honest nodes share the common action
Heal(Target) => PreviousStates[Target] + 1, suppose a malicious
m changes their own
Heal action code to
Heal(Target) => PreviousStates[Target] + 2 (2 instead of 1),
and then send an action
Fortunately, this action does not work as
because the changed code in itself is not used by other honest nodes,
so they still increase only 1, not 2. The effect of that double healing
is a sort of “illusion” only visible to the malicious node
In conclusion, action code is a part of the protocol and it works with consensus in the network, so only things each node can affect the network in general is property values of each action they sign and send, not code of an action.
Contextual data determined by a transaction and a block. Passed to Execute(IActionContext) method.
An pseudorandom number generator interface equivalent to Random.
Although these two types have similar shapes, they are not compatible (i.e., disallowed to be casted to each other).
An delegate to provide read-only view of account states.
Gets an account state of the given
If the given
address has never been set
its account status, returns
null instead of throwing