Struct smarthub_sdk::market::base::MarketFeature

pub struct MarketFeature {
    pub owner_id: AccountId,
    pub sales: UnorderedMap<ContractAndTokenId, Sale>,
    pub by_owner_id: TreeMap<AccountId, UnorderedSet<ContractAndTokenId>>,
    pub by_nft_contract_id: LookupMap<AccountId, UnorderedSet<TokenId>>,
    pub ft_token_ids: UnorderedSet<AccountId>,
    pub storage_deposits: LookupMap<AccountId, Balance>,
    pub bid_history_length: u8,
    pub reputation: Option<ReputationFeature>,
}

Fields

owner_id: AccountId

sales: UnorderedMap<ContractAndTokenId, Sale>

by_owner_id: TreeMap<AccountId, UnorderedSet<ContractAndTokenId>>

by_nft_contract_id: LookupMap<AccountId, UnorderedSet<TokenId>>

ft_token_ids: UnorderedSet<AccountId>

storage_deposits: LookupMap<AccountId, Balance>

bid_history_length: u8

reputation: Option<ReputationFeature>

Implementations

impl MarketFeature

pub fn new<M1, M2, M3, M4, M5, R1>(
    owner_id: AccountId,
    ft_token_ids: Option<Vec<FungibleTokenId>>,
    bid_history_length: Option<u8>,
    sales_prefix: M1,
    by_owner_prefix: M2,
    by_contract_prefix: M3,
    ft_tokens_prefix: M4,
    storage_prefix: M5,
    reputation_prefix: Option<R1>
) -> Selfwhere
    M1: IntoStorageKey,
    M2: IntoStorageKey,
    M3: IntoStorageKey,
    M4: IntoStorageKey,
    M5: IntoStorageKey,
    R1: IntoStorageKey,

impl MarketFeature

pub fn internal_on_nft_approve(
    &mut self,
    args: &MarketOnNftApproveArgs,
    nft_contract_id: &AccountId,
    token_id: &TokenId,
    owner_id: &AccountId,
    approval_id: &u64
) -> PromiseOrValue<String>

impl MarketFeature

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

impl MarketFeature

pub fn internal_market_fee(
    &mut self,
    price: &u128,
    account_id: &AccountId
) -> u128

Trait Implementations

impl BorshDeserialize for MarketFeaturewhere
    AccountId: BorshDeserialize,
    UnorderedMap<ContractAndTokenId, Sale>: BorshDeserialize,
    TreeMap<AccountId, UnorderedSet<ContractAndTokenId>>: BorshDeserialize,
    LookupMap<AccountId, UnorderedSet<TokenId>>: BorshDeserialize,
    UnorderedSet<AccountId>: BorshDeserialize,
    LookupMap<AccountId, Balance>: BorshDeserialize,
    u8: BorshDeserialize,
    Option<ReputationFeature>: 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 MarketFeaturewhere
    AccountId: BorshSerialize,
    UnorderedMap<ContractAndTokenId, Sale>: BorshSerialize,
    TreeMap<AccountId, UnorderedSet<ContractAndTokenId>>: BorshSerialize,
    LookupMap<AccountId, UnorderedSet<TokenId>>: BorshSerialize,
    UnorderedSet<AccountId>: BorshSerialize,
    LookupMap<AccountId, Balance>: BorshSerialize,
    u8: BorshSerialize,
    Option<ReputationFeature>: 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 MarketCore for MarketFeature

fn market_add_ft_token(&mut self, nft_contract_id: AccountId) -> bool

only owner

fn supported_ft_token_ids(&self) -> Vec<AccountId>

views

fn market_remove_sale(&mut self, nft_contract_id: AccountId, token_id: String)

for add sale see: nft_callbacks.rs TODO remove without redirect to wallet? panic reverts

fn market_resolve_purchase(
    &mut self,
    ft_token_id: FungibleTokenId,
    buyer_id: AccountId,
    sale: Sale,
    price: U128
) -> U128

self callback

fn market_update_price(
    &mut self,
    nft_contract_id: AccountId,
    token_id: String,
    ft_token_id: AccountId,
    price: U128
)

fn market_offer(&mut self, nft_contract_id: AccountId, token_id: String)

fn market_add_bid(
    &mut self,
    contract_and_token_id: ContractAndTokenId,
    amount: Balance,
    ft_token_id: AccountId,
    buyer_id: AccountId,
    sale: &mut Sale
)

fn market_accept_offer(
    &mut self,
    nft_contract_id: AccountId,
    token_id: String,
    ft_token_id: AccountId
)

fn market_process_purchase(
    &mut self,
    nft_contract_id: AccountId,
    token_id: String,
    ft_token_id: AccountId,
    price: U128,
    buyer_id: AccountId
) -> Promise

impl MarketEnumeration for MarketFeature

fn market_supply_sales(&self) -> U64

fn market_supply_by_owner_id(&self, account_id: AccountId) -> U64

fn market_sales_by_owner_id(
    &self,
    account_id: AccountId,
    from_index: U64,
    limit: u64
) -> Vec<Sale>

fn market_supply_by_nft_contract_id(&self, nft_contract_id: AccountId) -> U64

fn market_sales_by_nft_contract_id(
    &self,
    nft_contract_id: AccountId,
    from_index: U64,
    limit: u64
) -> Vec<Sale>

fn market_sale(&self, contract_id: AccountId, token_id: TokenId) -> Option<Sale>