Struct smarthub_sdk::rent::RentFeature

pub struct RentFeature {
    pub approved_owner_by_id: Option<LookupMap<TokenId, AccountId>>,
    pub rents_current: TreeMap<TokenId, AccountId>,
    pub rents_pending: UnorderedSet<TokenId>,
    pub rents_by_id: TreeMap<TokenId, Rent>,
    pub rents_per_account: TreeMap<AccountId, UnorderedSet<TokenId>>,
    pub rents_end_by_id: LookupMap<TokenId, u64>,
    pub rent_tokens_per_account: LookupMap<AccountId, UnorderedSet<TokenId>>,
    pub rent_tokens_by_contract: TreeMap<AccountId, UnorderedSet<TokenId>>,
}

Fields

approved_owner_by_id: Option<LookupMap<TokenId, AccountId>>

rents_current: TreeMap<TokenId, AccountId>

rents_pending: UnorderedSet<TokenId>

rents_by_id: TreeMap<TokenId, Rent>

rents_per_account: TreeMap<AccountId, UnorderedSet<TokenId>>

rents_end_by_id: LookupMap<TokenId, u64>

rent_tokens_per_account: LookupMap<AccountId, UnorderedSet<TokenId>>

rent_tokens_by_contract: TreeMap<AccountId, UnorderedSet<TokenId>>

Implementations

impl RentFeature

pub fn new<R0, R1, R2, R3, R4, R5, R6, R7>(
    approved_owner_prefix: Option<R0>,
    rents_current_prefix: R1,
    rents_pending_prefix: R2,
    rents_by_id_prefix: R3,
    rent_tokens_per_account_prefix: R4,
    rents_per_account_prefix: R5,
    rents_at_prefix: R6,
    rent_tokens_by_contract_prefix: R7
) -> Selfwhere
    R0: IntoStorageKey,
    R1: IntoStorageKey,
    R2: IntoStorageKey,
    R3: IntoStorageKey,
    R4: IntoStorageKey,
    R5: IntoStorageKey,
    R6: IntoStorageKey,
    R7: IntoStorageKey,

impl RentFeature

pub fn internal_on_nft_approve(
    &mut self,
    args: &RentOnNftApproveArgs,
    contract_id: &AccountId,
    token_id: &TokenId,
    owner_id: &AccountId
) -> PromiseOrValue<String>

pub fn internal_on_ft_transfer(
    &mut self,
    args: &RentOnFtTransferArgs,
    ft_token_id: &AccountId,
    amount: &U128,
    sender_id: &AccountId
) -> PromiseOrValue<U128>

impl RentFeature

pub fn internal_process_purchase(
    &mut self,
    contract_id: &AccountId,
    token_id: &TokenId,
    buyer_id: &AccountId,
    receiver_id: &AccountId,
    time: &u64,
    ft_token_id: &AccountId,
    deposit: &U128
) -> Promise

pub fn internal_resolve_purchase(
    &mut self,
    contract_id: &AccountId,
    token_id: &TokenId,
    buyer_id: &AccountId,
    owner_id: &AccountId,
    receiver_id: &AccountId,
    time: &u64,
    end_time: &u64,
    ft_token_id: &AccountId,
    price: &U128
) -> U128

Trait Implementations

impl BorshDeserialize for RentFeaturewhere
    Option<LookupMap<TokenId, AccountId>>: BorshDeserialize,
    TreeMap<TokenId, AccountId>: BorshDeserialize,
    UnorderedSet<TokenId>: BorshDeserialize,
    TreeMap<TokenId, Rent>: BorshDeserialize,
    TreeMap<AccountId, UnorderedSet<TokenId>>: BorshDeserialize,
    LookupMap<TokenId, u64>: BorshDeserialize,
    LookupMap<AccountId, UnorderedSet<TokenId>>: 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.

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

Deserialize this instance from a slice of bytes.

impl BorshSerialize for RentFeaturewhere
    Option<LookupMap<TokenId, AccountId>>: BorshSerialize,
    TreeMap<TokenId, AccountId>: BorshSerialize,
    UnorderedSet<TokenId>: BorshSerialize,
    TreeMap<TokenId, Rent>: BorshSerialize,
    TreeMap<AccountId, UnorderedSet<TokenId>>: BorshSerialize,
    LookupMap<TokenId, u64>: BorshSerialize,
    LookupMap<AccountId, UnorderedSet<TokenId>>: BorshSerialize,

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

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

Serialize this instance into a vector of bytes.

impl RentFeatureCore for RentFeature

fn rent_token_is_locked(&self, contract_id: AccountId, token_id: TokenId) -> bool

fn rent_update(
    &mut self,
    contract_id: AccountId,
    token_id: TokenId,
    ft_token_id: &AccountId,
    price_per_hour: U128,
    min_time: u64,
    max_time: u64
)

fn rent_remove(&mut self, contract_id: AccountId, token_id: TokenId)

fn rent_pay(
    &mut self,
    contract_id: AccountId,
    token_id: TokenId,
    time: u64,
    receiver_id: AccountId
) -> Promise

fn rent_claim(&mut self, contract_id: AccountId, token_id: TokenId) -> Promise

fn rent_is_ended(&self, contract_id: AccountId, token_id: TokenId) -> bool

fn rent_total_supply(&self) -> u64

fn rent_is_approved(
    &self,
    contract_id: AccountId,
    token_id: TokenId,
    account_id: AccountId
) -> bool

impl RentFeatureEnumeration for RentFeature

fn rents(&self, from_index: Option<U128>, limit: Option<u64>) -> Vec<JsonRent>

fn rents_for_account(
    &self,
    account_id: AccountId,
    from_index: Option<U128>,
    limit: Option<u64>
) -> Vec<JsonRent>

fn rents_by_ids(&self, ids: Vec<TokenId>) -> Vec<JsonRent>

fn rents_supply_for_account(&self, account_id: AccountId) -> U128

fn rent(&self, contract_id: AccountId, token_id: TokenId) -> Option<JsonRent>

fn rented_tokens_for_account(
    &self,
    account_id: AccountId,
    from_index: Option<U128>,
    limit: Option<u64>
) -> Vec<JsonRent>

fn rented_tokens_supply_for_account(&self, account_id: AccountId) -> U128

fn rents_by_contract(
    &self,
    contract_id: AccountId,
    from_index: Option<U128>,
    limit: Option<u64>
) -> Vec<JsonRent>

fn rents_supply_by_contract(&self, contract_id: AccountId) -> U128

impl RentFeatureResolve for RentFeature

fn rent_resolve_pay(
    &mut self,
    contract_id: AccountId,
    token_id: TokenId,
    buyer_id: AccountId,
    owner_id: AccountId,
    receiver_id: AccountId,
    time: u64,
    end_time: u64,
    ft_token_id: AccountId,
    price: U128
) -> U128

fn rent_resolve_claim(
    &mut self,
    contract_id: AccountId,
    token_id: TokenId,
    owner_id: AccountId,
    renter_id: AccountId
)