Struct McAuthorisationToken 

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

The Willow authorisation token provided by Meadowcap.

There are two main ways of creating these: if you yourself want to authorise an entry, you can use the new_for_entry method. If you want to verify incoming data, use the McAuthorisationToken::new method.

Examples

Authorising an entry of your own:

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 cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);
let ingredients = McIngredients::new(cap, AlfieSecret).unwrap();

let auth_token = McAuthorisationToken::new_for_entry(&alfies_entry, &ingredients).unwrap();

assert!(auth_token.does_authorise(&alfies_entry));

Verifying an untrusted entry:

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 alfies_cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

let auth_token = McAuthorisationToken::<4, 4, 4, _, _, _, _, TestSubspaceSecret>::new(alfies_cap, AlfieSignature);

assert!(auth_token.does_authorise(&alfies_entry));

Implementations

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

pub fn new( capability: WriteCapability<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature>, signature: UserSignature, ) -> Self

Manually creates a new McAuthorisationToken (as opposed to using AuthorisationToken::new_for_entry).

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 alfies_cap = WriteCapability::<
    4, 4, 4,
    TestNamespace,
    TestNamespaceSignature,
    TestSubspace,
    TestSubspaceSignature,
>::new_communal(Family, Alfie);

let auth_token = McAuthorisationToken::<4, 4, 4, _, _, _, _, TestSubspaceSecret>::new(alfies_cap, AlfieSignature);

assert!(auth_token.does_authorise(&alfies_entry));

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

Returns a reference to the write capability.

pub fn signature(&self) -> &UserSignature

Returns a reference to the signature.

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

Takes ownership of the authorisation token and returns its capability and signature by value.

Trait Implementations

impl<const MCL: usize, const MCC: usize, const MPL: usize, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature, UserKeypair, PD> AuthorisationToken<MCL, MCC, MPL, NamespacePublicKey, UserPublicKey, PD> for McAuthorisationToken<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature, UserKeypair>

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

type Ingredients = McIngredients<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature, UserKeypair>

The type of the information you need in order to authorise an entry. For example, in Meadowcap, this would be a pair of a capability and a secret key.

type CreationError = DoesNotAuthorise

Everything that can go wrong when trying to create a new authorisation token from some Ingredients for some entry.

fn new_for_entry<E>( entry: &E, ingredients: &Self::Ingredients, ) -> Result<Self, Self::CreationError>

where E: EntrylikeExt<MCL, MCC, MPL, NamespacePublicKey, UserPublicKey, PD> + ?Sized,

Creates an authorisation token for the given entry, if possible.

fn does_authorise<E>(&self, entry: &E) -> bool

where E: EntrylikeExt<MCL, MCC, MPL, NamespacePublicKey, UserPublicKey, PD> + ?Sized,

Determines whether self authorises the given entry.

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

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

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, UserKeypair> Debug for McAuthorisationToken<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature, UserKeypair>

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: Hash, NamespaceSignature: Hash, UserPublicKey: Hash, UserSignature: Hash, UserKeypair: Hash> Hash for McAuthorisationToken<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature, UserKeypair>

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, UserKeypair: PartialEq> PartialEq for McAuthorisationToken<MCL, MCC, MPL, NamespacePublicKey, NamespaceSignature, UserPublicKey, UserSignature, UserKeypair>

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

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