Collections: changes after merge

contracts/auctions/src/lib.rs

@@ -1,6 +1,6 @@
 #![no_std]
 
-use soroban_sdk::{contract, contractimpl, contracttype, Address, BytesN, Env, Vec};
+use soroban_sdk::{contract, contractimpl, contracttype, Address, Env, Vec};
 
 #[derive(Clone)]
 #[contracttype]

contracts/collections/src/contract.rs

@@ -1,9 +1,12 @@
-use soroban_sdk::{contract, contractimpl, log, vec, Address, Bytes, Env, String, Vec};
+use soroban_sdk::{contract, contractimpl, log, vec, Address, Bytes, BytesN, Env, String, Vec};
 
 use crate::{
     error::ContractError,
     storage::{
-        utils::{get_admin, get_balance_of, save_admin, save_config, update_balance_of},
+        utils::{
+            get_admin, get_balance_of, is_initialized, save_admin, save_config, set_initialized,
+            update_balance_of,
+        },
         Config, DataKey, OperatorApprovalKey, URIValue,
     },
 };
@@ -19,13 +22,28 @@ impl Collections {
         env: Env,
         admin: Address,
         name: String,
-        image: URIValue,
+        symbol: String,
     ) -> Result<(), ContractError> {
-        let config = Config { name, image };
+        let config = Config {
+            name: name.clone(),
+            symbol: symbol.clone(),
+        };
+
+        if is_initialized(&env) {
+            log!(&env, "Collections: Initialize: Already initialized");
+            return Err(ContractError::AlreadyInitialized);
+        }
 
         save_config(&env, config)?;
         save_admin(&env, &admin)?;
 
+        set_initialized(&env);
+
+        env.events()
+            .publish(("initialize", "collection name: "), name);
+        env.events()
+            .publish(("initialize", "collectoin symbol: "), symbol);
+
         Ok(())
     }
 
@@ -46,7 +64,6 @@ impl Collections {
             log!(&env, "Collections: Balance of batch: length missmatch");
             return Err(ContractError::AccountsIdsLengthMissmatch);
         }
-
         let mut batch_balances: Vec<u64> = vec![&env];
 
         // we verified that the length of both `accounts` and `ids` is the same
@@ -83,12 +100,21 @@ impl Collections {
 
         env.storage().persistent().set(
             &DataKey::OperatorApproval(OperatorApprovalKey {
-                owner: sender,
-                operator,
+                owner: sender.clone(),
+                operator: operator.clone(),
             }),
             &approved,
         );
 
+        env.events()
+            .publish(("Set approval for", "Sender: "), sender);
+        env.events().publish(
+            ("Set approval for", "Set approval for operator: "),
+            operator,
+        );
+        env.events()
+            .publish(("Set approval for", "New approval: "), approved);
+
         Ok(())
     }
 
@@ -119,7 +145,6 @@ impl Collections {
         to: Address,
         id: u64,
         transfer_amount: u64,
-        _data: Bytes, // we don't have onERC1155Received in Stellar/Soroban
     ) -> Result<(), ContractError> {
         from.require_auth();
         // TODO: check if `to` is not zero address
@@ -139,6 +164,12 @@ impl Collections {
         // next we incrase the recipient's `to` balance
         update_balance_of(&env, &to, id, rcpt_balance + transfer_amount)?;
 
+        env.events().publish(("safe transfer from", "from: "), from);
+        env.events().publish(("safe transfer from", "to: "), to);
+        env.events().publish(("safe transfer from", "id: "), id);
+        env.events()
+            .publish(("safe transfer from", "transfer amount: "), transfer_amount);
+
         Ok(())
     }
 
@@ -150,7 +181,6 @@ impl Collections {
         to: Address,
         ids: Vec<u64>,
         amounts: Vec<u64>,
-        _data: Bytes, // we don't have onERC1155Received in Stellar/Soroban
     ) -> Result<(), ContractError> {
         from.require_auth();
         // TODO: check if `to` is not zero address
@@ -185,6 +215,15 @@ impl Collections {
             update_balance_of(&env, &to, id, rcpt_balance + amount)?;
         }
 
+        env.events()
+            .publish(("safe batch transfer from", "from: "), from);
+        env.events()
+            .publish(("safe batch transfer from", "to: "), to);
+        env.events()
+            .publish(("safe batch transfer from", "ids: "), ids);
+        env.events()
+            .publish(("safe batch transfer from", "amounts: "), amounts);
+
         Ok(())
     }
 
@@ -202,13 +241,16 @@ impl Collections {
 
         let admin = get_admin(&env)?;
         if admin != sender {
-            log!(&env, "Collections: Set uri: Unauthorized");
+            log!(&env, "Collections: Mint: Unauthorized");
             return Err(ContractError::Unauthorized);
         }
 
-        let current_balance = get_balance_of(&env, &to, id)?;
-        //TODO: check for overflow?
-        update_balance_of(&env, &to, id, current_balance + amount)?;
+        update_balance_of(&env, &to, id, amount)?;
+
+        env.events().publish(("mint", "sender: "), sender);
+        env.events().publish(("mint", "to: "), to);
+        env.events().publish(("mint", "id: "), id);
+        env.events().publish(("mint", "amount: "), amount);
 
         Ok(())
     }
@@ -226,7 +268,7 @@ impl Collections {
 
         let admin = get_admin(&env)?;
         if admin != sender {
-            log!(&env, "Collections: Set uri: Unauthorized");
+            log!(&env, "Collections: Mint batch: Unauthorized");
             return Err(ContractError::Unauthorized);
         }
 
@@ -239,11 +281,15 @@ impl Collections {
             let id = ids.get(idx).unwrap();
             let amount = amounts.get(idx).unwrap();
 
-            let current_balance = get_balance_of(&env, &to, id)?;
             //TODO: check for overflow?
-            update_balance_of(&env, &to, id, current_balance + amount)?;
+            update_balance_of(&env, &to, id, amount)?;
         }
 
+        env.events().publish(("mint batch", "sender: "), sender);
+        env.events().publish(("mint batch", "to: "), to);
+        env.events().publish(("mint batch", "ids: "), ids);
+        env.events().publish(("mint batch", "amounts: "), amounts);
+
         Ok(())
     }
 
@@ -262,6 +308,10 @@ impl Collections {
 
         update_balance_of(&env, &from, id, current_balance - amount)?;
 
+        env.events().publish(("burn", "from: "), from);
+        env.events().publish(("burn", "id: "), id);
+        env.events().publish(("burn", "amount: "), amount);
+
         Ok(())
     }
 
@@ -293,6 +343,10 @@ impl Collections {
             update_balance_of(&env, &from, id, current_balance - amount)?;
         }
 
+        env.events().publish(("burn batch", "from: "), from);
+        env.events().publish(("burn batch", "ids: "), ids);
+        env.events().publish(("burn batch", "amounts: "), amounts);
+
         Ok(())
     }
 
@@ -308,7 +362,25 @@ impl Collections {
 
         env.storage()
             .persistent()
-            .set(&DataKey::Uri(id), &URIValue { uri });
+            .set(&DataKey::Uri(id), &URIValue { uri: uri.clone() });
+
+        env.events().publish(("set uri", "sender: "), sender);
+        env.events().publish(("set uri", "id: "), id);
+        env.events().publish(("set uri", "uri: "), uri);
+
+        Ok(())
+    }
+
+    // Sets the main image(logo) for the collection
+    #[allow(dead_code)]
+    pub fn set_collection_uri(env: Env, uri: Bytes) -> Result<(), ContractError> {
+        get_admin(&env)?.require_auth();
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::CollectionUri, &URIValue { uri: uri.clone() });
+
+        env.events().publish(("set collection uri", "uri: "), uri);
 
         Ok(())
     }
@@ -324,6 +396,28 @@ impl Collections {
         }
     }
 
+    // Returns the URI for a token type `id`
+    #[allow(dead_code)]
+    pub fn collection_uri(env: Env) -> Result<URIValue, ContractError> {
+        if let Some(uri) = env.storage().persistent().get(&DataKey::CollectionUri) {
+            Ok(uri)
+        } else {
+            log!(&env, "Collections: Uri: No collection uri set");
+            Err(ContractError::NoUriSet)
+        }
+    }
+
+    #[allow(dead_code)]
+    #[cfg(not(tarpaulin_include))]
+    pub fn upgrade(env: Env, new_wasm_hash: BytesN<32>) -> Result<(), ContractError> {
+        let admin: Address = get_admin(&env)?;
+        admin.require_auth();
+
+        env.deployer().update_current_contract_wasm(new_wasm_hash);
+
+        Ok(())
+    }
+
     #[cfg(test)]
     #[allow(dead_code)]
     pub fn show_admin(env: &Env) -> Result<Address, ContractError> {

contracts/collections/src/error.rs

@@ -14,4 +14,7 @@ pub enum ContractError {
     Unauthorized = 7,
     InvalidAccountIndex = 8,
     InvalidIdIndex = 9,
+    NftIdNotFound = 10,
+    AlreadyInitialized = 11,
+    EntryDoesNotExist = 12,
 }

contracts/collections/src/storage.rs

@@ -8,14 +8,8 @@ use soroban_sdk::{contracttype, symbol_short, Address, Bytes, String, Symbol};
 //pub(crate) const BALANCE_LIFETIME_THRESHOLD: u32 = BALANCE_BUMP_AMOUNT - DAY_IN_LEDGERS;
 
 type NftId = u64;
-
-// Struct to represent a token balance for a specific address and token ID
-#[derive(Clone)]
-#[contracttype]
-pub struct BalanceDataKey {
-    pub token_id: u64,
-    pub owner: Address,
-}
+type TokenId = u64;
+type Balance = u64;
 
 // Struct to represent the operator approval status
 #[derive(Clone)]
@@ -29,10 +23,12 @@ pub struct OperatorApprovalKey {
 #[derive(Clone)]
 #[contracttype]
 pub enum DataKey {
-    Balance(BalanceDataKey),
+    Balance(Address),
     OperatorApproval(OperatorApprovalKey),
     Uri(NftId),
+    CollectionUri,
     Config,
+    IsInitialized,
 }
 
 // Struct to represent token URI
@@ -46,29 +42,30 @@ pub struct URIValue {
 #[contracttype]
 pub struct Config {
     pub name: String,
-    pub image: URIValue,
+    pub symbol: String,
 }
 
 pub const ADMIN: Symbol = symbol_short!("admin");
 
 pub mod utils {
-    use soroban_sdk::{log, Address, Env};
+    use soroban_sdk::{log, Address, Env, Map};
 
     use crate::error::ContractError;
 
-    use super::{Config, DataKey, ADMIN};
+    use super::{Balance, Config, DataKey, TokenId, ADMIN};
 
     pub fn get_balance_of(env: &Env, owner: &Address, id: u64) -> Result<u64, ContractError> {
-        let result = env
+        let balance_map: Map<TokenId, Balance> = env
             .storage()
             .persistent()
-            .get(&DataKey::Balance(crate::storage::BalanceDataKey {
-                token_id: id,
-                owner: owner.clone(),
-            }))
-            .unwrap_or(0u64);
+            .get(&DataKey::Balance(owner.clone()))
+            .unwrap_or(Map::new(env));
 
-        Ok(result)
+        if let Some(balance) = balance_map.get(id) {
+            Ok(balance)
+        } else {
+            Ok(0u64)
+        }
     }
 
     pub fn update_balance_of(
@@ -77,13 +74,17 @@ pub mod utils {
         id: u64,
         new_amount: u64,
     ) -> Result<(), ContractError> {
-        env.storage().persistent().set(
-            &DataKey::Balance(crate::storage::BalanceDataKey {
-                token_id: id,
-                owner: owner.clone(),
-            }),
-            &new_amount,
-        );
+        let mut balance_map: Map<TokenId, Balance> = env
+            .storage()
+            .persistent()
+            .get(&DataKey::Balance(owner.clone()))
+            .unwrap_or(Map::new(env));
+
+        balance_map.set(id, new_amount);
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::Balance(owner.clone()), &balance_map);
 
         Ok(())
     }
@@ -95,6 +96,7 @@ pub mod utils {
     }
 
     #[allow(dead_code)]
+    #[cfg(not(tarpaulin_include))]
     pub fn get_config(env: &Env) -> Result<Config, ContractError> {
         if let Some(config) = env.storage().persistent().get(&DataKey::Config) {
             Ok(config)
@@ -110,6 +112,7 @@ pub mod utils {
         Ok(())
     }
 
+    #[cfg(not(tarpaulin_include))]
     pub fn get_admin(env: &Env) -> Result<Address, ContractError> {
         if let Some(admin) = env.storage().persistent().get(&ADMIN) {
             Ok(admin)
@@ -118,4 +121,16 @@ pub mod utils {
             Err(ContractError::AdminNotSet)
         }
     }
+    pub fn is_initialized(env: &Env) -> bool {
+        env.storage()
+            .persistent()
+            .get(&DataKey::IsInitialized)
+            .unwrap_or(false)
+    }
+
+    pub fn set_initialized(env: &Env) {
+        env.storage()
+            .persistent()
+            .set(&DataKey::IsInitialized, &true);
+    }
 }