@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

package/contracts/endpoint-v2/src/tests/messaging_channel/clear.rs

@@ -1,316 +0,0 @@
-use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, IntoVal};
-
-use crate::{
-    endpoint_v2::EndpointV2,
-    errors::EndpointError,
-    events::PacketDelivered,
-    interfaces::Origin,
-    storage,
-    tests::endpoint_setup::setup,
-    util::{build_payload, compute_guid},
-};
-use utils::testing_utils::assert_event;
-
-#[test]
-fn test_clear_success() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
-
-    let receiver = Address::generate(env);
-    let src_eid = 2;
-    let sender_bytes = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 1;
-    let message = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
-
-    // Compute guid and build payload
-    let guid =
-        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
-    let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &guid, &message));
-
-    // Compute and store payload hash
-    let payload_hash = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
-    });
-
-    // Verify payload hash is stored
-    let stored = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender_bytes, nonce)
-    });
-    assert_eq!(stored, Some(payload_hash.clone()));
-
-    // Clear the payload (receiver authorizes itself)
-    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
-    endpoint_client
-        .mock_auths(&[soroban_sdk::testutils::MockAuth {
-            address: &receiver,
-            invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                contract: &endpoint_client.address,
-                fn_name: "clear",
-                args: (&receiver, &origin, &receiver, &guid, &message).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .clear(&receiver, &origin, &receiver, &guid, &message);
-
-    // Verify PacketDelivered event was emitted
-    assert_event(env, &endpoint_client.address, PacketDelivered { origin: origin.clone(), receiver: receiver.clone() });
-
-    // Verify payload hash is removed
-    let cleared = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender_bytes, nonce)
-    });
-    assert_eq!(cleared, None);
-
-    // Verify lazy nonce was updated
-    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender_bytes)
-    });
-    assert_eq!(lazy_nonce, nonce);
-}
-
-#[test]
-fn test_clear_with_delegate() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
-
-    let receiver = Address::generate(env);
-    let delegate = Address::generate(env);
-    let src_eid = 2;
-    let sender_bytes = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 1;
-    let message = Bytes::from_array(env, &[0xdd, 0xee, 0xff]);
-
-    // Set delegate for receiver
-    env.as_contract(&endpoint_client.address, || storage::EndpointStorage::set_delegate(env, &receiver, &delegate));
-
-    // Compute guid and build payload
-    let guid =
-        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
-    let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &guid, &message));
-
-    // Store payload hash
-    let payload_hash = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
-    });
-
-    // Clear using delegate
-    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
-    endpoint_client
-        .mock_auths(&[soroban_sdk::testutils::MockAuth {
-            address: &delegate,
-            invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                contract: &endpoint_client.address,
-                fn_name: "clear",
-                args: (&delegate, &origin, &receiver, &guid, &message).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .clear(&delegate, &origin, &receiver, &guid, &message);
-
-    // Verify PacketDelivered event was emitted
-    assert_event(env, &endpoint_client.address, PacketDelivered { origin: origin.clone(), receiver: receiver.clone() });
-
-    // Verify payload is cleared
-    let cleared = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender_bytes, nonce)
-    });
-    assert_eq!(cleared, None);
-}
-
-#[test]
-fn test_panic_clear_unauthorized() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
-
-    let receiver = Address::generate(env);
-    let unauthorized_caller = Address::generate(env);
-    let src_eid = 2;
-    let sender_bytes = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 1;
-    let message = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
-
-    let guid =
-        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
-
-    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
-
-    // Try to clear with unauthorized caller - should panic
-    assert_eq!(
-        endpoint_client
-            .mock_auths(&[soroban_sdk::testutils::MockAuth {
-                address: &unauthorized_caller,
-                invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                    contract: &endpoint_client.address,
-                    fn_name: "clear",
-                    args: (&unauthorized_caller, &origin, &receiver, &guid, &message).into_val(env),
-                    sub_invokes: &[],
-                },
-            }])
-            .try_clear(&unauthorized_caller, &origin, &receiver, &guid, &message)
-            .unwrap_err()
-            .unwrap(),
-        EndpointError::Unauthorized.into()
-    );
-}
-
-#[test]
-fn test_panic_clear_wrong_message() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
-
-    let receiver = Address::generate(env);
-    let src_eid = 2;
-    let sender_bytes = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 1;
-    let correct_message = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
-    let wrong_message = Bytes::from_array(env, &[0xdd, 0xee, 0xff]);
-
-    // Store with correct message
-    let guid =
-        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
-    let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &guid, &correct_message));
-    let payload_hash = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
-    });
-
-    // Try to clear with wrong message - should panic
-    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
-    assert_eq!(
-        endpoint_client
-            .mock_auths(&[soroban_sdk::testutils::MockAuth {
-                address: &receiver,
-                invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                    contract: &endpoint_client.address,
-                    fn_name: "clear",
-                    args: (&receiver, &origin, &receiver, &guid, &wrong_message).into_val(env),
-                    sub_invokes: &[],
-                },
-            }])
-            .try_clear(&receiver, &origin, &receiver, &guid, &wrong_message)
-            .unwrap_err()
-            .unwrap(),
-        EndpointError::PayloadHashNotFound.into()
-    );
-}
-
-#[test]
-fn test_panic_clear_wrong_guid() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
-
-    let receiver = Address::generate(env);
-    let src_eid = 2;
-    let sender_bytes = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 1;
-    let message = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
-
-    // Store with correct guid
-    let correct_guid =
-        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
-    let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &correct_guid, &message));
-    let payload_hash = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
-    });
-
-    // Try to clear with wrong guid - should panic
-    let wrong_guid = BytesN::from_array(env, &[0xffu8; 32]);
-    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
-    assert_eq!(
-        endpoint_client
-            .mock_auths(&[soroban_sdk::testutils::MockAuth {
-                address: &receiver,
-                invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                    contract: &endpoint_client.address,
-                    fn_name: "clear",
-                    args: (&receiver, &origin, &receiver, &wrong_guid, &message).into_val(env),
-                    sub_invokes: &[],
-                },
-            }])
-            .try_clear(&receiver, &origin, &receiver, &wrong_guid, &message)
-            .unwrap_err()
-            .unwrap(),
-        EndpointError::PayloadHashNotFound.into()
-    );
-}
-
-#[test]
-fn test_clear_multiple_sequential() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
-
-    let receiver = Address::generate(env);
-    let src_eid = 2;
-    let sender_bytes = BytesN::from_array(env, &[1u8; 32]);
-
-    // Store 3 payloads
-    for nonce in 1..=3 {
-        let message = Bytes::from_array(env, &[nonce as u8]);
-        let guid = env
-            .as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
-        let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &guid, &message));
-        let payload_hash = env.as_contract(&endpoint_client.address, || {
-            BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
-        });
-        env.as_contract(&endpoint_client.address, || {
-            EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
-        });
-    }
-
-    // Clear them in order
-    for nonce in 1..=3 {
-        let message = Bytes::from_array(env, &[nonce as u8]);
-        let guid = env
-            .as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
-        let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
-
-        endpoint_client
-            .mock_auths(&[soroban_sdk::testutils::MockAuth {
-                address: &receiver,
-                invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                    contract: &endpoint_client.address,
-                    fn_name: "clear",
-                    args: (&receiver, &origin, &receiver, &guid, &message).into_val(env),
-                    sub_invokes: &[],
-                },
-            }])
-            .clear(&receiver, &origin, &receiver, &guid, &message);
-    }
-
-    // Verify all are cleared
-    for nonce in 1..=3 {
-        let cleared = env.as_contract(&endpoint_client.address, || {
-            storage::EndpointStorage::inbound_payload_hash(
-                env,
-                &receiver,
-                src_eid,
-                &sender_bytes,
-                nonce,
-            )
-        });
-        assert_eq!(cleared, None);
-    }
-
-    // Verify lazy nonce is updated to 3
-    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender_bytes)
-    });
-    assert_eq!(lazy_nonce, 3);
-}