update types

Author: garikbesson

integration-tests/src/helpers.rs

@@ -76,7 +76,7 @@ pub async fn place_nft_for_sale(
     market_contract: &Contract,
     nft_contract: &Contract,
     token_id: &str,
-    approval_id: u32,
+    approval_id: u64,
     price: &NearToken,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let request_payload = json!({

market-contract/src/external.rs

@@ -9,22 +9,17 @@ trait ExtContract {
     fn nft_transfer_payout(
         &mut self,
         receiver_id: AccountId, //purchaser (person to transfer the NFT to)
-        token_id: TokenId, //token ID to transfer
-        approval_id: u32, //market contract's approval ID in order to transfer the token on behalf of the owner
-        memo: String, //memo (to include some context)
+        token_id: TokenId,      //token ID to transfer
+        approval_id: u64, //market contract's approval ID in order to transfer the token on behalf of the owner
+        memo: String,     //memo (to include some context)
         /*
             the price that the token was purchased for. This will be used in conjunction with the royalty percentages
-            for the token in order to determine how much money should go to which account. 
+            for the token in order to determine how much money should go to which account.
         */
         balance: NearToken,
         //the maximum amount of accounts the market can payout at once (this is limited by GAS)
-		    max_len_payout: u32,
+        max_len_payout: u32,
     );
     fn nft_token(&self, token_id: TokenId);
-    fn nft_is_approved(
-        &self,
-        token_id: TokenId,
-        approved_account_id: AccountId,
-        approval_id: u32,
-    );
-}
+    fn nft_is_approved(&self, token_id: TokenId, approved_account_id: AccountId, approval_id: u64);
+}

market-contract/src/nft_callbacks.rs

@@ -5,14 +5,14 @@ use crate::*;
 /*
     trait that will be used as the callback from the NFT contract. When nft_approve is
     called, it will fire a cross contract call to this marketplace and this is the function
-    that is invoked. 
+    that is invoked.
 */
 trait NonFungibleTokenApprovalsReceiver {
     fn nft_on_approve(
         &mut self,
         token_id: TokenId,
         owner_id: AccountId,
-        approval_id: u32,
+        approval_id: u64,
         msg: String,
     );
 }
@@ -24,7 +24,7 @@ impl NonFungibleTokenApprovalsReceiver for Contract {
         &mut self,
         token_id: TokenId,
         owner_id: AccountId,
-        approval_id: u32,
+        approval_id: u64,
         msg: String,
     ) {
         /*

market-contract/src/sale.rs

@@ -1,5 +1,5 @@
 use crate::*;
-use near_sdk::{ext_contract};
+use near_sdk::ext_contract;
 
 pub trait NonFungibleTokenCore {
     //approve an account ID to transfer a token on your behalf
@@ -10,7 +10,7 @@ pub trait NonFungibleTokenCore {
         &self,
         token_id: TokenId,
         approved_account_id: AccountId,
-        approval_id: Option<u32>,
+        approval_id: Option<u64>,
     ) -> bool;
 
     //revoke a specific account from transferring the token on your behalf
@@ -27,7 +27,7 @@ trait NonFungibleTokenApprovalsReceiver {
         &mut self,
         token_id: TokenId,
         owner_id: AccountId,
-        approval_id: u32,
+        approval_id: u64,
         msg: String,
     );
 }
@@ -54,12 +54,12 @@ impl NonFungibleTokenCore for Contract {
         );
 
         //get the next approval ID if we need a new approval
-        let approval_id: u32 = token.next_approval_id;
+        let approval_id: u64 = token.next_approval_id;
 
         //check if the account has been approved already for this token
         let is_new_approval = token
             .approved_account_ids
-            //insert returns none if the key was not present.  
+            //insert returns none if the key was not present.
             .insert(account_id.clone(), approval_id)
             //if the key was not present, .is_none() will return true so it is a new approval.
             .is_none();
@@ -77,36 +77,32 @@ impl NonFungibleTokenCore for Contract {
         //insert the token back into the tokens_by_id collection
         self.tokens_by_id.insert(&token_id, &token);
 
-        //refund any excess storage attached by the user. If the user didn't attach enough, panic. 
+        //refund any excess storage attached by the user. If the user didn't attach enough, panic.
         refund_deposit(storage_used);
 
         //if some message was passed into the function, we initiate a cross contract call on the
-        //account we're giving access to. 
+        //account we're giving access to.
         if let Some(msg) = msg {
             // Defaulting GAS weight to 1, no attached deposit, and no static GAS to attach.
             ext_non_fungible_approval_receiver::ext(account_id)
-                .nft_on_approve(
-                    token_id, 
-                    token.owner_id, 
-                    approval_id, 
-                    msg
-                ).as_return();
+                .nft_on_approve(token_id, token.owner_id, approval_id, msg)
+                .as_return();
         }
     }
 
     //check if the passed in account has access to approve the token ID
-	  fn nft_is_approved(
+    fn nft_is_approved(
         &self,
         token_id: TokenId,
         approved_account_id: AccountId,
-        approval_id: Option<u32>,
+        approval_id: Option<u64>,
     ) -> bool {
         //get the token object from the token_id
         let token = self.tokens_by_id.get(&token_id).expect("No token");
-  
+
         //get the approval number for the passed in account ID
         let approval = token.approved_account_ids.get(&approved_account_id);
-  
+
         //if there was some approval ID found for the account ID
         if let Some(approval) = approval {
             //if a specific approval_id was passed into the function
@@ -123,7 +119,7 @@ impl NonFungibleTokenCore for Contract {
         }
     }
 
-    //revoke a specific account from transferring the token on your behalf 
+    //revoke a specific account from transferring the token on your behalf
     #[payable]
     fn nft_revoke(&mut self, token_id: TokenId, account_id: AccountId) {
         //assert that the user attached exactly 1 yoctoNEAR for security reasons
@@ -136,11 +132,7 @@ impl NonFungibleTokenCore for Contract {
         assert_eq!(&predecessor_account_id, &token.owner_id);
 
         //if the account ID was in the token's approval, we remove it and the if statement logic executes
-        if token
-            .approved_account_ids
-            .remove(&account_id)
-            .is_some()
-        {
+        if token.approved_account_ids.remove(&account_id).is_some() {
             //refund the funds released by removing the approved_account_id to the caller of the function
             refund_approved_account_ids_iter(predecessor_account_id, [account_id].iter());
 
@@ -171,4 +163,4 @@ impl NonFungibleTokenCore for Contract {
             self.tokens_by_id.insert(&token_id, &token);
         }
     }
-}
+}

nft-contract-approval/src/approval.rs

@@ -3,42 +3,40 @@ use crate::*;
 #[near_bindgen]
 impl Contract {
     //Query for the total supply of NFTs on the contract
-    pub fn nft_total_supply(&self) -> U64 {
+    pub fn nft_total_supply(&self) -> U128 {
         //return the length of the token metadata by ID
-        U64(self.token_metadata_by_id.len())
+        U128(self.token_metadata_by_id.len().into())
     }
 
     //Query for nft tokens on the contract regardless of the owner using pagination
-    pub fn nft_tokens(&self, from_index: Option<U128>, limit: Option<u32>) -> Vec<JsonToken> {
+    pub fn nft_tokens(&self, from_index: Option<U128>, limit: Option<u64>) -> Vec<JsonToken> {
         //where to start pagination - if we have a from_index, we'll use that - otherwise start from 0 index
         let start = u128::from(from_index.unwrap_or(U128(0)));
 
         //iterate through each token using an iterator
-        self.token_metadata_by_id.keys()
+        self.token_metadata_by_id
+            .keys()
             //skip to the index we specified in the start variable
-            .skip(start as usize) 
+            .skip(start as usize)
             //take the first "limit" elements in the vector. If we didn't specify a limit, use 50
-            .take(limit.unwrap_or(50) as usize) 
+            .take(limit.unwrap_or(50) as usize)
             //we'll map the token IDs which are strings into Json Tokens
             .map(|token_id| self.nft_token(token_id.clone()).unwrap())
             //since we turned the keys into an iterator, we need to turn it back into a vector to return
             .collect()
     }
 
     //get the total supply of NFTs for a given owner
-    pub fn nft_supply_for_owner(
-      &self,
-      account_id: AccountId,
-    ) -> U64 {
+    pub fn nft_supply_for_owner(&self, account_id: AccountId) -> U128 {
         //get the set of tokens for the passed in owner
         let tokens_for_owner_set = self.tokens_per_owner.get(&account_id);
 
         //if there is some set of tokens, we'll return the length
         if let Some(tokens_for_owner_set) = tokens_for_owner_set {
-            U64(tokens_for_owner_set.len())
+            U128(tokens_for_owner_set.len().into())
         } else {
             //if there isn't a set of tokens for the passed in account ID, we'll return 0
-            U64(0)
+            U128(0)
         }
     }
 
@@ -47,30 +45,31 @@ impl Contract {
         &self,
         account_id: AccountId,
         from_index: Option<U128>,
-        limit: Option<u32>,
+        limit: Option<u64>,
     ) -> Vec<JsonToken> {
         //get the set of tokens for the passed in owner
         let tokens_for_owner_set = self.tokens_per_owner.get(&account_id);
         //if there is some set of tokens, we'll set the tokens variable equal to that set
         let tokens = if let Some(tokens_for_owner_set) = tokens_for_owner_set {
             tokens_for_owner_set
         } else {
-            //if there is no set of tokens, we'll simply return an empty vector. 
+            //if there is no set of tokens, we'll simply return an empty vector.
             return vec![];
         };
 
         //where to start pagination - if we have a from_index, we'll use that - otherwise start from 0 index
         let start = u128::from(from_index.unwrap_or(U128(0)));
 
         //iterate through the keys vector
-        tokens.iter()
+        tokens
+            .iter()
             //skip to the index we specified in the start variable
-            .skip(start as usize) 
+            .skip(start as usize)
             //take the first "limit" elements in the vector. If we didn't specify a limit, use 50
-            .take(limit.unwrap_or(50) as usize) 
+            .take(limit.unwrap_or(50) as usize)
             //we'll map the token IDs which are strings into Json Tokens
             .map(|token_id| self.nft_token(token_id.clone()).unwrap())
             //since we turned the keys into an iterator, we need to turn it back into a vector to return
             .collect()
     }
-}
+}