Struct fadroma::scrt::permit::Permit

pub struct Permit<P: Permission> {
    pub params: PermitParams<P>,
    pub address: String,
}

The type the represents a signed permit. You shouldn’t try to instantiate this type yourself unless you are writing test code. Rather you set this as a parameter in your contract query functions that you wish to authenticate.

Fields

params: PermitParams<P>

address: String

Implementations

impl<P: Permission> Permit<P>

pub fn new(signer: impl Into<String>, params: PermitParams<P>) -> Self

Creates a new instance using the given params and signer which is the address that “signed” the permit. This method is only useful in test code to create mock a permit.

impl<P: Permission> Permit<P>

pub fn validate( &self, deps: Deps<'_>, current_contract_addr: &str, hrp: Option<&str>, expected_permissions: &[P] ) -> StdResult<String>

Validates the permit by checking whether it contains the expected permissions, the current_contract_addr is allowed, the permit hasn’t been revoked (based on its name) and veryfing the cryptographic signature. If any of these prerequisites fails, an error is returned. Otherwise, returns the address that signed the permit.

Parameters:

• deps: Needed to check whether the permit has been revoked and verify signature.
• current_contract_addr: The contract address that is calling this function i.e env.contract.address.
• hrp: The address prefix i.e the “secret” part of the address “secret1k0jntykt7e4g3y88ltc60czgjuqdy4c9e8fzek”. Should be left as None most of the time.
• expected_permissions: The permission set that the permit needs to contains in order to successfully pass verification. Pass an empty slice (&[]) if you don’t need to check permissions.

pub fn assert_not_revoked( storage: &dyn Storage, account: &str, permit_name: &str ) -> StdResult<()>

Checks if the permit has been revoked based on the permit_name parameter. This is already being called by Permit::validate.

pub fn revoke(storage: &mut dyn Storage, account: &Addr, permit_name: &str)

Mark any permit with permit_name that is signed by account as revoked. Any such permit will fail verification.

pub fn has_permission(&self, permission: &P) -> bool

Check if the permit contains the given permission. This is already being called by Permit::validate.

pub fn is_for_contract(&self, contract: &str) -> bool

Check if the given contract address is allowed to use this permit. This is already being called by Permit::validate.

Trait Implementations

impl<P: Clone + Permission> Clone for Permit<P>

fn clone(&self) -> Permit<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug + Permission> Debug for Permit<P>

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

Formats the value using the given formatter.

impl<'de, P> Deserialize<'de> for Permit<P>where P: Deserialize<'de> + Permission,

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

Deserialize this value from the given Serde deserializer.

impl<P: Permission + JsonSchema> JsonSchema for Permit<P>

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl<P: PartialEq + Permission> PartialEq<Permit<P>> for Permit<P>

fn eq(&self, other: &Permit<P>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<P> Serialize for Permit<P>where P: Serialize + Permission,

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

Serialize this value into the given Serde serializer.

impl<P: Permission> StructuralPartialEq for Permit<P>