using U types for payouts

Author: garikbesson

market-contract/res/nft_simple.wasm

@@ -39,7 +39,7 @@ pub type ContractAndTokenId = String;
 #[derive(Serialize, Deserialize)]
 #[serde(crate = "near_sdk::serde")]
 pub struct Payout {
-    pub payout: HashMap<AccountId, NearToken>,
+    pub payout: HashMap<AccountId, U128>,
 }
 
 //main contract struct to store all the information
@@ -176,8 +176,8 @@ impl Contract {
 
     /// views
     //return the minimum storage for 1 sale
-    pub fn storage_minimum_balance(&self) -> NearToken {
-        storage_per_sale()
+    pub fn storage_minimum_balance(&self) -> U128 {
+        U128(storage_per_sale().as_yoctonear())
     }
 
     //return how much storage an account has paid for

market-contract/src/lib.rs

@@ -43,15 +43,15 @@ impl Contract {
         //we need to enforce that the user has enough storage for 1 EXTRA sale.
 
         //get the storage for a sale
-        let storage_amount = self.storage_minimum_balance();
+        let storage_amount = self.storage_minimum_balance().0;
         //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()).0 + 1).into());
 
         //make sure that the total paid is >= the required storage
         assert!(
-            owner_paid_storage.ge(&signer_storage_required),
+            owner_paid_storage.ge(&NearToken::from_yoctonear(signer_storage_required)),
             "Insufficient storage paid: {}, for {} sales at {} rate of per sale",
             owner_paid_storage, signer_storage_required.saturating_div(storage_per_sale().as_yoctonear()), storage_per_sale()
         );
@@ -92,7 +92,7 @@ impl Contract {
         &mut self,
         nft_contract_id: AccountId,
         token_id: String,
-        price: NearToken,
+        price: U128,
     ) {
         //assert that the user has attached exactly 1 yoctoNEAR (for security reasons)
         assert_one_yocto();
@@ -112,7 +112,7 @@ impl Contract {
         );
 
         //set the sale conditions equal to the passed in price
-        sale.sale_conditions = price;
+        sale.sale_conditions = NearToken::from_yoctonear(price.0);
         //insert the sale back into the map for the unique sale ID
         self.sales.insert(&contract_and_token_id, &sale);
     }
@@ -226,7 +226,7 @@ impl Contract {
                         //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.as_yoctonear())?;
+                            remainder = remainder.checked_sub(value.0)?;
                         }
                         //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
@@ -254,7 +254,7 @@ impl Contract {
 
         // NEAR payouts
         for (receiver_id, amount) in payout {
-            Promise::new(receiver_id).transfer(amount);
+            Promise::new(receiver_id).transfer(NearToken::from_yoctonear(amount.0));
         }
 
         //return the price payout out

market-contract/src/sale.rs

@@ -48,7 +48,7 @@ impl Contract {
         let keys = sales.as_vector();
 
         //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(0));
+        let start = from_index.unwrap_or(0);
 
         //iterate through the keys vector
         keys.iter()

market-contract/src/sale_views.rs

@@ -195,7 +195,7 @@ fn test_update_price() {
         .attached_deposit(ONE_YOCTONEAR)
         .predecessor_account_id(accounts(0))  // bob to buy NFT from alice
         .build());
-    contract.update_price(nft_contract_id, token_id, new_price);
+    contract.update_price(nft_contract_id, token_id, U128(new_price.as_yoctonear()));
 
     // test update price success
     let sale = contract.sales.get(&contract_and_token_id).expect("No sale");

market-contract/src/tests.rs

@@ -11,7 +11,7 @@ impl Contract {
     //Query for nft tokens on the contract regardless of the owner using pagination
     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(0));
+        let start = from_index.unwrap_or(0);
 
         //iterate through each token using an iterator
         self.token_metadata_by_id.keys()

nft-contract-approval/res/nft_simple.wasm

@@ -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, U64};
+use near_sdk::json_types::{Base64VecU8, U64, U128};
 use near_sdk::serde::{Deserialize, Serialize};
 use near_sdk::{
   near_bindgen, env, AccountId, NearToken, CryptoHash, PanicOnDefault, Promise, PromiseOrValue, BorshStorageKey, NearSchema

nft-contract-approval/src/enumeration.rs

@@ -4,7 +4,7 @@ pub type TokenId = String;
 #[derive(Serialize, Deserialize, NearSchema)]
 #[serde(crate = "near_sdk::serde")]
 pub struct Payout {
-    pub payout: HashMap<AccountId, NearToken>,
+    pub payout: HashMap<AccountId, U128>,
 } 
 
 #[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize, Clone, NearSchema)]

nft-contract-approval/src/lib.rs

@@ -2,7 +2,7 @@ use crate::*;
 
 pub trait NonFungibleTokenCore {
     //calculates the payout for a token given the passed in balance. This is a view method
-  	fn nft_payout(&self, token_id: TokenId, balance: NearToken, max_len_payout: u32) -> Payout;
+  	fn nft_payout(&self, token_id: TokenId, balance: U128, max_len_payout: u32) -> Payout;
 
     //transfers the token to the receiver ID and returns the payout object that should be payed given the passed in balance. 
     fn nft_transfer_payout(
@@ -11,7 +11,7 @@ pub trait NonFungibleTokenCore {
         token_id: TokenId,
         approval_id: u64,
         memo: Option<String>,
-        balance: NearToken,
+        balance: U128,
         max_len_payout: u32,
     ) -> Payout;
 }
@@ -20,7 +20,7 @@ pub trait NonFungibleTokenCore {
 impl NonFungibleTokenCore for Contract {
 
     //calculates the payout for a token given the passed in balance. This is a view method
-    fn nft_payout(&self, token_id: TokenId, balance: NearToken, max_len_payout: u32) -> Payout {
+    fn nft_payout(&self, token_id: TokenId, balance: U128, max_len_payout: u32) -> Payout {
 		/*
             FILL THIS IN
         */
@@ -35,7 +35,7 @@ impl NonFungibleTokenCore for Contract {
         token_id: TokenId,
         approval_id: u64,
         memo: Option<String>,
-        balance: NearToken,
+        balance: U128,
         max_len_payout: u32,
     ) -> Payout {
         /*