returned the use U128/U64

Author: garikbesson

market-contract/src/external.rs

@@ -16,7 +16,7 @@ trait ExtContract {
             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. 
         */
-        balance: NearToken,
+        balance: U128,
         //the maximum amount of accounts the market can payout at once (this is limited by GAS)
 		    max_len_payout: u32,
     );

market-contract/src/lib.rs

@@ -1,5 +1,6 @@
 use near_sdk::borsh::{BorshDeserialize, BorshSerialize};
 use near_sdk::collections::{LookupMap, UnorderedMap, UnorderedSet};
+use near_sdk::json_types::{U128, U64};
 use near_sdk::serde::{Deserialize, Serialize};
 use near_sdk::{
     assert_one_yocto, env, ext_contract, near_bindgen, AccountId, BorshStorageKey, CryptoHash, Gas,
@@ -180,8 +181,8 @@ impl Contract {
     }
 
     //return how much storage an account has paid for
-    pub fn storage_balance_of(&self, account_id: AccountId) -> NearToken {
-        self.storage_deposits.get(&account_id).unwrap_or(ZERO_NEAR)
+    pub fn storage_balance_of(&self, account_id: AccountId) -> U128 {
+        U128(self.storage_deposits.get(&account_id).unwrap_or(ZERO_NEAR).as_yoctonear())
     }
 }
 

market-contract/src/sale.rs

@@ -47,7 +47,7 @@ impl Contract {
         //get the total storage paid by the owner
         let owner_paid_storage = self.storage_deposits.get(&owner_id).unwrap_or(ZERO_NEAR);
         //get the storage required which is simply the storage for the number of sales they have + 1 
-        let signer_storage_required = storage_amount.saturating_mul((self.get_supply_by_owner_id(owner_id.clone()) + 1).into());
+        let signer_storage_required = storage_amount.saturating_mul((self.get_supply_by_owner_id(owner_id.clone()).0 + 1).into());
 
         //make sure that the total paid is >= the required storage
         assert!(
@@ -145,7 +145,7 @@ impl Contract {
         self.process_purchase(
             contract_id,
             token_id,
-            deposit,
+            U128(deposit.as_yoctonear()),
             buyer_id,
         );
     }
@@ -157,7 +157,7 @@ impl Contract {
         &mut self,
         nft_contract_id: AccountId,
         token_id: String,
-        price: NearToken,
+        price: U128,
         buyer_id: AccountId,
     ) -> Promise {
         //get the sale object by removing the sale
@@ -203,8 +203,8 @@ impl Contract {
     pub fn resolve_purchase(
         &mut self,
         buyer_id: AccountId,
-        price: NearToken,
-    ) -> NearToken {
+        price: U128,
+    ) -> U128 {
         // checking for payout information returned from the nft_transfer_payout method
         let payout_option = promise_result_as_success().and_then(|value| {
             //if we set the payout_option to None, that means something went wrong and we should refund the buyer
@@ -221,17 +221,17 @@ impl Contract {
                     //if the payout object is the correct length, we move forward
                     } else {
                         //we'll keep track of how much the nft contract wants us to payout. Starting at the full price payed by the buyer
-                        let mut remainder = price;
+                        let mut remainder = price.0;
 
                         //loop through the payout and subtract the values from the remainder. 
                         for &value in payout_object.payout.values() {
                             //checked sub checks for overflow or any errors and returns None if there are problems
-                            remainder = remainder.checked_sub(value)?;
+                            remainder = remainder.checked_sub(value.as_yoctonear())?;
                         }
                         //Check to see if the NFT contract sent back a faulty payout that requires us to pay more or too little. 
                         //The remainder will be 0 if the payout summed to the total price. The remainder will be 1 if the royalties
                         //we something like 3333 + 3333 + 3333. 
-                        if remainder.is_zero() || remainder.eq(&ONE_YOCTONEAR) {
+                        if remainder == 0 || remainder == 1 {
                             //set the payout_option to be the payout because nothing went wrong
                             Some(payout_object.payout)
                         } else {
@@ -247,7 +247,7 @@ impl Contract {
             payout_option
         //if the payout option was None, we refund the buyer for the price they payed and return
         } else {
-            Promise::new(buyer_id).transfer(price);
+            Promise::new(buyer_id).transfer(NearToken::from_yoctonear(u128::from(price)));
             // leave function and return the price that was refunded
             return price;
         };

market-contract/src/sale_views.rs

@@ -7,24 +7,24 @@ impl Contract {
     //returns the number of sales the marketplace has up (as a string)
     pub fn get_supply_sales(
         &self,
-    ) -> u64 {
+    ) -> U64 {
         //returns the sales object length
-        self.sales.len()
+        U64(self.sales.len())
     }
 
     //returns the number of sales for a given account (result is a string)
     pub fn get_supply_by_owner_id(
         &self,
         account_id: AccountId,
-    ) -> u64 {
+    ) -> U64 {
         //get the set of sales for the given owner Id
         let by_owner_id = self.by_owner_id.get(&account_id);
 
         //if there as some set, we return the length but if there wasn't a set, we return 0
         if let Some(by_owner_id) = by_owner_id {
-            by_owner_id.len()
+            U64(by_owner_id.len())
         } else {
-            0
+            U64(0)
         }
     }
 
@@ -66,15 +66,15 @@ impl Contract {
     pub fn get_supply_by_nft_contract_id(
         &self,
         nft_contract_id: AccountId,
-    ) -> u64 {
+    ) -> U64 {
         //get the set of tokens for associated with the given nft contract
         let by_nft_contract_id = self.by_nft_contract_id.get(&nft_contract_id);
 
         //if there was some set, return it's length. Otherwise return 0
         if let Some(by_nft_contract_id) = by_nft_contract_id {
-            by_nft_contract_id.len()
+            U64(by_nft_contract_id.len())
         } else {
-            0
+            U64(0)
         }
     }
 

market-contract/src/tests.rs

@@ -4,6 +4,7 @@ use crate::sale::Sale;
 use crate::Contract;
 use near_sdk::{
     collections::UnorderedSet,
+    json_types::U128,
     env,
     NearToken,
     test_utils::{accounts, VMContextBuilder},
@@ -71,7 +72,7 @@ fn test_storage_balance_of() {
         .build());
     contract.storage_deposit(Some(accounts(0)));
     let balance = contract.storage_balance_of(accounts(0));
-    assert!(balance.eq(&MIN_REQUIRED_STORAGE_YOCTO));
+    assert_eq!(balance, U128(MIN_REQUIRED_STORAGE_YOCTO.as_yoctonear()));
 }
 
 #[test]
@@ -97,7 +98,7 @@ fn test_storage_withdraw() {
     contract.storage_withdraw();
 
     let remaining_amount = contract.storage_balance_of(accounts(0));
-    assert!(remaining_amount.is_zero())
+    assert_eq!(remaining_amount, U128(0))
 }
 
 #[test]

nft-contract-approval/src/enumeration.rs

@@ -3,9 +3,9 @@ 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) -> U64 {
         //return the length of the token metadata by ID
-        self.token_metadata_by_id.len()
+        U64(self.token_metadata_by_id.len())
     }
 
     //Query for nft tokens on the contract regardless of the owner using pagination
@@ -29,16 +29,16 @@ impl Contract {
     pub fn nft_supply_for_owner(
       &self,
       account_id: AccountId,
-    ) -> u64 {
+    ) -> U64 {
         //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 {
-            tokens_for_owner_set.len()
+            U64(tokens_for_owner_set.len())
         } else {
             //if there isn't a set of tokens for the passed in account ID, we'll return 0
-            0
+            U64(0)
         }
     }
 

nft-contract-approval/src/internal.rs

@@ -14,7 +14,7 @@ pub(crate) fn refund_approved_account_ids_iter<'a, I>(
     approved_account_ids: I, //the approved account IDs must be passed in as an iterator
 ) -> Promise where I: Iterator<Item = &'a AccountId> {
     //get the storage total by going through and summing all the bytes for each approved account IDs
-    let storage_released: u128 = approved_account_ids.map(bytes_for_approved_account_id).sum();
+    let storage_released = approved_account_ids.map(bytes_for_approved_account_id).sum();
     //transfer the account the storage that is released
     Promise::new(account_id).transfer(env::storage_byte_cost().saturating_mul(storage_released))
 }

nft-contract-approval/src/lib.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use near_sdk::borsh::{BorshSerialize, BorshDeserialize};
 use near_sdk::collections::{LazyOption, LookupMap, UnorderedMap, UnorderedSet};
-use near_sdk::json_types::Base64VecU8;
+use near_sdk::json_types::{Base64VecU8, U64};
 use near_sdk::serde::{Deserialize, Serialize};
 use near_sdk::{
   near_bindgen, env, AccountId, NearToken, CryptoHash, PanicOnDefault, Promise, PromiseOrValue, BorshStorageKey, NearSchema

nft-contract-basic/src/enumeration.rs

@@ -3,9 +3,9 @@ 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) -> U64 {
         //return the length of the token metadata by ID
-        self.token_metadata_by_id.len()
+        U64(self.token_metadata_by_id.len())
     }
 
     //Query for nft tokens on the contract regardless of the owner using pagination
@@ -29,16 +29,16 @@ impl Contract {
     pub fn nft_supply_for_owner(
       &self,
       account_id: AccountId,
-    ) -> u64 {
+    ) -> U64 {
         //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 {
-            tokens_for_owner_set.len()
+            U64(tokens_for_owner_set.len())
         } else {
             //if there isn't a set of tokens for the passed in account ID, we'll return 0
-            0
+            U64(0)
         }
     }
 

nft-contract-basic/src/lib.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use near_sdk::borsh::{BorshSerialize, BorshDeserialize};
 use near_sdk::collections::{LazyOption, LookupMap, UnorderedMap, UnorderedSet};
-use near_sdk::json_types::Base64VecU8;
+use near_sdk::json_types::{Base64VecU8, U64};
 use near_sdk::serde::{Deserialize, Serialize};
 use near_sdk::{
   near_bindgen, env, AccountId, NearToken, CryptoHash, PanicOnDefault, Promise, PromiseOrValue, BorshStorageKey, NearSchema