263 add optimizations audit recommendations

clients/runtime/src/rpc.rs

@@ -1179,24 +1179,29 @@ impl RedeemPallet for SpacewalkParachain {
 				.request("redeem_getVaultRedeemRequests", rpc_params![account_id, head])
 				.await?;
 
-			let redeem_requests: Result<Vec<(H256, SpacewalkRedeemRequest)>, Error> = join_all(
+			let redeem_requests = join_all(
 				result.into_iter().map(|key| async move {
 					self.get_redeem_request(key).await.map(|value| (key, value))
 				})
 			)
-			.await
-			.into_iter()
-			.collect();
-
-			match redeem_requests {
-				Ok(redeem_requests) => {
-					let filtered_results: Vec<_> = redeem_requests
-						.into_iter()
-						.filter_map(|item| filter(item))
-						.collect();
-					Ok(filtered_results)
-				}
-				Err(e) => Err(e),
+			.await;
+
+			let mut some_error: Option<Error> = None;
+			let filtered_results: Vec<_> = redeem_requests
+				.into_iter()
+				.filter_map(|item_maybe| 
+					match item_maybe {
+						Ok(item) => filter(item),
+						Err(e) => {
+							some_error.get_or_insert(e);
+							None
+						},
+					}
+				)
+				.collect();
+			match some_error {
+				Some(err) => Err(err),
+				None => Ok(filtered_results),
 			}
 		}
 
@@ -1382,21 +1387,29 @@ impl ReplacePallet for SpacewalkParachain {
 			.request("replace_getOldVaultReplaceRequests", rpc_params![account_id, head])
 			.await?;
 
-		let redeem_requests: Result<Vec<(H256, SpacewalkReplaceRequest)>, Error> =
+		let replace_requests =
 			join_all(result.into_iter().map(|key| async move {
 				self.get_replace_request(key).await.map(|value| (key, value))
 			}))
-			.await
+			.await;
+
+		let mut some_error: Option<Error> = None;
+		let filtered_results: Vec<_> = replace_requests
 			.into_iter()
+			.filter_map(|item_maybe| 
+				match item_maybe {
+					Ok(item) => filter(item),
+					Err(e) => {
+						some_error.get_or_insert(e);
+						None
+					},
+				}
+			)
 			.collect();
 
-		match redeem_requests {
-			Ok(redeem_requests) => {
-				let filtered_results: Vec<_> =
-					redeem_requests.into_iter().filter_map(|item| filter(item)).collect();
-					Ok(filtered_results)
-				},
-			Err(e) => Err(e),
+		match some_error {
+			Some(err) => Err(err),
+			None => Ok(filtered_results),
 		}
 
 	}

clients/vault/src/cancellation.rs

@@ -169,7 +169,18 @@ impl<P: IssuePallet + ReplacePallet + Send + Sync> Canceller<P> for ReplaceCance
 // verbose drain_filter
 fn drain_expired(requests: &mut Vec<ActiveRequest>, current_height: u32) -> Vec<ActiveRequest> {
 
-	requests.drain(..).filter(|active_req| current_height > active_req.parachain_deadline_height).collect()
+	let mut expired = Vec::new();
+
+    requests.retain(|req| {
+        if current_height > req.parachain_deadline_height {
+            expired.push(req.clone());
+            false
+        } else {
+            true
+        }
+    });
+
+    expired
 
 }
 

clients/vault/src/oracle/collector/proof_builder.rs

@@ -115,7 +115,6 @@ impl ScpMessageCollector {
 		slot: Slot,
 		sender: &StellarMessageSender,
 	) -> Option<UnlimitedVarArray<ScpEnvelope>> {
-		let empty = UnlimitedVarArray::new_empty();
 
 		if let Some(envelopes) = self.envelopes_map().get(&slot) {
 			// lacking envelopes
@@ -124,7 +123,7 @@ impl ScpMessageCollector {
 					"Proof Building for slot {slot}: not enough envelopes to build proof "
 				);
 			} else {
-				return Some(UnlimitedVarArray::new(envelopes.clone()).unwrap_or(empty))
+				return UnlimitedVarArray::new(envelopes.clone()).ok()
 			}
 		}
 

pallets/issue/src/lib.rs

@@ -28,7 +28,7 @@ use currency::Amount;
 pub use default_weights::{SubstrateWeight, WeightInfo};
 pub use pallet::*;
 use types::IssueRequestExt;
-use vault_registry::{CurrencySource};
+use vault_registry::{CurrencySource, VaultStatus};
 
 use crate::types::{BalanceOf, CurrencyId, DefaultVaultId};
 #[doc(inline)]
@@ -388,7 +388,9 @@ impl<T: Config> Pallet<T> {
 		Self::check_volume(amount_requested.clone())?;
 
 		// ensure that the vault is accepting new issues (vault is active)
-		let _vault = ext::vault_registry::get_active_vault_from_id::<T>(&vault_id).map_err(|_| Error::<T>::VaultNotAcceptingNewIssues)?;
+		let vault = ext::vault_registry::get_active_vault_from_id::<T>(&vault_id)?;
+
+		ensure!(vault.status == VaultStatus::Active(true), Error::<T>::VaultNotAcceptingNewIssues);
 
 		// Check that the vault is currently not banned
 		ext::vault_registry::ensure_not_banned::<T>(&vault_id)?;

pallets/vault-registry/src/lib.rs

@@ -198,7 +198,6 @@ pub mod pallet {
 			let vault = Self::get_active_rich_vault_from_id(&vault_id)?;
 
 			let amount = Amount::new(amount, currency_pair.collateral);
-
 			Self::try_deposit_collateral(&vault_id, &amount)?;
 
 			Self::deposit_event(Event::<T>::DepositCollateral {
@@ -911,7 +910,6 @@ impl<T: Config> Pallet<T> {
 		vault_id: &DefaultVaultId<T>,
 		amount: &Amount<T>,
 	) -> DispatchResult {
-
 		// ensure the vault is active
 		let _vault = Self::get_active_rich_vault_from_id(vault_id)?;
 

primitives/src/lib.rs

@@ -849,10 +849,14 @@ impl TransactionEnvelopeExt for TransactionEnvelope {
 		let tx_operations: Vec<Operation> = match self {
 			TransactionEnvelope::EnvelopeTypeTxV0(env) => env.tx.operations.get_vec().clone(),
 			TransactionEnvelope::EnvelopeTypeTx(env) => env.tx.operations.get_vec().clone(),
-			TransactionEnvelope::EnvelopeTypeTxFeeBump(_) => return BalanceConversion::unlookup(transferred_amount),
-			TransactionEnvelope::Default(_) => return BalanceConversion::unlookup(transferred_amount),
+			TransactionEnvelope::EnvelopeTypeTxFeeBump(_) => Vec::new(),
+			TransactionEnvelope::Default(_) => Vec::new(),
 		};
 
+		if tx_operations.len() == 0 {
+			return BalanceConversion::unlookup(transferred_amount);
+		}
+
 		transferred_amount = tx_operations
 			.iter()
 			.fold(0i64, |acc, x| {