Struct DomainRecord 

pub struct DomainRecord {
    pub reference: DomainRecordRef,
    pub owner: String,
    pub class: DomainRecordClass,
    pub version: u64,
    pub lifecycle: DomainRecordLifecycle,
    pub payload: Value,
    pub references: Vec<DomainReference>,
}

Fields

reference: DomainRecordRef

owner: String

class: DomainRecordClass

version: u64

lifecycle: DomainRecordLifecycle

payload: Value

references: Vec<DomainReference>

Implementations

impl DomainRecord

pub const fn is_deleted(&self) -> bool

pub const fn is_active(&self) -> bool

Examples found in repository

examples/governance_transition.rs (line 398)

fn audit_order(
    view: &SimulationView<'_>,
    context: &BoundaryContext,
) -> Result<BoundaryProposal, CanwuError> {
    if owned_order_ingress(view, context, CENTRAL_PLUGIN, ISSUE_INGRESS)?.is_some() {
        return Ok(BoundaryProposal::default());
    }
    let order = order_payload(view)?;
    for (label, reference, expected_plugin, expected_system) in [
        (
            "treasury",
            treasury_reference().as_untyped(),
            TREASURY_PLUGIN,
            "prepare-treasury",
        ),
        (
            "county",
            county_reference().as_untyped(),
            COUNTY_PLUGIN,
            "prepare-county",
        ),
    ] {
        let record = view.domain_record(reference)?.ok_or_else(|| {
            CanwuError::new(
                ErrorCode::InvalidBoundary,
                format!("central audit is missing the {label} relief disposition"),
            )
        })?;
        let expected_hash = action_hash(600)?;
        validate_order(&order, expected_system, expected_plugin, &expected_hash)?;
        let actual_hash = canonical_hash(ACTION_HASH_DOMAIN, &record.payload)?;
        if record.version != 1
            || !record.is_active()
            || record.owner != expected_plugin
            || actual_hash != expected_hash
            || record.payload != json!({"status": "committed", "grain_units": 600})
        {
            return Err(CanwuError::new(
                ErrorCode::InvalidBoundary,
                format!("central audit found an invalid {label} disposition"),
            ));
        }
    }
    Ok(BoundaryProposal::default())
}

pub fn typed_reference<T>(&self) -> Option<TypedDomainRecordRef<T>>

where T: DomainRecordType,

pub fn decode_payload<T>( &self, ) -> Result<<T as DomainRecordType>::Payload, CanwuError>

where T: DomainRecordType, <T as DomainRecordType>::Payload: DeserializeOwned,

Examples found in repository

examples/governance_transition.rs (line 213)

fn order_payload(view: &SimulationView<'_>) -> Result<ReliefOrder, CanwuError> {
    view.typed_domain_record(&order_reference())?
        .ok_or_else(|| CanwuError::new(ErrorCode::InvalidBoundary, "relief order is missing"))?
        .decode_payload::<ReliefOrderRecord>()
}

Trait Implementations

impl Clone for DomainRecord

fn clone(&self) -> DomainRecord

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DomainRecord

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DomainRecord

fn deserialize<__D>( __deserializer: __D, ) -> Result<DomainRecord, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DomainRecord

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for DomainRecord

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DomainRecord