feat(near-contract-standards): NEP-199 - Non-Fungible Token Royalties and Payouts

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "near-sdk",
     "near-sdk-macros",
+#    "near-sdk-sim",
     "near-contract-standards",
     "near-sys",
 ]

examples/non-fungible-token/nft/src/lib.rs

@@ -15,21 +15,25 @@ NOTES:
   - To prevent the deployed contract from being modified or deleted, it should not have any access
     keys on its account.
 */
-use std::collections::HashMap;
+use near_contract_standards::non_fungible_token::approval::NonFungibleTokenApproval;
+use near_contract_standards::non_fungible_token::core::{
+    NonFungibleTokenCore, NonFungibleTokenResolver,
+};
+use near_contract_standards::non_fungible_token::enumeration::NonFungibleTokenEnumeration;
 use near_contract_standards::non_fungible_token::metadata::{
     NFTContractMetadata, NonFungibleTokenMetadataProvider, TokenMetadata, NFT_METADATA_SPEC,
 };
-use near_contract_standards::non_fungible_token::NonFungibleToken;
+use near_contract_standards::non_fungible_token::payout::Payout;
+use near_contract_standards::non_fungible_token::{NonFungibleToken, NonFungibleTokenPayout};
 use near_contract_standards::non_fungible_token::{Token, TokenId};
-use near_contract_standards::non_fungible_token::approval::NonFungibleTokenApproval;
-use near_contract_standards::non_fungible_token::core::{NonFungibleTokenCore, NonFungibleTokenResolver};
-use near_contract_standards::non_fungible_token::enumeration::NonFungibleTokenEnumeration;
 use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
 use near_sdk::collections::LazyOption;
+use near_sdk::json_types::U128;
 use near_sdk::{
-    env, near_bindgen, require, AccountId, BorshStorageKey, PanicOnDefault, Promise, PromiseOrValue,
+    assert_one_yocto, env, near_bindgen, require, AccountId, BorshStorageKey, PanicOnDefault,
+    Promise, PromiseOrValue,
 };
-use near_sdk::json_types::U128;
+use std::collections::HashMap;
 
 #[near_bindgen]
 #[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]
@@ -47,6 +51,7 @@ enum StorageKey {
     TokenMetadata,
     Enumeration,
     Approval,
+    Royalties,
 }
 
 #[near_bindgen]
@@ -80,6 +85,7 @@ impl Contract {
                 Some(StorageKey::TokenMetadata),
                 Some(StorageKey::Enumeration),
                 Some(StorageKey::Approval),
+                Some(StorageKey::Royalties),
             ),
             metadata: LazyOption::new(StorageKey::Metadata, Some(&metadata)),
         }
@@ -108,12 +114,25 @@ impl Contract {
 #[near_bindgen]
 impl NonFungibleTokenCore for Contract {
     #[payable]
-    fn nft_transfer(&mut self, receiver_id: AccountId, token_id: TokenId, approval_id: Option<u64>, memo: Option<String>) {
+    fn nft_transfer(
+        &mut self,
+        receiver_id: AccountId,
+        token_id: TokenId,
+        approval_id: Option<u64>,
+        memo: Option<String>,
+    ) {
         self.tokens.nft_transfer(receiver_id, token_id, approval_id, memo);
     }
 
     #[payable]
-    fn nft_transfer_call(&mut self, receiver_id: AccountId, token_id: TokenId, approval_id: Option<u64>, memo: Option<String>, msg: String) -> PromiseOrValue<bool> {
+    fn nft_transfer_call(
+        &mut self,
+        receiver_id: AccountId,
+        token_id: TokenId,
+        approval_id: Option<u64>,
+        memo: Option<String>,
+        msg: String,
+    ) -> PromiseOrValue<bool> {
         self.tokens.nft_transfer_call(receiver_id, token_id, approval_id, memo, msg)
     }
 
@@ -125,15 +144,31 @@ impl NonFungibleTokenCore for Contract {
 #[near_bindgen]
 impl NonFungibleTokenResolver for Contract {
     #[private]
-    fn nft_resolve_transfer(&mut self, previous_owner_id: AccountId, receiver_id: AccountId, token_id: TokenId, approved_account_ids: Option<HashMap<AccountId, u64>>) -> bool {
-        self.tokens.nft_resolve_transfer(previous_owner_id, receiver_id, token_id, approved_account_ids)
+    fn nft_resolve_transfer(
+        &mut self,
+        previous_owner_id: AccountId,
+        receiver_id: AccountId,
+        token_id: TokenId,
+        approved_account_ids: Option<HashMap<AccountId, u64>>,
+    ) -> bool {
+        self.tokens.nft_resolve_transfer(
+            previous_owner_id,
+            receiver_id,
+            token_id,
+            approved_account_ids,
+        )
     }
 }
 
 #[near_bindgen]
 impl NonFungibleTokenApproval for Contract {
     #[payable]
-    fn nft_approve(&mut self, token_id: TokenId, account_id: AccountId, msg: Option<String>) -> Option<Promise> {
+    fn nft_approve(
+        &mut self,
+        token_id: TokenId,
+        account_id: AccountId,
+        msg: Option<String>,
+    ) -> Option<Promise> {
         self.tokens.nft_approve(token_id, account_id, msg)
     }
 
@@ -145,10 +180,14 @@ impl NonFungibleTokenApproval for Contract {
     #[payable]
     fn nft_revoke_all(&mut self, token_id: TokenId) {
         self.tokens.nft_revoke_all(token_id);
-
     }
 
-    fn nft_is_approved(&self, token_id: TokenId, approved_account_id: AccountId, approval_id: Option<u64>) -> bool {
+    fn nft_is_approved(
+        &self,
+        token_id: TokenId,
+        approved_account_id: AccountId,
+        approval_id: Option<u64>,
+    ) -> bool {
         self.tokens.nft_is_approved(token_id, approved_account_id, approval_id)
     }
 }
@@ -167,11 +206,41 @@ impl NonFungibleTokenEnumeration for Contract {
         self.tokens.nft_supply_for_owner(account_id)
     }
 
-    fn nft_tokens_for_owner(&self, account_id: AccountId, from_index: Option<U128>, limit: Option<u64>) -> Vec<Token> {
+    fn nft_tokens_for_owner(
+        &self,
+        account_id: AccountId,
+        from_index: Option<U128>,
+        limit: Option<u64>,
+    ) -> Vec<Token> {
         self.tokens.nft_tokens_for_owner(account_id, from_index, limit)
     }
 }
 
+impl NonFungibleTokenPayout for Contract {
+    fn nft_payout(&self, token_id: String, balance: U128, max_len_payout: Option<u32>) -> Payout {
+        let owner_id = self.tokens.owner_by_id.get(&token_id).expect("No such token_id");
+        self.tokens
+            .royalties
+            .as_ref()
+            .map_or(Payout::default(), |r| r.create_payout(balance.0, &owner_id))
+    }
+
+    fn nft_transfer_payout(
+        &mut self,
+        receiver_id: AccountId,
+        token_id: String,
+        approval_id: Option<u64>,
+        memo: Option<String>,
+        balance: U128,
+        max_len_payout: Option<u32>,
+    ) -> Payout {
+        assert_one_yocto();
+        let payout = self.nft_payout(token_id.clone(), balance, max_len_payout);
+        self.nft_transfer(receiver_id, token_id, approval_id, memo);
+        payout
+    }
+}
+
 #[near_bindgen]
 impl NonFungibleTokenMetadataProvider for Contract {
     fn nft_metadata(&self) -> NFTContractMetadata {

examples/non-fungible-token/tests/workspaces/test_core.rs

@@ -8,22 +8,13 @@ async fn simulate_simple_transfer() -> anyhow::Result<()> {
     let worker = workspaces::sandbox().await?;
     let (nft_contract, alice, _, _) = init(&worker).await?;
 
-    let token = nft_contract
-        .call("nft_token")
-        .args_json((TOKEN_ID,))
-        .view()
-        .await?
-        .json::<Token>()?;
+    let token =
+        nft_contract.call("nft_token").args_json((TOKEN_ID,)).view().await?.json::<Token>()?;
     assert_eq!(token.owner_id.to_string(), nft_contract.id().to_string());
 
     let res = nft_contract
         .call("nft_transfer")
-        .args_json((
-            alice.id(),
-            TOKEN_ID,
-            Option::<u64>::None,
-            Some("simple transfer".to_string()),
-        ))
+        .args_json((alice.id(), TOKEN_ID, Option::<u64>::None, Some("simple transfer".to_string())))
         .max_gas()
         .deposit(ONE_YOCTO)
         .transact()
@@ -33,12 +24,8 @@ async fn simulate_simple_transfer() -> anyhow::Result<()> {
     // A single NFT transfer event should have been logged:
     assert_eq!(res.logs().len(), 1);
 
-    let token = nft_contract
-        .call("nft_token")
-        .args_json((TOKEN_ID,))
-        .view()
-        .await?
-        .json::<Token>()?;
+    let token =
+        nft_contract.call("nft_token").args_json((TOKEN_ID,)).view().await?.json::<Token>()?;
     assert_eq!(token.owner_id.to_string(), alice.id().to_string());
 
     Ok(())
@@ -64,12 +51,8 @@ async fn simulate_transfer_call_fast_return_to_sender() -> anyhow::Result<()> {
         .await?;
     assert!(res.is_success());
 
-    let token = nft_contract
-        .call("nft_token")
-        .args_json((TOKEN_ID,))
-        .view()
-        .await?
-        .json::<Token>()?;
+    let token =
+        nft_contract.call("nft_token").args_json((TOKEN_ID,)).view().await?.json::<Token>()?;
     assert_eq!(token.owner_id.to_string(), nft_contract.id().to_string());
 
     Ok(())
@@ -95,12 +78,8 @@ async fn simulate_transfer_call_slow_return_to_sender() -> anyhow::Result<()> {
         .await?;
     assert!(res.is_success());
 
-    let token = nft_contract
-        .call("nft_token")
-        .args_json((TOKEN_ID,))
-        .view()
-        .await?
-        .json::<Token>()?;
+    let token =
+        nft_contract.call("nft_token").args_json((TOKEN_ID,)).view().await?.json::<Token>()?;
     assert_eq!(token.owner_id.to_string(), nft_contract.id().to_string());
 
     Ok(())
@@ -127,12 +106,8 @@ async fn simulate_transfer_call_fast_keep_with_sender() -> anyhow::Result<()> {
     assert!(res.is_success());
     assert_eq!(res.logs().len(), 2);
 
-    let token = nft_contract
-        .call("nft_token")
-        .args_json((TOKEN_ID,))
-        .view()
-        .await?
-        .json::<Token>()?;
+    let token =
+        nft_contract.call("nft_token").args_json((TOKEN_ID,)).view().await?.json::<Token>()?;
     assert_eq!(token.owner_id.to_string(), token_receiver_contract.id().to_string());
 
     Ok(())
@@ -158,12 +133,8 @@ async fn simulate_transfer_call_slow_keep_with_sender() -> anyhow::Result<()> {
         .await?;
     assert!(res.is_success());
 
-    let token = nft_contract
-        .call("nft_token")
-        .args_json((TOKEN_ID,))
-        .view()
-        .await?
-        .json::<Token>()?;
+    let token =
+        nft_contract.call("nft_token").args_json((TOKEN_ID,)).view().await?.json::<Token>()?;
     assert_eq!(token.owner_id.to_string(), token_receiver_contract.id().to_string());
 
     Ok(())
@@ -192,12 +163,8 @@ async fn simulate_transfer_call_receiver_panics() -> anyhow::Result<()> {
     // Prints final logs
     assert_eq!(res.logs().len(), 3);
 
-    let token = nft_contract
-        .call("nft_token")
-        .args_json((TOKEN_ID,))
-        .view()
-        .await?
-        .json::<Token>()?;
+    let token =
+        nft_contract.call("nft_token").args_json((TOKEN_ID,)).view().await?.json::<Token>()?;
     assert_eq!(token.owner_id.to_string(), nft_contract.id().to_string());
 
     Ok(())
@@ -222,17 +189,14 @@ async fn simulate_transfer_call_receiver_panics_and_nft_resolve_transfer_produce
         .deposit(ONE_YOCTO)
         .transact()
         .await?;
+
     assert!(res.is_failure());
 
     // Prints no logs
     assert_eq!(res.logs().len(), 0);
 
-    let token = nft_contract
-        .call("nft_token")
-        .args_json((TOKEN_ID,))
-        .view()
-        .await?
-        .json::<Token>()?;
+    let token =
+        nft_contract.call("nft_token").args_json((TOKEN_ID,)).view().await?.json::<Token>()?;
     assert_eq!(token.owner_id.to_string(), nft_contract.id().to_string());
 
     Ok(())
@@ -256,12 +220,8 @@ async fn simulate_simple_transfer_no_logs_on_failure() -> anyhow::Result<()> {
     // Prints no logs
     assert_eq!(res.logs().len(), 0);
 
-    let token = nft_contract
-        .call("nft_token")
-        .args_json((TOKEN_ID,))
-        .view()
-        .await?
-        .json::<Token>()?;
+    let token =
+        nft_contract.call("nft_token").args_json((TOKEN_ID,)).view().await?.json::<Token>()?;
     assert_eq!(token.owner_id.to_string(), nft_contract.id().to_string());
 
     Ok(())

near-contract-standards/src/non_fungible_token/core/core_impl.rs

@@ -4,6 +4,7 @@ use crate::non_fungible_token::core::resolver::ext_nft_resolver;
 use crate::non_fungible_token::core::NonFungibleTokenCore;
 use crate::non_fungible_token::events::{NftMint, NftTransfer};
 use crate::non_fungible_token::metadata::TokenMetadata;
+use crate::non_fungible_token::payout::Royalties;
 use crate::non_fungible_token::token::{Token, TokenId};
 use crate::non_fungible_token::utils::{refund_approved_account_ids, refund_deposit_to_account};
 use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
@@ -47,6 +48,7 @@ pub struct NonFungibleToken {
     // required by approval extension
     pub approvals_by_id: Option<LookupMap<TokenId, HashMap<AccountId, u64>>>,
     pub next_approval_id_by_id: Option<LookupMap<TokenId, u64>>,
+    pub royalties: Option<Royalties>,
 }
 
 #[derive(BorshStorageKey, BorshSerialize)]
@@ -55,18 +57,20 @@ pub enum StorageKey {
 }
 
 impl NonFungibleToken {
-    pub fn new<Q, R, S, T>(
+    pub fn new<Q, R, S, T, Y>(
         owner_by_id_prefix: Q,
         owner_id: AccountId,
         token_metadata_prefix: Option<R>,
         enumeration_prefix: Option<S>,
         approval_prefix: Option<T>,
+        royalties_prefix: Option<Y>,
     ) -> Self
     where
         Q: IntoStorageKey,
         R: IntoStorageKey,
         S: IntoStorageKey,
         T: IntoStorageKey,
+        Y: IntoStorageKey,
     {
         let (approvals_by_id, next_approval_id_by_id) = if let Some(prefix) = approval_prefix {
             let prefix: Vec<u8> = prefix.into_storage_key();
@@ -86,6 +90,7 @@ impl NonFungibleToken {
             tokens_per_owner: enumeration_prefix.map(LookupMap::new),
             approvals_by_id,
             next_approval_id_by_id,
+            royalties: royalties_prefix.map(Royalties::new),
         };
         this.measure_min_token_storage_cost();
         this
@@ -391,7 +396,6 @@ impl NonFungibleTokenCore for NonFungibleToken {
         msg: String,
     ) -> PromiseOrValue<bool> {
         assert_one_yocto();
-        require!(env::prepaid_gas() > GAS_FOR_NFT_TRANSFER_CALL, "More gas is required");
         let sender_id = env::predecessor_account_id();
         let (old_owner, old_approvals) =
             self.internal_transfer(&sender_id, &receiver_id, &token_id, approval_id, memo);