Struct names::Module

pub struct Module<T: Trait>(_);

Methods

impl<T: Trait + 'static> Module<T>

pub fn lookup<K: EncodeLike<T::Name>>(key: K) -> Option<NameData<T>>

The main mapping from names to associated data.

impl<T: Trait> Module<T>

Can also be called using Call.

pub fn update(
    origin: T::Origin,
    name: T::Name,
    value: T::Value
) -> DispatchResult

Tries to update a name with a given value.

If the name does not exist yet, it will be created. If the name exists, then only the current owner can update it.

pub fn transfer(
    origin: T::Origin,
    name: T::Name,
    recipient: T::AccountId
) -> DispatchResult

Tries to transfer a name to a given recipient.

If the name does not exist, it will be registered directly to them with a default value.

impl<T: Trait> Module<T>

pub fn check_assuming_signed(
    sender: T::AccountId,
    name: T::Name,
    value: Option<T::Value>,
    recipient: Option<T::AccountId>
) -> Result<Operation<T>, &'static str>

Checks if a name operation is valid, assuming that we already know it was signed by the given account.

Value and recipient are optional. If the value is missing, we use the existing value or the default value if the name does not exist yet. If the recipient is missing, we set it to the sender account.

This function returns either an error if the operation is not valid, or the data that should be passed to execute later on if the transaction is valid.

pub fn execute(op: Operation<T>) -> DispatchResult

Executes the state change (and fires events) for a given name operation.

This should be called after check_assuming_signed (passing its result), and when potential other checks have been done as well.

This function may actually fail (return an error) if the fee withdrawal is not possible. This can happen if some funds were spent externally between the call to check_assuming_signed and this function. If that happens, then execute will be a noop.

Trait Implementations

impl<T: Trait> Callable<T> for Module<T>

type Call = Call<T>

impl<T: Clone + Trait> Clone for Module<T>

fn clone(&self) -> Module<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Trait> Copy for Module<T>

impl<T: Trait> Debug for Module<T> where
    T: Debug, 

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Eq + Trait> Eq for Module<T>

impl<T: Trait> ModuleErrorMetadata for Module<T>

fn metadata() -> &'static [ErrorMetadata]

impl<T: Trait> OffchainWorker<<T as Trait>::BlockNumber> for Module<T>

fn offchain_worker(_n: BlockNumber)

This function is being called after every block import (when fully synced).

impl<T: Trait> OnFinalize<<T as Trait>::BlockNumber> for Module<T>

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

impl<T: Trait> OnInitialize<<T as Trait>::BlockNumber> for Module<T>

fn on_initialize(h: T::BlockNumber)

The block is being initialized. Implement to have something happen.

impl<T: PartialEq + Trait> PartialEq<Module<T>> for Module<T>

fn eq(&self, other: &Module<T>) -> bool

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

fn ne(&self, other: &Module<T>) -> bool

This method tests for !=.

impl<T: Trait> StructuralEq for Module<T>

impl<T: Trait> StructuralPartialEq for Module<T>

impl<T: Trait> WeighBlock<<T as Trait>::BlockNumber> for Module<T>

fn on_initialize(n: T::BlockNumber) -> Weight

Return the weight of the block's on_initialize hook.

fn on_finalize(BlockNumber) -> u32

Return the weight of the block's on_finalize hook.