Add upgrade e2e test and fix PackageUpgradedEvent parsing

Adds an end-to-end test that exercises the full governance-gated upgrade
lifecycle and verifies cascading effects across the stack.

The test found a real bug: PackageUpgradedEvent was missing from
HashiEvent::try_parse(), so validators never learned about package
upgrades via the event stream. Fixed by adding the missing match arm.

Test flow:
- Deposit before upgrade, verify balance survives (state continuity)
- Upgrade via propose/vote/execute+publish+finalize
- Verify all node watchers pick up the new package version
- Deposit after upgrade through full validator confirmation path
- Call v2-only canary module (new code reachable)
- Disable v1, verify entry points rejected

Author: Bridgerz

crates/e2e-tests/src/e2e_flow.rs

@@ -10,7 +10,6 @@ mod tests {
 
     use futures::StreamExt;
     use hashi::sui_tx_executor::SuiTxExecutor;
-    use hashi_types::move_types::DepositConfirmedEvent;
     use hashi_types::move_types::WithdrawalConfirmedEvent;
     use hashi_types::move_types::WithdrawalPickedForProcessingEvent;
     use std::sync::Arc;
@@ -20,27 +19,20 @@ mod tests {
     use sui_rpc::field::FieldMask;
     use sui_rpc::field::FieldMaskUtil;
     use sui_rpc::proto::sui::rpc::v2::Checkpoint;
-    use sui_rpc::proto::sui::rpc::v2::GetBalanceRequest;
     use sui_rpc::proto::sui::rpc::v2::SubscribeCheckpointsRequest;
     use sui_sdk_types::Address;
-    use sui_sdk_types::StructTag;
     use sui_sdk_types::bcs::FromBcs;
     use tracing::debug;
     use tracing::info;
 
     use crate::TestNetworks;
     use crate::TestNetworksBuilder;
 
-    fn init_test_logging() {
-        tracing_subscriber::fmt()
-            .with_test_writer()
-            .with_env_filter(
-                tracing_subscriber::EnvFilter::from_default_env()
-                    .add_directive(tracing::Level::INFO.into()),
-            )
-            .try_init()
-            .ok();
-    }
+    use crate::test_helpers::create_deposit_and_wait;
+    use crate::test_helpers::get_hbtc_balance;
+    use crate::test_helpers::init_test_logging;
+    use crate::test_helpers::lookup_vout;
+    use crate::test_helpers::txid_to_address;
 
     async fn setup_test_networks() -> Result<TestNetworks> {
         info!("Setting up test networks...");
@@ -60,84 +52,6 @@ mod tests {
         Ok(networks)
     }
 
-    fn txid_to_address(txid: &Txid) -> Address {
-        hashi_types::bitcoin_txid::BitcoinTxid::from(*txid).into()
-    }
-
-    async fn wait_for_deposit_confirmation(
-        sui_client: &mut sui_rpc::Client,
-        request_id: Address,
-        timeout: Duration,
-    ) -> Result<()> {
-        info!(
-            "Waiting for deposit confirmation for request_id: {}",
-            request_id
-        );
-
-        let start = std::time::Instant::now();
-        let subscription_read_mask = FieldMask::from_paths([Checkpoint::path_builder()
-            .transactions()
-            .events()
-            .events()
-            .contents()
-            .finish()]);
-        let mut subscription = sui_client
-            .subscription_client()
-            .subscribe_checkpoints(
-                SubscribeCheckpointsRequest::default().with_read_mask(subscription_read_mask),
-            )
-            .await?
-            .into_inner();
-
-        while let Some(item) = subscription.next().await {
-            if start.elapsed() > timeout {
-                return Err(anyhow!(
-                    "Timeout waiting for deposit confirmation after {:?}",
-                    timeout
-                ));
-            }
-
-            let checkpoint = match item {
-                Ok(checkpoint) => checkpoint,
-                Err(e) => {
-                    debug!("Error in checkpoint stream: {}", e);
-                    continue;
-                }
-            };
-
-            debug!(
-                "Received checkpoint {}, checking for DepositConfirmedEvent...",
-                checkpoint.cursor()
-            );
-
-            for txn in checkpoint.checkpoint().transactions() {
-                for event in txn.events().events() {
-                    let event_type = event.contents().name();
-
-                    if event_type.contains("DepositConfirmedEvent") {
-                        match DepositConfirmedEvent::from_bcs(event.contents().value()) {
-                            Ok(event_data) => {
-                                if event_data.request_id == request_id {
-                                    info!(
-                                        "Deposit confirmed! Found DepositConfirmedEvent for request_id: {}",
-                                        request_id
-                                    );
-                                    return Ok(());
-                                }
-                            }
-                            Err(e) => {
-                                debug!("Failed to parse DepositConfirmedEvent: {}", e);
-                            }
-                        }
-                    }
-                }
-            }
-            tokio::time::sleep(Duration::from_millis(100)).await;
-        }
-
-        Err(anyhow!("Checkpoint subscription ended unexpectedly"))
-    }
-
     async fn wait_for_withdrawal_confirmation(
         sui_client: &mut sui_rpc::Client,
         timeout: Duration,
@@ -207,105 +121,6 @@ mod tests {
         Err(anyhow!("Checkpoint subscription ended unexpectedly"))
     }
 
-    async fn get_hbtc_balance(
-        sui_client: &mut sui_rpc::Client,
-        package_id: Address,
-        owner: Address,
-    ) -> Result<u64> {
-        let btc_type = format!("{}::btc::BTC", package_id);
-        let btc_struct_tag: StructTag = btc_type.parse()?;
-        let request = GetBalanceRequest::default()
-            .with_owner(owner.to_string())
-            .with_coin_type(btc_struct_tag.to_string());
-
-        let response = sui_client
-            .state_client()
-            .get_balance(request)
-            .await?
-            .into_inner();
-
-        let balance = response.balance().balance_opt().unwrap_or(0);
-        debug!("hBTC balance for {}: {} sats", owner, balance);
-        Ok(balance)
-    }
-
-    fn lookup_vout(
-        networks: &TestNetworks,
-        txid: Txid,
-        address: bitcoin::Address,
-        amount: u64,
-    ) -> Result<usize> {
-        let tx = networks
-            .bitcoin_node
-            .rpc_client()
-            .get_raw_transaction(txid)
-            .and_then(|r| r.transaction().map_err(Into::into))?;
-        let vout = tx
-            .output
-            .iter()
-            .position(|output| {
-                output.value == Amount::from_sat(amount)
-                    && output.script_pubkey == address.script_pubkey()
-            })
-            .ok_or_else(|| {
-                anyhow!(
-                    "Could not find output with amount {} and deposit address",
-                    amount
-                )
-            })?;
-        debug!("Found deposit in tx output {}", vout);
-        Ok(vout)
-    }
-
-    async fn create_deposit_and_wait(
-        networks: &mut TestNetworks,
-        amount_sats: u64,
-    ) -> Result<Address> {
-        let user_key = networks.sui_network.user_keys.first().unwrap();
-        let hbtc_recipient = user_key.public_key().derive_address();
-        let hashi = networks.hashi_network.nodes()[0].hashi().clone();
-        // Use the on-chain MPC key rather than the local key-ready channel.
-        // The on-chain key is set during end_reconfig and is guaranteed
-        // available once HashiNetworkBuilder::build() returns.
-        let deposit_address =
-            hashi.get_deposit_address(&hashi.get_onchain_mpc_pubkey()?, Some(&hbtc_recipient))?;
-
-        info!("Sending Bitcoin to deposit address...");
-        let txid = networks
-            .bitcoin_node
-            .send_to_address(&deposit_address, Amount::from_sat(amount_sats))?;
-        info!("Transaction sent: {}", txid);
-
-        info!("Mining blocks for confirmation...");
-        let blocks_to_mine = 10;
-        networks.bitcoin_node.generate_blocks(blocks_to_mine)?;
-        info!("{blocks_to_mine} blocks mined");
-
-        info!("Creating deposit request on Sui...");
-        let vout = lookup_vout(networks, txid, deposit_address, amount_sats)?;
-        let mut executor = SuiTxExecutor::from_config(&hashi.config, hashi.onchain_state())?
-            .with_signer(user_key.clone());
-        let request_id = executor
-            .execute_create_deposit_request(
-                txid_to_address(&txid),
-                vout as u32,
-                amount_sats,
-                Some(hbtc_recipient),
-            )
-            .await?;
-        info!("Deposit request created: {}", request_id);
-
-        wait_for_deposit_confirmation(
-            &mut networks.sui_network.client,
-            request_id,
-            Duration::from_secs(300),
-        )
-        .await?;
-        info!("Deposit confirmed on Sui");
-
-        Ok(hbtc_recipient)
-    }
-
     /// Mines one block per second on Bitcoin regtest until stopped.
     /// Stops automatically when dropped.
     struct BackgroundMiner {

crates/e2e-tests/src/lib.rs

@@ -23,6 +23,10 @@ pub mod e2e_flow;
 pub mod hashi_network;
 mod publish;
 pub mod sui_network;
+#[cfg(test)]
+mod test_helpers;
+pub mod upgrade_flow;
+pub mod upgrade_tests;
 
 pub use bitcoin_node::BitcoinNodeBuilder;
 pub use bitcoin_node::BitcoinNodeHandle;
@@ -69,6 +73,10 @@ impl TestNetworks {
         &self.bitcoin_node
     }
 
+    pub fn dir(&self) -> &Path {
+        self.dir.path()
+    }
+
     pub async fn restart(&mut self) -> Result<()> {
         self.hashi_network.restart().await
     }