Struct ExercisedEvent 

pub struct ExercisedEvent {

    pub offset: i64,
    pub node_id: i32,
    pub contract_id: String,
    pub template_id: String,
    pub interface_id: Option<String>,
    pub choice: String,
    pub choice_argument: Option<Value>,
    pub acting_parties: Vec<String>,
    pub consuming: bool,
    pub witness_parties: Vec<String>,
    pub last_descendant_node_id: i32,
    pub exercise_result: Option<Option<Value>>,
    pub package_name: String,
    pub implemented_interfaces: Option<Vec<String>>,
    pub acs_delta: bool,
}

ExercisedEvent : Records that a choice has been exercised on a target contract.

Fields

offset: i64

The offset of origin. Offsets are managed by the participant nodes. Transactions can thus NOT be assumed to have the same offsets on different participant nodes. It is a valid absolute offset (positive integer) Required

node_id: i32

The position of this event in the originating transaction or reassignment. Node IDs are not necessarily equal across participants, as these may see different projections/parts of transactions. Must be valid node ID (non-negative integer) Required

contract_id: String

The ID of the target contract. Must be a valid LedgerString (as described in value.proto). Required

template_id: String

Identifies the template that defines the executed choice. This template’s package-id may differ from the target contract’s package-id if the target contract has been upgraded or downgraded. The identifier uses the package-id reference format. Required

interface_id: Option<String>

The interface where the choice is defined, if inherited. If defined, the identifier uses the package-id reference format. Optional

choice: String

The choice that was exercised on the target contract. Must be a valid NameString (as described in value.proto). Required

choice_argument: Option<Value>

The argument of the exercised choice. Required

acting_parties: Vec<String>

The parties that exercised the choice. Each element must be a valid PartyIdString (as described in value.proto). Required: must be non-empty

consuming: bool

If true, the target contract may no longer be exercised. Required

witness_parties: Vec<String>

The parties that are notified of this event. The witnesses of an exercise node will depend on whether the exercise was consuming or not. If consuming, the witnesses are the union of the stakeholders, the actors and all informees of all the ancestors of this event this participant knows about. If not consuming, the witnesses are the union of the signatories, the actors and all informees of all the ancestors of this event this participant knows about. In both cases the witnesses are limited to the querying parties, or not limited in case anyParty filters are used. Note that the actors might not necessarily be observers and thus stakeholders. This is the case when the controllers of a choice are specified using "flexible controllers", using the choice ... controller syntax, and said controllers are not explicitly marked as observers. Each element must be a valid PartyIdString (as described in value.proto). Required: must be non-empty

last_descendant_node_id: i32

Specifies the upper boundary of the node ids of the events in the same transaction that appeared as a result of this ExercisedEvent. This allows unambiguous identification of all the members of the subtree rooted at this node. A full subtree can be constructed when all descendant nodes are present in the stream. If nodes are heavily filtered, it is only possible to determine if a node is in a consequent subtree or not. Required

exercise_result: Option<Option<Value>>

The result of exercising the choice. Optional

package_name: String

The package name of the contract. Required

implemented_interfaces: Option<Vec<String>>

If the event is consuming, the interfaces implemented by the target template that have been matched from the interface filter query. Populated only in case interface filters with include_interface_view set. The identifier uses the package-id reference format. Optional: can be empty

acs_delta: bool

Whether this event would be part of respective ACS_DELTA shaped stream, and should therefore considered when tracking contract activeness on the client-side. Required

Implementations

impl ExercisedEvent

pub fn new( offset: i64, node_id: i32, contract_id: String, template_id: String, choice: String, choice_argument: Option<Value>, acting_parties: Vec<String>, consuming: bool, witness_parties: Vec<String>, last_descendant_node_id: i32, package_name: String, acs_delta: bool, ) -> ExercisedEvent

Records that a choice has been exercised on a target contract.

Trait Implementations

impl Clone for ExercisedEvent

fn clone(&self) -> ExercisedEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExercisedEvent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ExercisedEvent

fn default() -> ExercisedEvent

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExercisedEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExercisedEvent

fn eq(&self, other: &ExercisedEvent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExercisedEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExercisedEvent