feat(multisig-prover) & feat(voting-verifier): add Stacks specific encoding, custom ITS support, as well as stacks-clarity custom package

Cargo.toml

@@ -73,6 +73,7 @@ service-registry = { version = "^1.1.0", path = "contracts/service-registry" }
 service-registry-api = { version = "^1.0.0", path = "packages/service-registry-api" }
 sha3 = { version = "0.10.8", default-features = false, features = [] }
 signature-verifier-api = { version = "^1.0.0", path = "packages/signature-verifier-api" }
+stacks-clarity = { version = "^1.0.0", path = "packages/stacks-clarity" }
 stellar = { version = "^1.0.0", path = "external-gateways/stellar" }
 stellar-xdr = { version = "21.2.0" }
 strum = { version = "0.25", default-features = false, features = ["derive"] }

contracts/gateway/src/contract.rs

@@ -90,6 +90,10 @@ pub fn execute(
         ExecuteMsg::VerifyMessages(msgs) => {
             execute::verify_messages(&verifier, msgs).change_context(Error::VerifyMessages)
         }
+        ExecuteMsg::VerifyMessageWithPayload { message, payload } => {
+            execute::verify_message_with_payload(&verifier, message, payload)
+                .change_context(Error::VerifyMessages)
+        }
         ExecuteMsg::RouteMessages(msgs) => {
             let router = Router::new(config.router);
 

contracts/gateway/src/contract/execute.rs

@@ -1,5 +1,5 @@
 use axelar_wasm_std::{FnExt, VerificationStatus};
-use cosmwasm_std::{CosmosMsg, Event, Response, Storage};
+use cosmwasm_std::{CosmosMsg, Event, HexBinary, Response, Storage};
 use error_stack::{Result, ResultExt};
 use itertools::Itertools;
 use router_api::client::Router;
@@ -19,6 +19,23 @@ pub fn verify_messages(
     })
 }
 
+pub fn verify_message_with_payload(
+    verifier: &voting_verifier::Client,
+    message: Message,
+    message_payload: HexBinary,
+) -> Result<Response, Error> {
+    let message_status = verifier
+        .messages_status(vec![message])
+        .change_context(Error::MessageStatus)?
+        .remove(0);
+
+    let (cosm_message, events) = verify_with_payload(verifier, message_status, message_payload);
+
+    Ok(Response::new()
+        .add_messages(cosm_message)
+        .add_events(events))
+}
+
 pub fn route_incoming_messages(
     verifier: &voting_verifier::Client,
     router: &Router,
@@ -102,6 +119,29 @@ fn verify(
         .then(|(msgs, events)| (verifier.verify_messages(msgs), events))
 }
 
+fn verify_with_payload(
+    verifier: &voting_verifier::Client,
+    message_status: MessageStatus,
+    message_payload: HexBinary,
+) -> (Option<CosmosMsg>, Vec<Event>) {
+    let status = message_status.status;
+    let message = message_status.message;
+
+    let messages = vec![message.clone()];
+
+    let verifiable_messages = filter_verifiable_messages(status, &messages);
+    let events = into_verify_events(status, messages);
+
+    if verifiable_messages.is_empty() {
+        return (None, events);
+    }
+
+    (
+        Some(verifier.verify_message_with_payload(message, message_payload)),
+        events,
+    )
+}
+
 fn route(
     router: &Router,
     msgs_by_status: Vec<(VerificationStatus, Vec<Message>)>,

contracts/gateway/tests/contract.rs

@@ -75,6 +75,58 @@ fn successful_verify() {
     goldie::assert_json!(responses);
 }
 
+#[test]
+fn successful_verify_with_payload() {
+    let (test_cases, handler) = test_cases_for_correct_verifier();
+
+    let mut responses = vec![];
+    for msgs in test_cases {
+        let mut deps = mock_dependencies();
+        update_query_handler(&mut deps.querier, handler.clone());
+
+        instantiate_contract(deps.as_mut(), "verifier", "router");
+
+        for msg in msgs {
+            // check verification is idempotent
+            let response = iter::repeat(
+                execute(
+                    deps.as_mut(),
+                    mock_env(),
+                    mock_info("sender", &[]),
+                    ExecuteMsg::VerifyMessageWithPayload {
+                        message: msg,
+                        payload: HexBinary::from_hex("00").unwrap(),
+                    },
+                )
+                .unwrap(),
+            )
+            .take(10)
+            .dedup()
+            .collect::<Vec<_>>();
+
+            assert_eq!(response.len(), 1);
+
+            responses.push(response[0].clone());
+        }
+    }
+
+    let golden_file = "tests/test_verify_with_payload.json";
+    #[cfg(feature = "generate_golden_files")]
+    {
+        let f = File::create(golden_file).unwrap();
+        serde_json::to_writer_pretty(f, &responses).unwrap();
+    }
+    #[cfg(not(feature = "generate_golden_files"))]
+    {
+        let f = File::open(golden_file).unwrap();
+        let expected_responses: Vec<Response> = serde_json::from_reader(f).unwrap();
+        assert_eq!(
+            serde_json::to_string_pretty(&responses).unwrap(),
+            serde_json::to_string_pretty(&expected_responses).unwrap()
+        );
+    }
+}
+
 #[test]
 fn successful_route_incoming() {
     let (test_cases, handler) = test_cases_for_correct_verifier();
@@ -175,6 +227,26 @@ fn verify_with_faulty_verifier_fails() {
     assert!(response.is_err());
 }
 
+#[test]
+fn verify_with_payload_with_faulty_verifier_fails() {
+    // if the mock querier is not overwritten, it will return an error
+    let mut deps = mock_dependencies();
+
+    instantiate_contract(deps.as_mut(), "verifier", "router");
+
+    let response = execute(
+        deps.as_mut(),
+        mock_env(),
+        mock_info("sender", &[]),
+        ExecuteMsg::VerifyMessageWithPayload {
+            message: generate_msgs("verifier in unreachable", 1).remove(0),
+            payload: HexBinary::from_hex("00").unwrap(),
+        },
+    );
+
+    assert!(response.is_err());
+}
+
 #[test]
 fn route_incoming_with_faulty_verifier_fails() {
     // if the mock querier is not overwritten, it will return an error