Namespace Libplanet.Action
Classes
AccountMetrics
ActionEvaluation
A record type to represent an evaluation plan and result of a single action.
ActionEvaluator
Class responsible for handling of IAction evaluations.
ActionsExtensions
ActionTypeAttribute
Indicates that an action class (i.e., a class implementing IAction) can be held by transactions and blocks. It also gives an action class a TypeIdentifier for serialization and deserialization.
BlockProtocolVersionNotSupportedException
The exception that is thrown when an IPreEvaluationBlock with a protocol version that is not supported by an implementation of IActionEvaluator is passed as an argument to Evaluate(IPreEvaluationBlock, Nullable<HashDigest<SHA256>>).
CommittedActionContext
CommittedActionEvaluation
A record type to represent an evaluation plan and result of a single action.
DuplicateActionTypeIdentifierException
An exception that is thrown when multiple action types are associated with the same TypeIdentifier.
GasLimitExceededException
GasLimitNegativeException
GasTracer
Provides a way to trace the gas usage of an ITransaction. It will be initialize each transaction.
GasTracer is thread-local, so it can be used in a multi-threaded environment.
GasUseNegativeException
InvalidActionException
The
NullAction
An action implementation which does nothing for filling type parameter taking of IAction.
PolicyActionsRegistry
RandomExtensions
This extension class provides some convenient methods to deal with IRandom.
UnexpectedlyTerminatedActionException
The exception that is thrown during an IAction is being evaluated.
The actual exception that the Action threw
is stored in the
Interfaces
IAction
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) => PreviousState[Target] + 1, suppose a malicious
node m changes their own Heal action code to
Heal(Target) => PreviousState[Target] + 2 (2 instead of 1),
and then send an action Heal(m).
Fortunately, this action does not work as m's intention,
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
alone.
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.
IActionContext
Contextual data determined by a transaction and a block. Passed to Execute(IActionContext) method.
IActionEvaluation
IActionEvaluator
IActionTypeLoaderContext
An interface to provide contextual variables to load action types.
ICommittedActionContext
Contextual data determined by a transaction and a block for rendering.
ICommittedActionEvaluation
IGasMeter
An interface to provide a transition of the gas usage.
IPolicyActionsRegistry
IRandom
An pseudorandom number generator interface equivalent to
Although these two types have similar shapes, they are not compatible (i.e., disallowed to be casted to each other).