feat: op consumer chain slashing (#92)

## Summary

This PR implements slashing for op stack consumer chain.

It updates the cw contract as follows:

- allow FPs to equivocate by submitting mutiple signatures for a block
- add new state to index voted block hashes and equivocation evidences
- add new handlers to slash finality providers and send notifying
message to Babylon, similar to the Cosmos consumer chain implementation

It also updates and add a new test case. We need to add additional
integration tests to check the e2e flow with Babylon node.

## Test plan
```bash
# build the contract
cargo build
cargo optimize

# test it
cargo test
cargo integration
```

Author: parketh

Cargo.toml

@@ -22,6 +22,7 @@ integration     = "./scripts/integration_test.sh"
 
 [workspace.dependencies]
 anybuf = { version = "0.5.0" }
+babylon-apis = { path = "./packages/apis" }
 babylon-proto = { path = "./packages/proto" }
 babylon-bitcoin = { path = "./packages/bitcoin" }
 babylon-btcstaking = { path = "./packages/btcstaking" }

contracts/op-finality-gadget/Cargo.toml

@@ -24,6 +24,9 @@ library = []
 [dependencies]
 babylon-apis = { path = "../../packages/apis" }
 babylon-merkle   = { path = "../../packages/merkle" }
+babylon-bindings = { path = "../../packages/bindings" }
+babylon-bitcoin  = { path = "../../packages/bitcoin" }
+babylon-proto    = { path = "../../packages/proto" }
 cosmwasm-schema  = { workspace = true }
 cosmwasm-std     = { workspace = true }
 cw-controllers   = { workspace = true }
@@ -33,8 +36,15 @@ eots             = { path = "../../packages/eots" }
 hex              = { workspace = true }
 k256             = { workspace = true } 
 thiserror        = { workspace = true }
+prost            = { workspace = true }
 anybuf           = { workspace = true }
 
 [dev-dependencies]
+babylon-bindings-test  = { path = "../../packages/bindings-test" }
+btc-staking            = { path = "../btc-staking", features = [ "library" ] }
 cosmwasm-vm       = { workspace = true }
 test-utils        = { path = "../../packages/test-utils" }
+anyhow           = { workspace = true }
+derivative       = { workspace = true }
+
+cw-multi-test          = { workspace = true }

contracts/op-finality-gadget/src/contract.rs

@@ -1,11 +1,14 @@
 use crate::error::ContractError;
 use crate::exec::admin::set_enabled;
-use crate::exec::finality::{handle_finality_signature, handle_public_randomness_commit};
+use crate::exec::finality::{
+    handle_finality_signature, handle_public_randomness_commit, handle_slashing,
+};
 use crate::msg::{ExecuteMsg, InstantiateMsg, QueryMsg};
 use crate::queries::{
     query_block_voters, query_config, query_first_pub_rand_commit, query_last_pub_rand_commit,
 };
 use crate::state::config::{Config, ADMIN, CONFIG, IS_ENABLED};
+use babylon_bindings::BabylonMsg;
 use cosmwasm_std::{
     to_json_binary, Deps, DepsMut, Env, MessageInfo, QueryResponse, Response, StdResult,
 };
@@ -16,7 +19,7 @@ pub fn instantiate(
     _env: Env,
     _info: MessageInfo,
     msg: InstantiateMsg,
-) -> StdResult<Response> {
+) -> StdResult<Response<BabylonMsg>> {
     let api = deps.api;
     ADMIN.set(deps.branch(), Some(api.addr_validate(&msg.admin)?))?;
     IS_ENABLED.save(deps.storage, &msg.is_enabled)?;
@@ -51,7 +54,7 @@ pub fn execute(
     env: Env,
     info: MessageInfo,
     msg: ExecuteMsg,
-) -> Result<Response, ContractError> {
+) -> Result<Response<BabylonMsg>, ContractError> {
     let api = deps.api;
 
     match msg {
@@ -86,6 +89,7 @@ pub fn execute(
             &block_hash,
             &signature,
         ),
+        ExecuteMsg::Slashing { evidence } => handle_slashing(&evidence),
         ExecuteMsg::SetEnabled { enabled } => set_enabled(deps, info, enabled),
         ExecuteMsg::UpdateAdmin { admin } => ADMIN
             .execute_update_admin(deps, info, Some(api.addr_validate(&admin)?))
@@ -145,7 +149,6 @@ pub(crate) mod tests {
         let mut deps = mock_dependencies();
         let init_admin = deps.api.addr_make(INIT_ADMIN);
         let new_admin = deps.api.addr_make(NEW_ADMIN);
-
         // Create an InstantiateMsg with admin set to Some(INIT_ADMIN.into())
         let instantiate_msg = InstantiateMsg {
             admin: init_admin.to_string(), // Admin provided

contracts/op-finality-gadget/src/error.rs

@@ -18,6 +18,16 @@ pub enum ContractError {
     HexError(#[from] FromHexError),
     #[error("The inclusion proof for height {0} does not correspond to the given height ({1})")]
     InvalidFinalitySigHeight(u64, u64),
+    #[error("Contract already has an open IBC channel")]
+    IbcChannelAlreadyOpen {},
+    #[error("The contract only supports ordered channels")]
+    IbcUnorderedChannel {},
+    #[error("Counterparty version must be `{version}`")]
+    IbcInvalidCounterPartyVersion { version: String },
+    #[error("IBC method is not supported")]
+    IbcUnsupportedMethod {},
+    #[error("IBC send timed out: dest: channel {0}, port {1}")]
+    IbcTimeout(String, String),
     #[error("The total amount of public randomnesses in the proof ({0}) does not match the amount of public committed randomness ({1})")]
     InvalidFinalitySigAmount(u64, u64),
     #[error("The start height ({0}) has overlap with the height of the highest public randomness committed ({1})")]
@@ -30,6 +40,8 @@ pub enum ContractError {
     MissingPubRandCommit(String, u64),
     #[error("{0}")]
     SecP256K1Error(String), // TODO: inherit errors from k256
+    #[error("Failed to extract secret key: {0}")]
+    SecretKeyExtractionError(String),
     #[error("{0}")]
     StdError(#[from] StdError),
     #[error("Failed to query block voters for block {0} with hash {1}. {2}")]

contracts/op-finality-gadget/src/exec/admin.rs

@@ -1,3 +1,4 @@
+use babylon_bindings::BabylonMsg;
 use cosmwasm_std::{DepsMut, MessageInfo, Response};
 
 use crate::{
@@ -14,7 +15,7 @@ pub fn set_enabled(
     deps: DepsMut,
     info: MessageInfo,
     enabled: bool,
-) -> Result<Response, ContractError> {
+) -> Result<Response<BabylonMsg>, ContractError> {
     // Check caller is admin
     check_admin(&deps, info)?;
     // Check if the finality gadget is already in the desired state