readme update (#139)

* fix: renewal space unfreeze

* feat: add some root extrisic

* feat: add some root function for test

* style: 0.5.4 add new field

* style: for distinguish chain

* feat: some root function for test

* feat: for test

* test: migration test

* fix: fix random bug

* fix: index from 1 start

* fix: random seed

* fix: random seed

* config: string limit 50000 -> 60000

* feat: batch delete files

* style: clear warning

* merge: frame-upgrade

* fix: fix merge bug

* refactor: add storage-handler pallet

* fix: fix recursing

* refactor: file-bank pallet adapt

* refactor: adapt storage handle

* refactor: rename file-map -> tee-worker

* refactor: rename file-map -> tee-worker

* fix: bug

* refactor: segment-book -> audit

* feat: upload_deal

* feat: upload_deal

* feat: upload_deal

* feat: upload_deal

* feat: upload deal

* feat: tranfser_report

* feat: time task deal_reassign_miner

* feat: unlock space for miner

* feat: calculate time task

* feat: delete file

* style: add Event

* style: fix warning

* refactor: idle space and service space change when segment add or delete

* feat: some func for test

* style: framework optimization

* fix: update FragmentCount const

* fix: fragment repeat causing BoundedVecError

* refactor: tuple to struct for go-substrate-sdk

* fix: update lock space, miner and user

* feat: add two new package

* feat: tee register

* feat: add report verify

* feat: generate challeng(40%)

* tests: ed25519 verify sig

* feat: generate challenge

* feat: submit prove

* feat: challenge clear

* feat: miner reward

* feat: clear and prove punish

* feat: three punish

* feat: lock miner

* feat: miner exit

* feat: filter for lock miner

* feat: update increase_collateral for debt

* feat: force miner exit

* feat: use force exit miner

* feat: clear expire file

* feat: delete file

* fix: transfer file  delete file

* feat: test rsa verify

* style: fix warning

* style: peer id types update

* feat: unlock offchain

* feat: add punish tee worker

* fix: challenge select miner when miner number < 10

* fix: fix challengesnapshot bug

* fix: miner exit bug

* style: add withdraw event

* style: update type

* test: add some test function

* test: add update_peer_id and exit

* test: purchase in mib units

* feat: random 0.046 chunks and random random number

* feat: add new filed

* fix: fix bug in reassigning validation tasks

* style: delete methods that are no longer in use

* feat: add methods for deleting fillers

* style: some related modifications made for testing purposes

* fix: miner exit prep error

* feat: restoral file

* fix: fix compile error

* fix: fix random select miner

* style: add restoral event

* refactor: optimize space expiration functionality

* test: some for test function

* feat: add stake_score in validator election (#125)

* feat: add stake_score in election

* fix: merge conflics

* fix: paritytech/substrate#13804

* test: test for bls

* style: merge

* test: test bls

* feat: restoral order storage

* feat: restoral order storage key

* test: update data for test

* fix: fix space expire bug

* fix: fix upload file user hold slice list

* fix: fix random select miner

* test: for test add some function

* Make verify-bls-signatures no_std compatible (#137)

* - Fixed a warning and compile
- Adding verify-bls-signatures in utils
- Replace Rand lib with getrandom to make it no_std compatible

* uncomment BLS and using dummy rand

* Using getrandom custom

* fix: cancel schedule mission

* fix: file upload update UserBucketList

* style: streamline code

* fix: space expired user bucket list kill

* Update README.md

---------

Co-authored-by: ytqaljn <2716693942@qq.com>
Co-authored-by: Shaka Lavigne <shakawwq@gmail.com>
Co-authored-by: Jimmy Chu <jimmychu0807@gmail.com>
Co-authored-by: Dean Clark <32699199+thirteenggh@users.noreply.github.com>

Author: 5 people

Cargo.lock

@@ -14,7 +14,7 @@
 
 ### Install Guide
 
-Follow [Setup](docs/setup.md) to guide you install the CESS development.
+Follow [Setup](docs/setup.md) to guide you to install the CESS development.
 
 ### Build Node
 

README.md

@@ -906,8 +906,9 @@ pub mod pallet {
 			if miner_count == 0 {
 				Err(OffchainErr::GenerateInfoError)?;
 			}
-
-			let need_miner_count = miner_count / 10 + 1;
+			//For TEST
+			let need_miner_count = miner_count;
+			// let need_miner_count = miner_count / 10 + 1;
 
 			let mut miner_list: BoundedVec<MinerSnapShot<AccountOf<T>>, T::ChallengeMinerMax> = Default::default();
 
@@ -916,8 +917,10 @@ pub mod pallet {
 			let mut total_idle_space: u128 = u128::MIN;
 			let mut total_service_space: u128 = u128::MIN;
 			// TODO: need to set a maximum number of cycles
-			while (miner_list.len() as u32 != need_miner_count) || (valid_index_list.len() as u32 != miner_count) {
-				let index_list = Self::random_select_miner(need_miner_count, miner_count, &valid_index_list);
+			let mut seed: u32 = 20230601;
+			while (miner_list.len() as u32 != need_miner_count) && (valid_index_list.len() as u32 != miner_count) {
+				seed = seed.saturating_add(1); 
+				let index_list = Self::random_select_miner(need_miner_count, miner_count, &valid_index_list, seed);
 
 				let allminer = T::MinerControl::get_all_miner().map_err(|_| OffchainErr::GenerateInfoError)?;
 
@@ -944,7 +947,7 @@ pub mod pallet {
 					};
 					let result = miner_list.try_push(miner_snapshot);
 					if let Err(_e) = result {
-						break;
+						return Err(OffchainErr::GenerateInfoError)?;
 					};
 				}
 			}
@@ -985,10 +988,10 @@ pub mod pallet {
 		}
 
 		// Ensure that the length is not 0
-		fn random_select_miner(need: u32, length: u32, valid_index_list: &Vec<u32>) -> Vec<u32> {
+		fn random_select_miner(need: u32, length: u32, valid_index_list: &Vec<u32>, seed: u32) -> Vec<u32> {
 			let mut miner_index_list: Vec<u32> = Default::default();
-			let mut seed: u32 = 20230417;
-			while (miner_index_list.len() as u32) < need {
+			let mut seed: u32 = seed.saturating_mul(1000);
+			while (miner_index_list.len() as u32) < need && ((valid_index_list.len() + miner_index_list.len()) as u32 != length) {
 				seed += 1;
 				let index = Self::random_number(seed);
 				let index: u32 = (index % length as u64) as u32;

c-pallets/audit/src/lib.rs

@@ -79,7 +79,6 @@ pub mod pallet {
 
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
-
 		/// Register for cacher.
 		///	
 		/// Parameters:

c-pallets/cacher/src/lib.rs

@@ -41,7 +41,15 @@ fn update_works() {
 			byte_price: 200u32.into(),
 		};
 		// Wrong accout update fails.
+<<<<<<< HEAD
+<<<<<<< HEAD
 		assert_noop!(Cacher::update(RuntimeOrigin::signed(2), new_info.clone()), Error::<Test>::UnRegister);
+=======
+		assert_noop!(Cacher::update(Origin::signed(2), new_info.clone()), Error::<Test>::UnRegistered);
+>>>>>>> main
+=======
+		assert_noop!(Cacher::update(RuntimeOrigin::signed(2), new_info.clone()), Error::<Test>::UnRegister);
+>>>>>>> main
 		// Update works.
 		assert_ok!(Cacher::update(RuntimeOrigin::signed(1), new_info.clone()));
 
@@ -61,7 +69,15 @@ fn logout_works() {
 		assert_ok!(Cacher::register(RuntimeOrigin::signed(1), info.clone()));
 
 		// Wrong accout logout fails.
+<<<<<<< HEAD
+<<<<<<< HEAD
+		assert_noop!(Cacher::logout(RuntimeOrigin::signed(2)), Error::<Test>::UnRegister);
+=======
+		assert_noop!(Cacher::logout(Origin::signed(2)), Error::<Test>::UnRegistered);
+>>>>>>> main
+=======
 		assert_noop!(Cacher::logout(RuntimeOrigin::signed(2)), Error::<Test>::UnRegister);
+>>>>>>> main
 		// Logout works.
 		assert_ok!(Cacher::logout(RuntimeOrigin::signed(1)));
 	});
@@ -89,7 +105,15 @@ fn pay_works() {
 		let bills: BoundedVec<_, <Test as Config>::BillsLimit> = bill_vec.try_into().unwrap();
 
 		// Pay fails.
+<<<<<<< HEAD
+<<<<<<< HEAD
+		assert_noop!(Cacher::pay(RuntimeOrigin::signed(1), bills.clone()), Error::<Test>::InsufficientBalance);
+=======
+		assert_noop!(Cacher::pay(Origin::signed(1), bills.clone()), BalancesError::<Test>::InsufficientBalance);
+>>>>>>> main
+=======
 		assert_noop!(Cacher::pay(RuntimeOrigin::signed(1), bills.clone()), Error::<Test>::InsufficientBalance);
+>>>>>>> main
 
 		<Test as Config>::Currency::make_free_balance_be(&1, BalanceOf::<Test>::max_value());
 		let balance_befor_1 = <Test as Config>::Currency::free_balance(&1);

c-pallets/cacher/src/tests.rs

@@ -101,7 +101,12 @@ impl<T: Config> Pallet<T> {
             bucket.object_list.try_push(hash).map_err(|_e| Error::<T>::BoundedVecError)?;
         }
 
-        <Bucket<T>>::insert(user, bucket_name, bucket);
+        <Bucket<T>>::insert(user, bucket_name.clone(), bucket);
+
+        <UserBucketList<T>>::try_mutate(&user, |bucket_list| -> DispatchResult{
+            bucket_list.try_push(bucket_name.clone()).map_err(|_e| Error::<T>::LengthExceedsLimit)?;
+            Ok(())
+        })?;
 
         Ok(())
     }
@@ -182,50 +187,49 @@ impl<T: Config> Pallet<T> {
     pub(super) fn random_assign_miner(
         needed_list: &BoundedVec<SegmentList<T>, T::SegmentCount>
     ) -> Result<BoundedVec<MinerTaskList<T>, T::StringLimit>, DispatchError> {
-        let mut index_list: Vec<u32> = Default::default();
         let mut miner_task_list: BoundedVec<MinerTaskList<T>, T::StringLimit> = Default::default();
         let mut miner_idle_space_list: Vec<u128> = Default::default();
         // The optimal number of miners required for storage.
         // segment_size * 1.5 / fragment_size.
         let miner_count: u32 = (SEGMENT_SIZE * 15 / 10 / FRAGMENT_SIZE) as u32;
         let mut seed = <frame_system::Pallet<T>>::block_number().saturated_into();
 
-        let all_miner = T::MinerControl::get_all_miner()?;
-        let total = all_miner.len() as u32;
+        let mut all_miner = T::MinerControl::get_all_miner()?;
+        let mut total = all_miner.len() as u32;
 
         // ensure!(total > miner_count, Error::<T>::NodesInsufficient);
         let max_count = miner_count * 5;
         let mut cur_count = 0;
         let mut total_idle_space = 0;
+
         // start random choose miner
         loop {
             // Get a random subscript.
+            if total == 0 {
+                break;
+            }
+
             let index = Self::generate_random_number(seed)? as u32 % total;
             // seed + 1
             seed = seed.checked_add(1).ok_or(Error::<T>::Overflow)?;
-            // Number of cycles plus 1
-            cur_count += 1;
+
             // When the number of cycles reaches the upper limit, the cycle ends.
             if cur_count == max_count {
                 break;
             }
-            // End the cycle after all storage nodes have been traversed.
-            if total == index_list.len() as u32 {
-                break;
-            }
-            // Continue to the next cycle when the current random result already exists.
-            if index_list.contains(&index) {
-                continue;
-            }
-            
+
+            // Number of cycles plus 1
+            cur_count += 1;
+
             // Judge whether the idle space of the miners is sufficient.
             let miner = all_miner[index as usize].clone();
+            all_miner.remove(index as usize);
+            total = total - 1;
             let result = T::MinerControl::is_positive(&miner)?;
             if !result {
                 continue;
             }
-            // Record current cycle results.
-            index_list.push(index);
+           
             let cur_space: u128 = T::MinerControl::get_miner_idle_space(&miner)?;
             // If sufficient, the miner is selected.
             if cur_space > needed_list.len() as u128 * FRAGMENT_SIZE {
@@ -393,7 +397,11 @@ impl<T: Config> Pallet<T> {
         }
 
         for (miner, count) in miner_list.iter() {
-            T::MinerControl::sub_miner_service_space(miner, FRAGMENT_SIZE * *count as u128)?;
+            if <RestoralTarget<T>>::contains_key(miner) {
+                Self::update_restoral_target(miner, FRAGMENT_SIZE * *count as u128)?;
+            } else {
+                T::MinerControl::sub_miner_service_space(miner, FRAGMENT_SIZE * *count as u128)?;
+            }
             weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 1));
         }
 
@@ -541,7 +549,8 @@ impl<T: Config> Pallet<T> {
         let now = <frame_system::Pallet<T>>::block_number();
         let block = now.checked_add(&block.saturated_into()).ok_or(Error::<T>::Overflow)?;
 
-        let restoral_info = RestoralInfo::<BlockNumberOf<T>>{
+        let restoral_info = RestoralTargetInfo::<AccountOf<T>, BlockNumberOf<T>>{
+            miner: miner.clone(),
             service_space,
             restored_space: u128::MIN,
             cooling_block: block,
@@ -551,4 +560,15 @@ impl<T: Config> Pallet<T> {
 
         Ok(())
     }
+
+    pub(super) fn update_restoral_target(miner: &AccountOf<T>, service_space: u128) -> DispatchResult {
+        <RestoralTarget<T>>::try_mutate(miner, |info_opt| -> DispatchResult {
+            let info = info_opt.as_mut().ok_or(Error::<T>::NonExistent)?;
+
+            info.restored_space = info.restored_space
+                .checked_add(service_space).ok_or(Error::<T>::Overflow)?;
+
+            Ok(())
+        })
+    }
 }