Merge branch 'main' into feat/aleo-sdk

Author: troykessler

.changeset/pink-beds-act.md

@@ -0,0 +1,9 @@
+---
+"@hyperlane-xyz/cosmos-sdk": minor
+"@hyperlane-xyz/radix-sdk": minor
+"@hyperlane-xyz/utils": minor
+"@hyperlane-xyz/cli": minor
+"@hyperlane-xyz/sdk": minor
+---
+
+add new methods for altvm interface

.registryrc

@@ -1 +1 @@
-93a21a90c1fcff8bf6e449c1fc4db9290c43f62e
+eece6cd6a63a62f0afe7ffd9d9af73909db46643

rust/main/agents/relayer/src/msg/message_processor.rs

@@ -399,7 +399,7 @@ async fn prepare_lander_task(
             continue;
         };
 
-        let batch_to_process = confirm_already_submitted_operations(
+        let batch_to_process = filter_operations_for_preparation(
             entrypoint.clone() as Arc<dyn Entrypoint + Send + Sync>,
             &confirm_queue,
             db.clone(),
@@ -419,49 +419,93 @@ async fn prepare_lander_task(
     }
 }
 
-/// This function checks the status of the payloads associated with the operations in the batch.
-/// If the payload is not dropped, the operation is pushed to the confirmation queue.
-/// If the payload is dropped, does not exist or there is issue in retrieving payload or its status, the operation will go through prepare logic.
-async fn confirm_already_submitted_operations(
+/// Disposition for how to handle an operation during submission check
+enum OperationDisposition {
+    /// Operation requires manual intervention - should be prepared
+    Manual,
+    /// Operation has not been submitted yet - should be prepared
+    Prepare,
+    /// Operation has already been submitted - should go to confirmation queue
+    Confirm,
+}
+
+/// Filters operations from a batch to determine which should proceed to preparation.
+///
+/// Operations already submitted (and not dropped) are pushed to the confirmation queue.
+/// Operations that need preparation are returned for further processing.
+///
+/// # Returns
+/// A vector of operations that should proceed to the preparation phase.
+async fn filter_operations_for_preparation(
     entrypoint: Arc<dyn Entrypoint + Send + Sync>,
     confirm_queue: &OpQueue,
     db: Arc<dyn HyperlaneDb>,
     batch: Vec<QueueOperation>,
 ) -> Vec<QueueOperation> {
     use ConfirmReason::AlreadySubmitted;
-    use PendingOperationStatus::{Confirm, Retry};
+    use PendingOperationStatus::Confirm;
+
+    // Phase 1: Determine disposition for each operation
+    let mut operations_with_disposition = Vec::with_capacity(batch.len());
+    for op in batch {
+        let disposition =
+            determine_operation_disposition(entrypoint.clone(), db.clone(), &op).await;
+        operations_with_disposition.push((op, disposition));
+    }
 
-    let mut ops_to_prepare = vec![];
-    for op in batch.into_iter() {
-        if let Retry(ReprepareReason::Manual) = op.status() {
-            ops_to_prepare.push(op);
-            continue;
-        }
-        if !has_operation_been_submitted(entrypoint.clone(), db.clone(), &op).await {
-            ops_to_prepare.push(op);
-            continue;
+    // Phase 2: Process operations based on their disposition
+    let mut ops_to_prepare = Vec::new();
+    for (op, disposition) in operations_with_disposition {
+        match disposition {
+            OperationDisposition::Manual | OperationDisposition::Prepare => {
+                ops_to_prepare.push(op);
+            }
+            OperationDisposition::Confirm => {
+                let status = Some(Confirm(AlreadySubmitted));
+                confirm_queue.push(op, status).await;
+            }
         }
-        let status = Some(Confirm(AlreadySubmitted));
-        confirm_queue.push(op, status).await;
     }
+
     ops_to_prepare
 }
 
-async fn has_operation_been_submitted(
+async fn determine_operation_disposition(
     entrypoint: Arc<dyn Entrypoint + Send + Sync>,
     db: Arc<dyn HyperlaneDb>,
     op: &QueueOperation,
-) -> bool {
+) -> OperationDisposition {
+    use PendingOperationStatus::Retry;
+
+    // Check if operation requires manual intervention
+    if let Retry(ReprepareReason::Manual) = op.status() {
+        return OperationDisposition::Manual;
+    }
+
+    // Determine disposition based on payload status
+    operation_disposition_by_payload_status(entrypoint, db, op).await
+}
+
+/// Determines the disposition of an operation based on its payload submission status.
+/// Returns Confirm if the payload has been submitted and is not dropped, Prepare otherwise.
+/// If payload status cannot be determined, operation will be prepared.
+async fn operation_disposition_by_payload_status(
+    entrypoint: Arc<dyn Entrypoint + Send + Sync>,
+    db: Arc<dyn HyperlaneDb>,
+    op: &QueueOperation,
+) -> OperationDisposition {
+    use OperationDisposition::{Confirm, Prepare};
+
     let id = op.id();
 
     let payload_uuids = match db.retrieve_payload_uuids_by_message_id(&id) {
         Ok(uuids) => uuids,
-        Err(_) => return false,
+        Err(_) => return Prepare,
     };
 
     let payload_uuids = match payload_uuids {
-        None => return false,
-        Some(uuids) if uuids.is_empty() => return false,
+        None => return Prepare,
+        Some(uuids) if uuids.is_empty() => return Prepare,
         Some(uuids) => uuids,
     };
 
@@ -470,10 +514,10 @@ async fn has_operation_been_submitted(
     let status = entrypoint.payload_status(payload_uuid).await;
 
     match status {
-        Ok(PayloadStatus::Dropped(_)) => false,
-        Ok(PayloadStatus::InTransaction(TransactionStatus::Dropped(_))) => false,
-        Ok(_) => true,
-        Err(_) => false,
+        Ok(PayloadStatus::Dropped(_)) => Prepare,
+        Ok(PayloadStatus::InTransaction(TransactionStatus::Dropped(_))) => Prepare,
+        Ok(_) => Confirm,
+        Err(_) => Prepare,
     }
 }
 

rust/main/agents/relayer/src/msg/message_processor/tests.rs

@@ -1,2 +1,2 @@
-mod tests_confirm_already_submitted_operations;
-mod tests_has_operation_been_submitted;
+mod tests_filter_operations_for_preparation;
+mod tests_operation_disposition_by_payload_status;

…_confirm_already_submitted_operations.rs …sts_filter_operations_for_preparation.rsrust/main/agents/relayer/src/msg/message_processor/tests/tests_confirm_already_submitted_operations.rs renamed to rust/main/agents/relayer/src/msg/message_processor/tests/tests_filter_operations_for_preparation.rs rust/main/agents/relayer/src/msg/message_processor/tests/tests_confirm_already_submitted_operations.rs renamed to rust/main/agents/relayer/src/msg/message_processor/tests/tests_filter_operations_for_preparation.rs

@@ -25,7 +25,7 @@ use lander::{
 use crate::msg::op_queue::OpQueue;
 use crate::server::operations::message_retry::MessageRetryRequest;
 
-use super::super::confirm_already_submitted_operations;
+use super::super::filter_operations_for_preparation;
 
 // Mock QueueOperation for testing
 #[derive(Debug, Serialize, Clone)]
@@ -294,14 +294,14 @@ fn create_test_queue() -> OpQueue {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_empty_batch() {
+async fn test_filter_operations_for_preparation_empty_batch() {
     let mock_db = MockHyperlaneDb::new();
     let mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
 
     let batch = vec![];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -321,7 +321,7 @@ async fn test_confirm_already_submitted_operations_empty_batch() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_all_manual_retry() {
+async fn test_filter_operations_for_preparation_all_manual_retry() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -345,7 +345,7 @@ async fn test_confirm_already_submitted_operations_all_manual_retry() {
 
     let batch = vec![op1, op2, op3];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -369,7 +369,7 @@ async fn test_confirm_already_submitted_operations_all_manual_retry() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_all_submitted() {
+async fn test_filter_operations_for_preparation_all_submitted() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -413,7 +413,7 @@ async fn test_confirm_already_submitted_operations_all_submitted() {
 
     let batch = vec![op1, op2, op3];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -437,7 +437,7 @@ async fn test_confirm_already_submitted_operations_all_submitted() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_none_submitted() {
+async fn test_filter_operations_for_preparation_none_submitted() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -459,7 +459,7 @@ async fn test_confirm_already_submitted_operations_none_submitted() {
 
     let batch = vec![op1, op2];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -483,7 +483,7 @@ async fn test_confirm_already_submitted_operations_none_submitted() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_mixed_batch() {
+async fn test_filter_operations_for_preparation_mixed_batch() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -539,7 +539,7 @@ async fn test_confirm_already_submitted_operations_mixed_batch() {
 
     let batch = vec![op1, op2, op3, op4];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -574,7 +574,7 @@ async fn test_confirm_already_submitted_operations_mixed_batch() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_db_error() {
+async fn test_filter_operations_for_preparation_db_error() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -597,7 +597,7 @@ async fn test_confirm_already_submitted_operations_db_error() {
     let op = Box::new(MockQueueOperation::with_first_prepare(message_id)) as QueueOperation;
     let batch = vec![op];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -622,7 +622,7 @@ async fn test_confirm_already_submitted_operations_db_error() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_payload_dropped() {
+async fn test_filter_operations_for_preparation_payload_dropped() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -644,7 +644,7 @@ async fn test_confirm_already_submitted_operations_payload_dropped() {
     let op = Box::new(MockQueueOperation::with_first_prepare(message_id)) as QueueOperation;
     let batch = vec![op];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -669,7 +669,7 @@ async fn test_confirm_already_submitted_operations_payload_dropped() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_transaction_dropped() {
+async fn test_filter_operations_for_preparation_transaction_dropped() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -695,7 +695,7 @@ async fn test_confirm_already_submitted_operations_transaction_dropped() {
     let op = Box::new(MockQueueOperation::with_first_prepare(message_id)) as QueueOperation;
     let batch = vec![op];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -720,7 +720,7 @@ async fn test_confirm_already_submitted_operations_transaction_dropped() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_entrypoint_error() {
+async fn test_filter_operations_for_preparation_entrypoint_error() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -742,7 +742,7 @@ async fn test_confirm_already_submitted_operations_entrypoint_error() {
     let op = Box::new(MockQueueOperation::with_first_prepare(message_id)) as QueueOperation;
     let batch = vec![op];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -767,7 +767,7 @@ async fn test_confirm_already_submitted_operations_entrypoint_error() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_non_manual_retry() {
+async fn test_filter_operations_for_preparation_non_manual_retry() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -794,7 +794,7 @@ async fn test_confirm_already_submitted_operations_non_manual_retry() {
     )) as QueueOperation;
     let batch = vec![op];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,
@@ -818,7 +818,7 @@ async fn test_confirm_already_submitted_operations_non_manual_retry() {
 }
 
 #[tokio::test]
-async fn test_confirm_already_submitted_operations_empty_payload_uuids() {
+async fn test_filter_operations_for_preparation_empty_payload_uuids() {
     let mut mock_db = MockHyperlaneDb::new();
     let mut mock_entrypoint = MockDispatcherEntrypoint::new();
     let confirm_queue = create_test_queue();
@@ -837,7 +837,7 @@ async fn test_confirm_already_submitted_operations_empty_payload_uuids() {
     let op = Box::new(MockQueueOperation::with_first_prepare(message_id)) as QueueOperation;
     let batch = vec![op];
 
-    let result = confirm_already_submitted_operations(
+    let result = filter_operations_for_preparation(
         Arc::new(mock_entrypoint) as Arc<dyn Entrypoint + Send + Sync>,
         &confirm_queue,
         Arc::new(mock_db) as Arc<dyn HyperlaneDb>,