feat: add opt-out config to execute all redeem and replace requests

Signed-off-by: Gregory Hill <[email protected]>

runtime/src/rpc.rs

@@ -939,7 +939,7 @@ pub trait ReplacePallet {
     /// Get all replace requests made by the given vault
     async fn get_old_vault_replace_requests(
         &self,
-        account_id: AccountId,
+        maybe_account_id: Option<AccountId>,
     ) -> Result<Vec<(H256, InterBtcReplaceRequest)>, Error>;
 
     /// Get the time difference in number of blocks between when a replace
@@ -1035,22 +1035,35 @@ impl ReplacePallet for InterBtcParachain {
     /// Get all replace requests made by the given vault
     async fn get_old_vault_replace_requests(
         &self,
-        account_id: AccountId,
+        maybe_account_id: Option<AccountId>,
     ) -> Result<Vec<(H256, InterBtcReplaceRequest)>, Error> {
         let head = self.get_finalized_block_hash().await?;
-        let result: Vec<H256> = self
-            .api
-            .rpc()
-            .request("replace_getOldVaultReplaceRequests", rpc_params![account_id, head])
-            .await?;
-        join_all(
-            result
-                .into_iter()
-                .map(|key| async move { self.get_replace_request(key).await.map(|value| (key, value)) }),
-        )
-        .await
-        .into_iter()
-        .collect()
+        if let Some(account_id) = maybe_account_id {
+            let result: Vec<H256> = self
+                .api
+                .rpc()
+                .request("replace_getOldVaultReplaceRequests", rpc_params![account_id, head])
+                .await?;
+            join_all(
+                result
+                    .into_iter()
+                    .map(|key| async move { self.get_replace_request(key).await.map(|value| (key, value)) }),
+            )
+            .await
+            .into_iter()
+            .collect()
+        } else {
+            let key_addr = metadata::storage().replace().replace_requests_root();
+            let mut iter = self.api.storage().iter(key_addr, DEFAULT_PAGE_SIZE, head).await?;
+            let mut replace_requests = Vec::new();
+            while let Some((replace_id, request)) = iter.next().await? {
+                let key_hash = replace_id.0.as_slice();
+                // last bytes are the raw key
+                let key = &key_hash[key_hash.len() - 32..];
+                replace_requests.push((H256::from_slice(key), request));
+            }
+            Ok(replace_requests)
+        }
     }
 
     async fn get_replace_period(&self) -> Result<u32, Error> {
@@ -1340,10 +1353,11 @@ pub trait RedeemPallet {
 
     async fn get_redeem_request(&self, redeem_id: H256) -> Result<InterBtcRedeemRequest, Error>;
 
-    /// Get all redeem requests requested of the given vault
-    async fn get_vault_redeem_requests(
+    /// Get all redeem requests, if the account is specified
+    /// only return those for that Vault
+    async fn get_redeem_requests(
         &self,
-        account_id: AccountId,
+        maybe_account_id: Option<AccountId>,
     ) -> Result<Vec<(H256, InterBtcRedeemRequest)>, Error>;
 
     async fn get_redeem_period(&self) -> Result<BlockNumber, Error>;
@@ -1386,24 +1400,37 @@ impl RedeemPallet for InterBtcParachain {
             .await
     }
 
-    async fn get_vault_redeem_requests(
+    async fn get_redeem_requests(
         &self,
-        account_id: AccountId,
+        maybe_account_id: Option<AccountId>,
     ) -> Result<Vec<(H256, InterBtcRedeemRequest)>, Error> {
         let head = self.get_finalized_block_hash().await?;
-        let result: Vec<H256> = self
-            .api
-            .rpc()
-            .request("redeem_getVaultRedeemRequests", rpc_params![account_id, head])
-            .await?;
-        join_all(
-            result
-                .into_iter()
-                .map(|key| async move { self.get_redeem_request(key).await.map(|value| (key, value)) }),
-        )
-        .await
-        .into_iter()
-        .collect()
+        if let Some(account_id) = maybe_account_id {
+            let result: Vec<H256> = self
+                .api
+                .rpc()
+                .request("redeem_getVaultRedeemRequests", rpc_params![account_id, head])
+                .await?;
+            join_all(
+                result
+                    .into_iter()
+                    .map(|key| async move { self.get_redeem_request(key).await.map(|value| (key, value)) }),
+            )
+            .await
+            .into_iter()
+            .collect()
+        } else {
+            let key_addr = metadata::storage().redeem().redeem_requests_root();
+            let mut iter = self.api.storage().iter(key_addr, DEFAULT_PAGE_SIZE, head).await?;
+            let mut redeem_requests = Vec::new();
+            while let Some((redeem_id, request)) = iter.next().await? {
+                let key_hash = redeem_id.0.as_slice();
+                // last bytes are the raw key
+                let key = &key_hash[key_hash.len() - 32..];
+                redeem_requests.push((H256::from_slice(key), request));
+            }
+            Ok(redeem_requests)
+        }
     }
 
     async fn get_redeem_period(&self) -> Result<BlockNumber, Error> {

vault/src/cancellation.rs

@@ -358,7 +358,7 @@ mod tests {
             async fn execute_replace(&self, replace_id: H256, merkle_proof: &[u8], raw_tx: &[u8]) -> Result<(), RuntimeError>;
             async fn cancel_replace(&self, replace_id: H256) -> Result<(), RuntimeError>;
             async fn get_new_vault_replace_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
-            async fn get_old_vault_replace_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
+            async fn get_old_vault_replace_requests(&self, maybe_account_id: Option<AccountId>) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
             async fn get_replace_period(&self) -> Result<u32, RuntimeError>;
             async fn get_replace_request(&self, replace_id: H256) -> Result<InterBtcReplaceRequest, RuntimeError>;
             async fn get_replace_dust_amount(&self) -> Result<u128, RuntimeError>;

vault/src/execution.rs

@@ -471,14 +471,15 @@ pub async fn execute_open_requests(
     num_confirmations: u32,
     payment_margin: Duration,
     auto_rbf: bool,
+    no_execute_all: bool,
 ) -> Result<(), ServiceError<Error>> {
     let parachain_rpc = &parachain_rpc;
     let vault_id = parachain_rpc.get_account_id().clone();
 
     // get all redeem and replace requests
     let (redeem_requests, replace_requests) = try_join!(
-        parachain_rpc.get_vault_redeem_requests(vault_id.clone()),
-        parachain_rpc.get_old_vault_replace_requests(vault_id.clone()),
+        parachain_rpc.get_redeem_requests(no_execute_all.then_some(vault_id.clone())),
+        parachain_rpc.get_old_vault_replace_requests(no_execute_all.then_some(vault_id.clone())),
     )?;
 
     let open_redeems = redeem_requests
@@ -722,7 +723,7 @@ mod tests {
             async fn execute_redeem(&self, redeem_id: H256, merkle_proof: &[u8], raw_tx: &[u8]) -> Result<(), RuntimeError>;
             async fn cancel_redeem(&self, redeem_id: H256, reimburse: bool) -> Result<(), RuntimeError>;
             async fn get_redeem_request(&self, redeem_id: H256) -> Result<InterBtcRedeemRequest, RuntimeError>;
-            async fn get_vault_redeem_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcRedeemRequest)>, RuntimeError>;
+            async fn get_redeem_requests(&self, maybe_account_id: Option<AccountId>) -> Result<Vec<(H256, InterBtcRedeemRequest)>, RuntimeError>;
             async fn get_redeem_period(&self) -> Result<BlockNumber, RuntimeError>;
         }
 
@@ -734,7 +735,7 @@ mod tests {
             async fn execute_replace(&self, replace_id: H256, merkle_proof: &[u8], raw_tx: &[u8]) -> Result<(), RuntimeError>;
             async fn cancel_replace(&self, replace_id: H256) -> Result<(), RuntimeError>;
             async fn get_new_vault_replace_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
-            async fn get_old_vault_replace_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
+            async fn get_old_vault_replace_requests(&self, maybe_account_id: Option<AccountId>) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
             async fn get_replace_period(&self) -> Result<u32, RuntimeError>;
             async fn get_replace_request(&self, replace_id: H256) -> Result<InterBtcReplaceRequest, RuntimeError>;
             async fn get_replace_dust_amount(&self) -> Result<u128, RuntimeError>;

vault/src/metrics.rs

@@ -220,8 +220,8 @@ impl PerCurrencyMetrics {
         let vault_id = &vault.vault_id;
         // update fee surplus
         if let Ok((redeem_requests, replace_requests)) = try_join!(
-            parachain_rpc.get_vault_redeem_requests(vault_id.account_id.clone()),
-            parachain_rpc.get_old_vault_replace_requests(vault_id.account_id.clone())
+            parachain_rpc.get_redeem_requests(Some(vault_id.account_id.clone())),
+            parachain_rpc.get_old_vault_replace_requests(Some(vault_id.account_id.clone()))
         ) {
             let redeems = redeem_requests
                 .iter()
@@ -608,7 +608,7 @@ pub async fn poll_metrics<P: CollateralBalancesPallet + RedeemPallet + IssuePall
         publish_native_currency_balance(parachain_rpc).await?;
         publish_issue_count(parachain_rpc, vault_id_manager).await;
         if let Ok(redeems) = parachain_rpc
-            .get_vault_redeem_requests(parachain_rpc.get_account_id().clone())
+            .get_redeem_requests(Some(parachain_rpc.get_account_id().clone()))
             .await
         {
             publish_redeem_count(vault_id_manager, &redeems).await;
@@ -720,7 +720,7 @@ mod tests {
             async fn execute_redeem(&self, redeem_id: H256, merkle_proof: &[u8], raw_tx: &[u8]) -> Result<(), RuntimeError>;
             async fn cancel_redeem(&self, redeem_id: H256, reimburse: bool) -> Result<(), RuntimeError>;
             async fn get_redeem_request(&self, redeem_id: H256) -> Result<InterBtcRedeemRequest, RuntimeError>;
-            async fn get_vault_redeem_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcRedeemRequest)>, RuntimeError>;
+            async fn get_redeem_requests(&self, maybe_account_id: Option<AccountId>) -> Result<Vec<(H256, InterBtcRedeemRequest)>, RuntimeError>;
             async fn get_redeem_period(&self) -> Result<BlockNumber, RuntimeError>;
         }
 
@@ -759,7 +759,7 @@ mod tests {
             async fn execute_replace(&self, replace_id: H256, merkle_proof: &[u8], raw_tx: &[u8]) -> Result<(), RuntimeError>;
             async fn cancel_replace(&self, replace_id: H256) -> Result<(), RuntimeError>;
             async fn get_new_vault_replace_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
-            async fn get_old_vault_replace_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
+            async fn get_old_vault_replace_requests(&self, maybe_account_id: Option<AccountId>) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
             async fn get_replace_period(&self) -> Result<u32, RuntimeError>;
             async fn get_replace_request(&self, replace_id: H256) -> Result<InterBtcReplaceRequest, RuntimeError>;
             async fn get_replace_dust_amount(&self) -> Result<u128, RuntimeError>;

vault/src/replace.rs

@@ -331,7 +331,7 @@ mod tests {
         async fn execute_replace(&self, replace_id: H256, merkle_proof: &[u8], raw_tx: &[u8]) -> Result<(), RuntimeError>;
         async fn cancel_replace(&self, replace_id: H256) -> Result<(), RuntimeError>;
         async fn get_new_vault_replace_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
-        async fn get_old_vault_replace_requests(&self, account_id: AccountId) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
+        async fn get_old_vault_replace_requests(&self, maybe_account_id: Option<AccountId>) -> Result<Vec<(H256, InterBtcReplaceRequest)>, RuntimeError>;
         async fn get_replace_period(&self) -> Result<u32, RuntimeError>;
         async fn get_replace_request(&self, replace_id: H256) -> Result<InterBtcReplaceRequest, RuntimeError>;
         async fn get_replace_dust_amount(&self) -> Result<u128, RuntimeError>;

vault/src/system.rs

@@ -69,6 +69,11 @@ pub struct VaultServiceConfig {
     #[clap(long)]
     pub no_issue_execution: bool,
 
+    /// Don't try to execute **all** redeem and replace requests,
+    /// the Vault will still submit proofs for their own
+    #[clap(long)]
+    pub no_execute_all: bool,
+
     /// Don't run the RPC API.
     #[clap(long)]
     pub no_api: bool,
@@ -632,6 +637,7 @@ impl VaultService {
             num_confirmations,
             self.config.payment_margin_minutes,
             self.config.auto_rbf,
+            self.config.no_execute_all,
         );
 
         let shutdown_clone = self.shutdown.clone();