Crate pallet_asset_management
source ·Expand description
Asset_Management Pallet
The Asset_Management pallet is used for everything that is related to the asset management by its owners.
Overview
The Asset_Management gives the possibility to the asset Owners, through governance, to implement the following actions:
- Elect a Representative that will micro-manage the asset
- Demote a previously elected Representative
- Allow the representative to submit a list of Tenants to the Owners
- Allow the owners to vote on list of tenants submitted by the Representative
Dispatchable Functions
-
launch_representative_session- An Owner creates a referendum for the following available proposals:- Elect a Representative.
- Demote a Representative.
-
owners_vote- Each asset owner can vote in an ongoing referendum. -
request_asset_management- An active Representative can request an additional asset to manage. -
representative_approval- Call used as a proposal for Representative election. -
demote_representative- Call used as a proposal for Representative demotion. -
launch_tenant_session- A Representative creates a referendum for the following available proposals:- Admit a Tenant for a given asset.
- Evict a Tenant from a given asset.
The Representative has to submit a judgement about the tenant profile. This judgement
will be considered by the owners before voting.
Representatives receive a judgement fee from the aspiring tenant.
A positive result of the referendum will send a guaranty_deposit payment request to the
tenant. When the tenant finally pays the guaranty_deposit,his account is connected to the
asset through
link_tenant_to_assetand this marks the start of his contract with the owners.
-
link_tenant_to_asset- Call used as a proposal to link an accepted tenant with an existing asset. -
unlink_tenant_to_asset- Call used as a proposal to remove the link between a tenant and an asset. -
request_guaranty_payment- Call used to send a guaranty deposit payment request to a tenant.
Re-exports
pub use pallet_assets as Assetss;pub use pallet_democracy as Dem;pub use pallet_housing_fund as HFund;pub use pallet_identity as Ident;pub use pallet_nft as Nft;pub use pallet_onboarding as Onboarding;pub use pallet_payment as Payment;pub use pallet_roles as Roles;pub use pallet::*;pub use super::*;pub use super::*;Modules
Operation on runtime child storages.
Stuff to do with the runtime’s storage.
A contiguous growable array type with heap-allocated contents, written
Vec<T>.Macros
Panic if an expression doesn’t evaluate to
Ok.Evaluate
$x:expr and if not true return Err($y:expr).Structs
An error type that indicates that the origin is invalid.
Hash storage keys with blake2 128
Hash storage keys with
concat(blake2_128(key), key)Hash storage keys with blake2 256
Blake2-256 Hash implementation.
A bounded vector.
A pointer type that uniquely owns a heap allocation of type
T.Const getter for a basic type.
A wrapper around a
StorageMap and a StorageValue<Value=u32> to keep track of how many items
are in a map, without needing to iterate all the values.A fixed point number representation in the range.
Fixed Point 128 bits unsigned, range = [0.000000000000000000, 340282366920938463463.374607431768211455]
Implement Get by returning Default for any type that implements Default.
Fixed-size uninterpreted hash type with 32 bytes (256 bits) size.
Store the key directly.
A lookup implementation returning the input value.
Inherent data to include in a block.
A type used exclusively by storage maps as their key type.
Implement QueryKindTrait with query being
Option<Value>A pallet identifier. These are per pallet and should be stored in a registry somewhere.
A fixed point representation of a number in the range [0, 1].
A fixed point representation of a number in the range [0, 1].
Zero-sized type used to mark things that “act like” they own a
T.Implement QueryKindTrait with query being
Result<Value, PalletError>A type that allow to store values for
(key1, key2) couple. Similar to StorageMap but allow
to iterate and remove value associated to first key.A type that allow to store value for given key. Allowing to insert/remove/iterate on values.
A type that allow to store values for an arbitrary number of keys in the form of
(Key<Hasher1, key1>, Key<Hasher2, key2>, ..., Key<HasherN, keyN>).A type that allow to store a value.
The storage version of a pallet.
Hash storage keys with
concat(twox64(key), key)Hash storage keys with twox 128
Hash storage keys with twox 256
Information concerning a valid transaction.
Implement QueryKindTrait with query being
ValueA contiguous growable array type, written as
Vec<T>, short for ‘vector’.Reasons for moving funds out of an account.
Enums
A generalized group of dispatch types.
Reason why a dispatch call failed.
Simple boolean for whether an account needs to be kept in existence.
An invalid transaction validity.
Explicit enum to denote if a transaction pays fee or not.
Origin for the System pallet.
The source of the transaction.
Errors that can occur while checking the validity of a transaction.
An unknown transaction validity.
Constants
The number of bytes of the module-specific
error field defined in [ModuleError].
In FRAME, this is the maximum encoded size of a pallet error type.Traits
This type can be converted into and possibly from an AccountId (which itself is generic).
A trait for querying whether a type can be said to “contain” a value.
Abstraction over a fungible assets system.
Trait that allows zero-copy read of value-references from slices in LE format.
Trait that allows zero-copy write of value-references to slices in LE format.
A marker trait that tells the compiler that a type encode to the same representation as another
type.
Some sort of check on the origin is performed by this object.
A trait to define the build function of a genesis config, T and I are placeholder for pallet
trait and pallet instance.
A trait for querying a single value from a type.
A
Dispatchable function (aka transaction) that can carry some static information along with
it, using the #[weight] attribute.Provides information about the storage version of a pallet.
Abstraction around hashing
The pallet hooks trait. Implementing this lets you express some logic to execute.
Trait to be used when types are exactly same.
A currency whose accounts can have liquidity restrictions.
Items implementing
MaxEncodedLen have a statically known maximum encoded size.A type that implements Serialize, DeserializeOwned and Debug when in std environment.
A type that can be used in runtime structures.
Defines a multiplicative identity element for
Self.Provides information about the pallet itself and its setup in the runtime.
A type that can be used as a parameter in a dispatchable function.
trait that defines how to create/release payments for users
Something that implements a fixed point ration with an arbitrary granularity
X, as parts per
X.A pallet that provides or verifies an inherent extrinsic will implement this trait.
A currency where funds can be reserved from the user.
Saturating arithmetic operations, returning maximum or minimum values instead of overflowing.
Means of changing one type into another in a manner dependent on the source type.
This variant is different to
Lookup in that it doesn’t (can cannot) require any
context.A trait to give information about storage.
Implementors return their meta type information.
A trait for querying a single value from a type defined in the trait.
Type that can be dispatched with an origin but without checking the origin filter.
Something that can validate unsigned extrinsics for the transaction pool.
Defines an additive identity element for
Self.Functions
Ensure that the origin
o represents an unsigned extrinsic. Returns Ok or an Err otherwise.Ensure that the origin
o represents the root. Returns Ok or an Err otherwise.Ensure that the origin
o represents a signed extrinsic (i.e. transaction).
Returns Ok with the account that signed the extrinsic or an Err otherwise.Ensure that the origin
o represents either a signed extrinsic (i.e. transaction) or the root.
Returns Ok with the account that signed the extrinsic, None if it was root, or an Err
otherwise.Type Definitions
Type alias for the
BlockNumber associated type of system config.Unaugmented version of
DispatchResultWithPostInfo that can be returned from
dispatchable functions and is automatically converted to the augmented type. Should be
used whenever the PostDispatchInfo does not need to be overwritten. As this should
be the common case it is the implicit return type when none is specified.The return type of a
Dispatchable in frame. When returned explicitly from
a dispatchable function it allows overriding the default PostDispatchInfo
returned from a dispatch.An identifier for an inherent.
Type alias for the
Origin associated type of system config.Minimum number of blocks a transaction will remain valid for.
TransactionLongevity::max_value() means “forever”.Priority for a transaction. Additive. Higher is better.
Tag for a transaction. No two transactions with the same tag should be placed on-chain.
Information on a transaction’s validity and, if valid, on how it relates to other transactions.
Derive Macros
Derive
Clone but do not bound any generic. Docs are at frame_support::CloneNoBound.Derive
Debug but do not bound any generics. Docs are at frame_support::DebugNoBound.Derive
parity_scale_codec::Decode and for struct and enum.Derive
parity_scale_codec::Encode and parity_scale_codec::EncodeLike for struct and enum.derive Eq but do no bound any generic. Docs are at
frame_support::EqNoBound.Derive
parity_scale_codec::MaxEncodedLen for struct and enum.Derive
PartialEq but do not bound any generic. Docs are at
frame_support::PartialEqNoBound.Derive
Debug, if std is enabled it uses frame_support::DebugNoBound, if std is not
enabled it just returns "<stripped>".
This behaviour is useful to prevent bloating the runtime WASM blob from unneeded code.