recover KMS address test

Author: Rhaki

rust/main/Cargo.lock

@@ -1,23 +1,30 @@
 use {
-    crate::utils::{try_for, DangoBuilder},
+    crate::utils::{try_for, DangoBuilder, SingleSignerExt},
     dango_client::{Secp256k1, Secret, SingleSigner},
     dango_genesis::{GatewayOption, GenesisOption, HyperlaneOption},
-    dango_hyperlane_types::isms::multisig::ValidatorSet,
+    dango_hyperlane_types::{
+        domain_hash, eip191_hash,
+        isms::{multisig::ValidatorSet, HYPERLANE_DOMAIN_KEY},
+        mailbox, multisig_hash, Addr32,
+    },
     dango_testing::{constants::user5, Preset},
     dango_types::{
         config::AppConfig,
         constants::dango,
         gateway::{self, Origin, Remote},
     },
     grug::{
-        BroadcastClientExt, Coins, GasOption, QueryClientExt, ResultExt, SearchTxClient,
-        __private::hex_literal::hex, addr, btree_map, btree_set,
+        addr, btree_map, btree_set, Addr, Api, BroadcastClientExt, CheckedContractEvent, Coins,
+        EventName, FlatCommitmentStatus, GasOption, Hash256, Inner, JsonDeExt, MockApi,
+        QueryClientExt, ResultExt, SearchEvent, SearchTxClient, __private::hex_literal::hex,
     },
     grug_indexer_client::HttpClient,
+    manual_relay::get_checkpoint_from_s3,
     std::time::Duration,
     tracing::Level,
 };
 
+pub mod manual_relay;
 pub mod utils;
 
 const PORT: u16 = 8080;
@@ -27,6 +34,8 @@ const PORT: u16 = 8080;
 async fn run_dango() -> anyhow::Result<()> {
     // --- SETTINGS ---
 
+    let local_domain = 88888867;
+
     let routes = [(
         Origin::Local(dango::DENOM.clone()),
         Remote::Warp {
@@ -61,7 +70,7 @@ async fn run_dango() -> anyhow::Result<()> {
     let mut ism_valset = HyperlaneOption::preset_test().ism_validator_sets;
     ism_valset.extend(ism_validator_sets);
 
-    DangoBuilder::new("localdango", 88888888)
+    DangoBuilder::new("localdango", local_domain)
         .with_block_creation(grug::BlockCreation::Timed)
         .with_block_time(grug::Duration::from_seconds(1))
         .with_port(PORT)
@@ -71,6 +80,7 @@ async fn run_dango() -> anyhow::Result<()> {
                 ..Preset::preset_test()
             },
             hyperlane: HyperlaneOption {
+                local_domain,
                 ism_validator_sets: ism_valset,
                 ..Preset::preset_test()
             },
@@ -87,6 +97,10 @@ async fn run_dango() -> anyhow::Result<()> {
 async fn transfer_remote() -> anyhow::Result<()> {
     // --- SETTINGS ---
 
+    let run_recover_address = true;
+    let location = "s3://hyperlane-testnet-val1/eu-north-1";
+    let recover_address_should_be = addr!("6603760598E4aAc3E9D47569cc3A7024cDa7003a");
+
     let url = format!("http://localhost:{}", PORT);
     let denom = dango::DENOM.clone();
     let amount = 55;
@@ -96,18 +110,20 @@ async fn transfer_remote() -> anyhow::Result<()> {
     };
     let recipient = addr!("f63130398dE6467a539020ac2B6d876B7A850C5F");
 
+    // --- SETTINGS ---
+
     let dango_client = HttpClient::new(url)?;
 
     let cfg: AppConfig = dango_client.query_app_config(None).await?;
     let chain_id = dango_client.query_status(None).await?.chain_id;
 
-    let mut user5 = SingleSigner::new(
-        addr!("a20a0e1a71b82d50fc046bc6e3178ad0154fd184"),
+    let mut user5 = SingleSigner::new_first_account(
+        &dango_client,
         Secp256k1::from_bytes(user5::PRIVATE_KEY)?,
+        Some(&cfg),
     )
-    .with_query_nonce(&dango_client)
     .await?
-    .with_query_user_index(&dango_client)
+    .with_query_nonce(&dango_client)
     .await?;
 
     let res = dango_client
@@ -129,11 +145,82 @@ async fn transfer_remote() -> anyhow::Result<()> {
         Duration::from_millis(100),
         || async { dango_client.search_tx(res.tx_hash).await },
     )
-    .await?;
+    .await?
+    .outcome
+    .should_succeed();
+
+    if !run_recover_address {
+        return Ok(());
+    }
+
+    let dispatch = outcome
+        .events
+        .clone()
+        .search_event::<CheckedContractEvent>()
+        .with_commitment_status(FlatCommitmentStatus::Committed)
+        .with_predicate(move |e| {
+            &e.contract == &cfg.addresses.hyperlane.mailbox && e.ty == mailbox::Dispatch::EVENT_NAME
+        })
+        .take()
+        .one()
+        .event
+        .data
+        .deserialize_json::<mailbox::Dispatch>()?
+        .0;
+
+    let insertion = outcome
+        .events
+        .search_event::<CheckedContractEvent>()
+        .with_commitment_status(FlatCommitmentStatus::Committed)
+        .with_predicate(move |e| {
+            &e.contract == &cfg.addresses.hyperlane.mailbox
+                && e.ty == mailbox::InsertedIntoTree::EVENT_NAME
+        })
+        .take()
+        .one()
+        .event
+        .data
+        .deserialize_json::<mailbox::InsertedIntoTree>()?;
 
-    outcome.outcome.should_succeed();
+    let checkpoint = try_for(
+        Duration::from_secs(10),
+        Duration::from_millis(100),
+        || async { get_checkpoint_from_s3(location, &insertion.index.to_string()).await },
+    )
+    .await?;
 
-    println!("found at height: {}", outcome.height);
+    let api = MockApi;
+
+    let raw_message = dispatch.encode();
+    let message_id = Hash256::from_inner(api.keccak256(&raw_message));
+
+    assert_eq!(message_id.inner(), checkpoint.message_id.inner());
+
+    let merkle_tree_hook_address =
+        Addr32::from_inner(checkpoint.merkle_tree_hook_address.into_inner());
+    let merkle_root = Hash256::from_inner(checkpoint.root.into_inner());
+
+    let multisig_hash = eip191_hash(multisig_hash(
+        domain_hash(
+            dispatch.origin_domain,
+            merkle_tree_hook_address,
+            HYPERLANE_DOMAIN_KEY,
+        ),
+        merkle_root,
+        checkpoint.index,
+        Hash256::from_inner(checkpoint.message_id.into_inner()),
+    ));
+
+    let pk = api.secp256k1_pubkey_recover(
+        &multisig_hash,
+        &checkpoint.serialized_signature[..64],
+        checkpoint.serialized_signature[64] - 27, // Ethereum uses recovery IDs 27, 28 instead of 0, 1.
+        false, // We need the _uncompressed_ public key for deriving address!
+    )?;
+    let pk_hash = api.keccak256(&pk[1..]);
+    let address: [u8; 20] = pk_hash[12..].try_into().unwrap();
+
+    assert_eq!(Addr::from_inner(address), recover_address_should_be);
 
     Ok(())
 }

rust/main/chains/hyperlane-dango/tests/localdango.rs

@@ -30,13 +30,13 @@ use {
 type AddrEncoded<const N: usize> = EncodedBytes<[u8; N], AddrEncoder>;
 
 #[derive(Debug, Serialize, Deserialize)]
-struct CheckpointResponse {
-    merkle_tree_hook_address: AddrEncoded<32>,
-    mailbox_domain: u32,
-    root: AddrEncoded<32>,
-    index: u32,
-    message_id: AddrEncoded<32>,
-    serialized_signature: AddrEncoded<65>,
+pub struct CheckpointResponse {
+    pub merkle_tree_hook_address: AddrEncoded<32>,
+    pub mailbox_domain: u32,
+    pub root: AddrEncoded<32>,
+    pub index: u32,
+    pub message_id: AddrEncoded<32>,
+    pub serialized_signature: AddrEncoded<65>,
 }
 
 abigen!(
@@ -237,7 +237,7 @@ async fn get_validator_locations<I: IntoIterator<Item = H160>>(
         .collect::<Result<Vec<String>, anyhow::Error>>()
 }
 
-async fn get_checkpoint_from_s3(s3: &str, index_msg: &str) -> anyhow::Result<CheckpointResponse> {
+pub async fn get_checkpoint_from_s3(s3: &str, index_msg: &str) -> anyhow::Result<CheckpointResponse> {
     let without_scheme = s3
         .strip_prefix("s3://")
         .ok_or(anyhow::anyhow!("Invalid S3 URL"))?;

rust/main/chains/hyperlane-dango/tests/manual_relay.rs

@@ -1,12 +1,12 @@
 use {
     crate::utils::{
         build_agents, workspace, Agent, CheckpointSyncer, DangoSettings, EvmSettings, Location,
-        LogLevel, Relayer, Validator,
+        LogLevel, Relayer, SingleSignerExt, Validator, ValidatorSigner,
     },
-    dango_hyperlane_testing::constants::MOCK_HYPERLANE_VALIDATOR_SIGNING_KEYS,
+    dango_client::{Secp256k1, Secret, SingleSigner},
     dango_testing::constants::{user4, user6},
     dango_types::config::AppConfig,
-    grug::{addr, HexByteArray, QueryClientExt},
+    grug::{HexByteArray, QueryClientExt},
     grug_indexer_client::HttpClient,
     hyperlane_base::settings::SignerConf,
     hyperlane_core::H256,
@@ -35,6 +35,14 @@ async fn run_relayer() -> anyhow::Result<()> {
     let dango_client = HttpClient::new(HTTPD_URL)?;
     let app_cfg: AppConfig = dango_client.query_app_config(None).await?;
 
+    let dango_chain_signer_address = SingleSigner::new_first_account(
+        &dango_client,
+        Secp256k1::from_bytes(user4::PRIVATE_KEY)?,
+        Some(&app_cfg),
+    )
+    .await?
+    .address;
+
     Agent::new(Relayer::default().with_allow_local_checkpoint_syncer(true))
         .with_chain(
             EvmSettings::new("sepolia")
@@ -45,7 +53,7 @@ async fn run_relayer() -> anyhow::Result<()> {
             DangoSettings::new("dangolocal2")
                 .with_chain_signer(SignerConf::Dango {
                     key: HexByteArray::from_inner(user4::PRIVATE_KEY),
-                    address: addr!("5a7213b5a8f12e826e88d67c083be371a442689c"),
+                    address: dango_chain_signer_address,
                 })
                 .with_index(1, Some(20))
                 .with_chain_settings(|dango| {
@@ -67,31 +75,41 @@ async fn run_relayer() -> anyhow::Result<()> {
 async fn run_dango_validator() -> anyhow::Result<()> {
     load_env();
 
+    let validator_chain = "localdango1";
+
     build_agents();
 
     let dango_client = HttpClient::new(HTTPD_URL)?;
     let chain_id = dango_client.query_status(None).await?.chain_id;
-    let app_cfg = dango_client.query_app_config(None).await?;
+    let app_cfg: AppConfig = dango_client.query_app_config(None).await?;
     let path = workspace().join("val-1");
 
+    let dango_chain_signer_address = SingleSigner::new_first_account(
+        &dango_client,
+        Secp256k1::from_bytes(user6::PRIVATE_KEY)?,
+        Some(&app_cfg),
+    )
+    .await?
+    .address;
+
     Agent::new(
         Validator::default()
-            .with_origin_chain_name("dangolocal2")
+            .with_origin_chain_name(validator_chain)
             .with_checkpoint_syncer(CheckpointSyncer::s3(
-                "hyperlane-test",
+                "hyperlane-testnet-val1",
                 "eu-north-1",
                 None::<String>,
             ))
-            // .with_checkpoint_syncer(CheckpointSyncer::LocalStorage(Location::Temp))
-            .with_validator_signer(utils::ValidatorSigner::Hex(H256::from(
-                MOCK_HYPERLANE_VALIDATOR_SIGNING_KEYS[0],
-            ))),
+            .with_validator_signer(ValidatorSigner::kms(
+                "alias/hyperlane-testnet-val1-singer-key",
+                "eu-north-1",
+            )),
     )
     .with_chain(
-        DangoSettings::new("dangolocal2")
+        DangoSettings::new(validator_chain)
             .with_chain_signer(SignerConf::Dango {
                 key: HexByteArray::from_inner(user6::PRIVATE_KEY),
-                address: addr!("365a389d8571b681d087ee8f7eecf1ff710f59c8"),
+                address: dango_chain_signer_address,
             })
             .with_index(1, Some(20))
             .with_chain_settings(|dango| {

rust/main/chains/hyperlane-dango/tests/run_agents.rs

@@ -115,6 +115,16 @@ impl Args for OriginChainName {
 
 pub enum ValidatorSigner {
     Hex(H256),
+    KMS { alias: String, region: String },
+}
+
+impl ValidatorSigner {
+    pub fn kms(alias: impl Into<String>, region: impl Into<String>) -> Self {
+        Self::KMS {
+            alias: alias.into(),
+            region: region.into(),
+        }
+    }
 }
 
 impl Args for ValidatorSigner {
@@ -124,6 +134,11 @@ impl Args for ValidatorSigner {
                 "validator.type".to_string() => "hexKey".to_string(),
                 "validator.key".to_string() => format!("{:?}", key),
             },
+            ValidatorSigner::KMS { alias, region } => btree_map! {
+                "validator.type".to_string() => "aws".to_string(),
+                "validator.id".to_string() => alias,
+                "validator.region".to_string() => region,
+            },
         }
     }
 }