Struct near_primitives_core::account::AccessKey

pub struct AccessKey {
    pub nonce: Nonce,
    pub permission: AccessKeyPermission,
}

Access key provides limited access to an account. Each access key belongs to some account and is identified by a unique (within the account) public key. One account may have large number of access keys. Access keys allow to act on behalf of the account by restricting transactions that can be issued. account_id,public_key is a key in the state

Fields

nonce: Nonce

The nonce for this access key. NOTE: In some cases the access key needs to be recreated. If the new access key reuses the same public key, the nonce of the new access key should be equal to the nonce of the old access key. It's required to avoid replaying old transactions again.

permission: AccessKeyPermission

Defines permissions for this access key.

Implementations

impl AccessKey

pub fn full_access() -> Self

Trait Implementations

impl BorshDeserialize for AccessKey where
    Nonce: BorshDeserialize,
    AccessKeyPermission: BorshDeserialize, 

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

pub fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

pub fn is_u8() -> bool

Whether Self is u8. NOTE: Vec<u8> is the most common use-case for serialization and deserialization, it's worth handling it as a special case to improve performance. It's a workaround for specific Vec<u8> implementation versus generic Vec<T> implementation. See https://github.com/rust-lang/rfcs/pull/1210 for details.

impl BorshSerialize for AccessKey where
    Nonce: BorshSerialize,
    AccessKeyPermission: BorshSerialize, 

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

pub fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

pub fn is_u8() -> bool

Whether Self is u8. NOTE: Vec<u8> is the most common use-case for serialization and deserialization, it's worth handling it as a special case to improve performance. It's a workaround for specific Vec<u8> implementation versus generic Vec<T> implementation. See https://github.com/rust-lang/rfcs/pull/1210 for details.

impl Clone for AccessKey

fn clone(&self) -> AccessKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AccessKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AccessKey

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

Deserialize this value from the given Serde deserializer.

impl Eq for AccessKey

impl Hash for AccessKey

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl PartialEq<AccessKey> for AccessKey

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

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

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

This method tests for !=.

impl Serialize for AccessKey

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

Serialize this value into the given Serde serializer.

impl StructuralEq for AccessKey

impl StructuralPartialEq for AccessKey