Add encoding handlers for ManagerWithMerkleVerification ABI

src/cellars.rs

@@ -12,6 +12,7 @@ pub type CachePriceRouterArgs = (bool, u32, Option<String>);
 
 pub(crate) mod aave_v2_stablecoin;
 pub(crate) mod adaptors;
+pub(crate) mod boring_vault_manager_with_merkle_verification;
 pub(crate) mod cellar_v1;
 pub(crate) mod cellar_v2;
 pub(crate) mod cellar_v2_2;

src/cellars/boring_vault_manager_with_merkle_verification.rs

@@ -0,0 +1,56 @@
+use ethers::{abi::AbiEncode, contract::EthCall};
+use steward_proto::proto::boring_vault_manager_with_merkle_verification::Function;
+
+use crate::{
+    abi::adaptors::boring_vault::manager_with_merkle_verification::{
+        ManagerWithMerkleVerificationCalls, PauseCall, SetManageRootCall, UnpauseCall,
+    },
+    error::{Error, ErrorKind},
+    utils::sp_call_parse_address,
+};
+
+use super::log_cellar_call;
+
+const CELLAR_NAME: &str = "ManagerWithMerkleVerification";
+
+pub fn get_encoded_call(function: Function, cellar_id: String) -> Result<Vec<u8>, Error> {
+    get_call(function, cellar_id).map(|call| call.encode())
+}
+
+pub fn get_call(
+    function: Function,
+    cellar_id: String,
+) -> Result<ManagerWithMerkleVerificationCalls, Error> {
+    match function {
+        Function::SetManageRoot(params) => {
+            log_cellar_call(CELLAR_NAME, &SetManageRootCall::function_name(), &cellar_id);
+
+            let strategist = sp_call_parse_address(params.strategist)?;
+            let manage_root = hex::decode(params.manage_root)
+                .map_err(|e| {
+                    ErrorKind::SPCallError.context(format!("failed to decode manage_root: {e}"))
+                })?
+                .try_into()
+                .map_err(|_| {
+                    ErrorKind::SPCallError.context("manage_root must be 32 bytes".to_string())
+                })?;
+
+            let call = SetManageRootCall {
+                strategist,
+                manage_root,
+            };
+
+            Ok(ManagerWithMerkleVerificationCalls::SetManageRoot(call))
+        }
+        Function::Pause(_) => {
+            log_cellar_call(CELLAR_NAME, &PauseCall::function_name(), &cellar_id);
+            let call = PauseCall {};
+            Ok(ManagerWithMerkleVerificationCalls::Pause(call))
+        }
+        Function::Unpause(_) => {
+            log_cellar_call(CELLAR_NAME, &UnpauseCall::function_name(), &cellar_id);
+            let call = UnpauseCall {};
+            Ok(ManagerWithMerkleVerificationCalls::Unpause(call))
+        }
+    }
+}

src/cork.rs

@@ -9,7 +9,10 @@ use tonic::{self, async_trait, Code, Request, Response, Status};
 use crate::cellars::to_checksum_address;
 use crate::server::handle_authorization;
 use crate::{
-    cellars::{self, aave_v2_stablecoin, cellar_v1, cellar_v2, cellar_v2_2, cellar_v2_5},
+    cellars::{
+        self, aave_v2_stablecoin, boring_vault_manager_with_merkle_verification, cellar_v1,
+        cellar_v2, cellar_v2_2, cellar_v2_5,
+    },
     error::{
         Error,
         ErrorKind::{self, *},
@@ -147,6 +150,16 @@ pub fn get_encoded_call(request: ScheduleRequest) -> Result<Vec<u8>, Error> {
 
             cellar_v2_5::get_encoded_call(call.call_type.unwrap(), request.cellar_id)
         }
+        BoringVaultManagerWithMerkleVerification(call) => {
+            if call.function.is_none() {
+                return Err(ErrorKind::Http.context("empty function data").into());
+            }
+
+            boring_vault_manager_with_merkle_verification::get_encoded_call(
+                call.function.unwrap(),
+                request.cellar_id,
+            )
+        }
     }
 }