Struct WriteCapability 

pub struct WriteCapability<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> { /* private fields */ }

A valid write capability.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::*;

let mut cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert_eq!(cap.receiver(), &Alfie);

cap.delegate(&AlfieSecret, Area::new_subspace_area(Alfie), Betty);

assert_eq!(cap.receiver(), &Betty);

Implementations

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

pub fn receiver(&self) -> &UserPublicKey

Returns the receiver of this capability.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::*;

let cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert_eq!(cap.receiver(), &Alfie);

pub fn granted_namespace(&self) -> &NamespacePublicKey

Returns the namespace id to which this grants access.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::*;

let cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert_eq!(cap.granted_namespace(), &Family);

pub fn granted_area_ref(&self) -> Option<&Area<MCL, MCC, MPL, UserPublicKey>>

Returns a reference to the area to which this grants access, or None if there is no delegation step which restricts the initial area.

This method is slightly inconvenient to work with (you need special logic if there are no delegation steps), but it is efficient because it never explicitly creates a new area value. For the more convenient version, see granted_area.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::{*, raw::Delegation};

let mut cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert_eq!(cap.granted_area_ref(), None);

cap.delegate(&AlfieSecret, Area::new_subspace_area(Alfie), Betty);

assert_eq!(cap.granted_area_ref(), Some(&Area::new_subspace_area(Alfie)));

pub fn genesis( &self, ) -> &Genesis<NamespacePublicKey, NamespaceSignature, UserPublicKey>

Returns the Genesis of this capability.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::{*, raw::*};

let cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert_eq!(
    cap.genesis(),
    &Genesis::Communal(CommunalGenesis {
        access_mode: AccessMode::Write,
        namespace_key: Family,
        user_key: Alfie,
    }),
);

pub fn is_owned(&self) -> bool

Returns true if and only if this is an owned capability.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::*;

let owncap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_owned(&FamilySecret, Alfie);

assert!(owncap.is_owned());

let comcap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert!(!comcap.is_owned());

pub fn delegations( &self, ) -> &[Delegation<MCL, MCC, MPL, UserPublicKey, UserSignature>]

Returns the Delegations of this capability as a slice.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::{*, raw::Delegation};

let mut cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert!(cap.delegations().is_empty());

cap.delegate(&AlfieSecret, Area::new_subspace_area(Alfie), Betty);

assert_eq!(cap.delegations().len(), 1);

pub fn new_communal( namespace_key: NamespacePublicKey, user_key: UserPublicKey, ) -> Self

Creates a new communal write capability with no delegations.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::*;

let cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert!(!cap.is_owned());
assert_eq!(cap.receiver(), &Alfie);
assert_eq!(cap.granted_namespace(), &Family);
assert_eq!(cap.granted_area(), Area::new_subspace_area(Alfie));
assert!(cap.delegations().is_empty());

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where NamespacePublicKey: Clone, UserPublicKey: EncodableKnownLength,

pub fn new_owned<NamespaceKeypair>( keypair: &NamespaceKeypair, user_key: UserPublicKey, ) -> Self

where NamespaceKeypair: Signer<NamespaceSignature> + Keypair<VerifyingKey = NamespacePublicKey>,

Creates a new owned write capability with no delegations.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::*;

let cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_owned(&FamilySecret, Alfie);

assert!(cap.is_owned());
assert_eq!(cap.receiver(), &Alfie);
assert_eq!(cap.granted_namespace(), &Family);
assert_eq!(cap.granted_area(), Area::full());
assert!(cap.delegations().is_empty());

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where UserPublicKey: PartialEq,

pub fn includes_area(&self, area: &Area<MCL, MCC, MPL, UserPublicKey>) -> bool

Returns whether the given area is contained in the granted area of this capability.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::*;

let mut cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert!(cap.includes_area(&Area::new_subspace_area(Alfie)));
assert!(!cap.includes_area(&Area::full()));

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where UserPublicKey: PartialEq + Clone,

pub fn granted_area(&self) -> Area<MCL, MCC, MPL, UserPublicKey>

Returns by value the area to which this grants access.

Prefer using includes, includes_area or granted_area_ref whenever applicable, as these are more efficient.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::{*, raw::Delegation};

let mut cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert_eq!(cap.granted_area(), Area::new_subspace_area(Alfie));

cap.delegate(&AlfieSecret, Area::new_subspace_area(Alfie), Betty);

assert_eq!(cap.granted_area(), Area::new_subspace_area(Alfie));

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where UserPublicKey: PartialEq, NamespacePublicKey: PartialEq,

pub fn includes<T>(&self, t: &T) -> bool

where T: Namespaced<NamespacePublicKey> + Coordinatelike<MCL, MCC, MPL, UserPublicKey> + ?Sized,

Returns whether the given namespaced coordinate is covered by this capability.

use willow_data_model::{prelude::*, test_parameters::*};
use meadowcap::*;

let alfies_entry = Entry::builder()
    .namespace_id(Family)
    .subspace_id(Alfie)
    .path(Path::<4, 4, 4>::new())
    .timestamp(12345)
    .payload_digest(Spades)
    .payload_length(2)
    .build().unwrap();

let bettys_entry = Entry::prefilled_builder(&alfies_entry)
    .subspace_id(Betty)
    .build().unwrap();

let mut cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

assert!(cap.includes(&alfies_entry));
assert!(!cap.includes(&bettys_entry));

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where NamespacePublicKey: Verifier<NamespaceSignature> + EncodableKnownLength, NamespaceSignature: EncodableKnownLength, UserPublicKey: Verifier<UserSignature> + EncodableKnownLength + PartialEq + Clone, UserSignature: EncodableKnownLength,

pub fn try_delegate<UserKeypair>( &mut self, keypair: &UserKeypair, new_area: Area<MCL, MCC, MPL, UserPublicKey>, new_receiver: UserPublicKey, ) -> Result<(), InvalidCapability>

where UserKeypair: Signer<UserSignature> + Keypair<VerifyingKey = UserPublicKey>,

Delegates this capability, returning an error if the resulting granted area would not be included in the previous granted area, or if the public key of the keypair was not the receiver of the capability pre-delegation.

pub fn delegate<UserKeypair>( &mut self, keypair: &UserKeypair, new_area: Area<MCL, MCC, MPL, UserPublicKey>, new_receiver: UserPublicKey, )

where UserKeypair: Signer<UserSignature> + Keypair<VerifyingKey = UserPublicKey>,

Delegates this capability, panicking if the resulting granted area would not be included in the previous granted area, or if the public key of the keypair was not the receiver of the capability pre-delegation.

Trait Implementations

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey: Clone, NamespaceSignature: Clone, UserPublicKey: Clone, UserSignature: Clone> Clone for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

fn clone( &self, ) -> WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> Debug for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where NamespacePublicKey: Debug, NamespaceSignature: Debug, UserPublicKey: Debug, UserSignature: Debug,

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

Formats the value using the given formatter.

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> Decodable for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where NamespacePublicKey: Verifier<NamespaceSignature> + EncodableKnownLength + DecodableCanonic<ErrorCanonic: Into<Blame>>, NamespaceSignature: EncodableKnownLength + DecodableCanonic<ErrorCanonic: Into<Blame>>, UserPublicKey: Verifier<UserSignature> + EncodableKnownLength + DecodableCanonic<ErrorReason: Into<Blame>, ErrorCanonic: Into<Blame>> + Clone + PartialEq, UserSignature: EncodableKnownLength + DecodableCanonic<ErrorCanonic: Into<Blame>>,

Implements decoding according to the EncodeMcCapability encoding relation, and further errors if the decoded capability is a read capability.

type ErrorReason = Blame

Reason why decoding can fail (beyond an unexpected end of input or a producer error).

async fn decode<P>( producer: &mut P, ) -> Result<Self, DecodeError<P::Final, P::Error, Self::ErrorReason>>

where P: BulkProducer<Item = u8> + ?Sized, Self: Sized,

Decodes the symbols produced by the given bulk producer into a Self, or yields an error if the producer does not produce a valid encoding.

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> DecodableCanonic for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where NamespacePublicKey: Verifier<NamespaceSignature> + EncodableKnownLength + DecodableCanonic<ErrorCanonic: Into<Blame>>, NamespaceSignature: EncodableKnownLength + DecodableCanonic<ErrorCanonic: Into<Blame>>, UserPublicKey: Verifier<UserSignature> + EncodableKnownLength + DecodableCanonic<ErrorReason: Into<Blame>, ErrorCanonic: Into<Blame>> + Clone + PartialEq, UserSignature: EncodableKnownLength + DecodableCanonic<ErrorCanonic: Into<Blame>>,

Implements decoding according to the encode_mc_capability encoding function, and further errors if the decoded capability is a read capability.

type ErrorCanonic = Blame

The type for reporting that the sequence of symbols to decode was not a valid canonic encoding of any value of type Self.

async fn decode_canonic<P>( producer: &mut P, ) -> Result<Self, DecodeError<P::Final, P::Error, Self::ErrorCanonic>>

where P: BulkProducer<Item = u8> + ?Sized, Self: Sized,

Decodes the symbols produced by the given bulk producer into a Self, and errors if the input encoding is not the canonical one.

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> Encodable for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where NamespacePublicKey: Encodable, NamespaceSignature: Encodable, UserPublicKey: Encodable + PartialEq + Clone, UserSignature: Encodable,

Implements encoding according to the encode_mc_capability encoding function.

async fn encode<C>(&self, consumer: &mut C) -> Result<(), C::Error>

where C: BulkConsumer<Item = u8> + ?Sized,

Writes an encoding of &self into the given bulk consumer.

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> EncodableKnownLength for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

where NamespacePublicKey: EncodableKnownLength, NamespaceSignature: EncodableKnownLength, UserPublicKey: EncodableKnownLength + PartialEq + Clone, UserSignature: EncodableKnownLength,

fn len_of_encoding(&self) -> usize

Computes the number of symbols of the encoding of self. A successful call to encode must feed exactly that many symbols into the bulk consumer.

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> From<WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>> for PossiblyValidWriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

fn from( value: WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>, ) -> Self

Converts to this type from the input type.

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey: Hash, NamespaceSignature: Hash, UserPublicKey: Hash, UserSignature: Hash> Hash for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey: PartialEq, NamespaceSignature: PartialEq, UserPublicKey: PartialEq, UserSignature: PartialEq> PartialEq for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

fn eq( &self, other: &WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>, ) -> 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<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey: Eq, NamespaceSignature: Eq, UserPublicKey: Eq, UserSignature: Eq> Eq for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature> StructuralPartialEq for WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>