add setBondDepository to EVM governance requests

Signed-off-by: Uncle Stinky <uncle.stinky@ghostchain.io>

pallets/exodus/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-exodus"
-version = "0.1.1"
+version = "0.1.2"
 description = "Threshold signature generation with DKG included"
 license.workspace = true
 authors.workspace = true

pallets/exodus/src/types/exodus_request.rs

@@ -188,6 +188,7 @@ pub enum GovernanceAction {
     ForfeitReserves { router: EvmAddress, liquidity: u128, destroyer_mode: bool },
     RedeemReserves { router: EvmAddress, amount: u128 },
     Withdraw { token: EvmAddress, amount: u128 },
+    SetBondDepository { address: EvmAddress },
     AuditReserves,
 
     Close { id: u128 },
@@ -290,6 +291,13 @@ impl GovernanceAction {
                     [token, amount]
                 )
             },
+            Self::SetBondDepository { address } => {
+                abi_encode_evm_message!(
+                    message_buffer,
+                    "setBondDepository(address)",
+                    [address]
+                )
+            },
             Self::AuditReserves => {
                 abi_encode_evm_message!(message_buffer, "auditReserves()", [])
             },
@@ -681,7 +689,8 @@ mod tests {
                 GovernanceAction::SetWarmupPeriod { warmup_period } => {
                     let hash = keccak_256("setWarmupPeriod(uint256)".as_bytes());
                     assert_eq!(inner_payload[0..4], hash[0..4]);
-                    assert_eq!(inner_payload[inner_payload.len() - 1], warmup_period as u8);
+                    let decoded_warmup = u32::from_be_bytes(inner_payload[32..36].try_into().unwrap());
+                    assert_eq!(decoded_warmup, warmup_period as u32);
                 },
                 GovernanceAction::UpdateGatekeeperAddress { new_gatekeeper } => {
                     let hash = keccak_256("updateGatekeeperAddress(address)".as_bytes());
@@ -691,7 +700,8 @@ mod tests {
                 GovernanceAction::SetBounty { bounty } => {
                     let hash = keccak_256("setBounty(uint256)".as_bytes());
                     assert_eq!(inner_payload[0..4], hash[0..4]);
-                    assert_eq!(inner_payload[inner_payload.len() - 1], bounty as u8);
+                    let decoded_bounty = u32::from_be_bytes(inner_payload[32..36].try_into().unwrap());
+                    assert_eq!(decoded_bounty, bounty as u32);
                 },
                 GovernanceAction::AddPool { address } => {
                     let hash = keccak_256("addPool(address)".as_bytes());
@@ -701,13 +711,16 @@ mod tests {
                 GovernanceAction::RemovePool { index } => {
                     let hash = keccak_256("removePool(uint256)".as_bytes());
                     assert_eq!(inner_payload[0..4], hash[0..4]);
-                    assert_eq!(inner_payload[inner_payload.len() - 1], index as u8);
+                    let decoded_index = u32::from_be_bytes(inner_payload[32..36].try_into().unwrap());
+                    assert_eq!(decoded_index, index as u32);
                 },
                 GovernanceAction::SetAdjustment { rate, target, add } => {
                     let hash = keccak_256("setAdjustment(uint256,uint256,bool)".as_bytes());
                     assert_eq!(inner_payload[0..4], hash[0..4]);
-                    assert_eq!(inner_payload[35], rate as u8);
+                    let decoded_rate = u32::from_be_bytes(inner_payload[32..36].try_into().unwrap());
-                    assert_eq!(inner_payload[67], target as u8);
+                    assert_eq!(decoded_rate, rate as u32);
+                    let decoded_target = u32::from_be_bytes(inner_payload[64..68].try_into().unwrap());
+                    assert_eq!(decoded_target, target as u32);
                     assert_eq!(inner_payload[99], add as u8);
                 },
                 GovernanceAction::Enable { status, address, calculator } => {
@@ -727,7 +740,8 @@ mod tests {
                     let hash = keccak_256("forfeitReserves(address,uint256,bool)".as_bytes());
                     assert_eq!(inner_payload[0..4], hash[0..4]);
                     assert_eq!(&inner_payload[16..36], router.as_ref());
-                    assert_eq!(inner_payload[67], liquidity as u8);
+                    let decoded_liquidity = u32::from_be_bytes(inner_payload[64..68].try_into().unwrap());
+                    assert_eq!(decoded_liquidity, liquidity as u32);
                     assert_eq!(inner_payload[99], destroyer_mode as u8);
                 },
                 GovernanceAction::RedeemReserves { router, amount } => {
@@ -740,7 +754,13 @@ mod tests {
                     let hash = keccak_256("withdraw(address,uint256)".as_bytes());
                     assert_eq!(inner_payload[0..4], hash[0..4]);
                     assert_eq!(&inner_payload[16..36], token.as_ref());
-                    assert_eq!(inner_payload[67], amount as u8);
+                    let decoded_amount = u32::from_be_bytes(inner_payload[64..68].try_into().unwrap());
+                    assert_eq!(decoded_amount, amount as u32);
+                },
+                GovernanceAction::SetBondDepository { address } => {
+                    let hash = keccak_256("setBondDepository(address)".as_bytes());
+                    assert_eq!(inner_payload[0..4], hash[0..4]);
+                    assert_eq!(&inner_payload[16..36], address.as_ref());
                 },
                 GovernanceAction::AuditReserves => {
                     let hash = keccak_256("auditReserves()".as_bytes());
@@ -750,7 +770,8 @@ mod tests {
                 GovernanceAction::Close { id } => {
                     let hash = keccak_256("close(uint256)".as_bytes());
                     assert_eq!(inner_payload[0..4], hash[0..4]);
-                    assert_eq!(inner_payload[inner_payload.len() - 1], id as u8);
+                    let decoded_id = u32::from_be_bytes(inner_payload[32..36].try_into().unwrap());
+                    assert_eq!(decoded_id, id as u32);
                 },
                 GovernanceAction::Create { market, terms, token, intervals, booleans } => {
                     let hash = keccak_256("create(uint256[4],uint256[2],address,uint32[2],bool[2])".as_bytes());