@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/endpoint-v2/src/tests/message_lib_manager/set_send_library.rs

@@ -0,0 +1,131 @@
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    vec, Address, IntoVal,
+};
+
+use crate::{errors::EndpointError, events::SendLibrarySet, storage, tests::endpoint_setup::setup, MessageLibType};
+use utils::testing_utils::assert_event;
+
+// Tests for set_send_library
+#[test]
+fn test_set_send_library_requires_oapp_auth() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let unauthorized_caller = Address::generate(env);
+
+    // Create and register a valid send lib
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+
+    // Mock auth for unauthorized caller (not the oapp or its delegate)
+    env.mock_auths(&[MockAuth {
+        address: &unauthorized_caller,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_send_library",
+            args: (&unauthorized_caller, &oapp, &context.eid, &send_lib).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    // Should fail with Unauthorized error
+    let result = endpoint_client.try_set_send_library(&unauthorized_caller, &oapp, &context.eid, &Some(send_lib));
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::Unauthorized.into());
+}
+
+#[test]
+fn test_set_send_library_same_value() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    // Create and register a valid send lib
+    let send_lib_add = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    let send_lib = Some(send_lib_add.clone());
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&send_lib_add,));
+    endpoint_client.register_library(&send_lib_add);
+
+    // First set with oapp auth - oapp sets its own send library
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_send_library",
+            args: (&oapp, &oapp, &context.eid, &send_lib).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_send_library(&oapp, &oapp, &context.eid, &send_lib);
+
+    // Try to set the same library again with oapp auth
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_send_library",
+            args: (&oapp, &oapp, &context.eid, &send_lib).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let result = endpoint_client.try_set_send_library(&oapp, &oapp, &context.eid, &send_lib);
+
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::SameValue.into());
+}
+
+#[test]
+fn test_set_send_library_success() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    // Create and register a valid send lib
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+
+    // Verify it was not set
+    assert_eq!(
+        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::send_library(env, &oapp, context.eid)),
+        None
+    );
+
+    // Set with oapp auth - oapp sets its own send library
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_send_library",
+            args: (&oapp, &oapp, &context.eid, &send_lib).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    endpoint_client.set_send_library(&oapp, &oapp, &context.eid, &Some(send_lib.clone()));
+
+    // Verify the event was published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        SendLibrarySet { sender: oapp.clone(), dst_eid: context.eid, new_lib: Some(send_lib.clone()) },
+    );
+
+    // Verify it was set correctly
+    assert_eq!(
+        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::send_library(env, &oapp, context.eid)),
+        Some(send_lib)
+    );
+}

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

@@ -0,0 +1,358 @@
+use soroban_sdk::{testutils::Address as _, Address, BytesN, IntoVal};
+
+use crate::{endpoint_v2::EndpointV2, events::PacketBurnt, storage, tests::endpoint_setup::setup};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_burn_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 = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
+
+    // Set lazy nonce to 1 so nonce 1 is <= lazy nonce
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &1)
+    });
+
+    // Store a payload hash first
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+    });
+
+    // Verify payload hash is stored
+    let stored_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(stored_hash, Some(payload_hash.clone()));
+
+    // Burn the payload
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "burn",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce, &payload_hash).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .burn(&receiver, &receiver, &src_eid, &sender, &nonce, &payload_hash);
+
+    // Verify PacketBurnt event was emitted
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketBurnt {
+            src_eid,
+            sender: sender.clone(),
+            receiver: receiver.clone(),
+            nonce,
+            payload_hash: payload_hash.clone(),
+        },
+    );
+
+    // Verify payload hash was removed
+    let removed_hash: Option<BytesN<32>> = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(removed_hash, None);
+}
+
+#[test]
+fn test_burn_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 = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let payload_hash = BytesN::from_array(env, &[0xcdu8; 32]);
+
+    // Set delegate for receiver
+    env.as_contract(&endpoint_client.address, || storage::EndpointStorage::set_delegate(env, &receiver, &delegate));
+
+    // Set lazy nonce to 1 so nonce 1 is <= lazy nonce
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &1)
+    });
+
+    // Store a payload hash first
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+    });
+
+    // Delegate can burn on behalf of receiver
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &delegate,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "burn",
+                args: (&delegate, &receiver, &src_eid, &sender, &nonce, &payload_hash).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .burn(&delegate, &receiver, &src_eid, &sender, &nonce, &payload_hash);
+
+    // Verify PacketBurnt event was emitted
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketBurnt {
+            src_eid,
+            sender: sender.clone(),
+            receiver: receiver.clone(),
+            nonce,
+            payload_hash: payload_hash.clone(),
+        },
+    );
+
+    // Verify payload hash was removed
+    let removed_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(removed_hash, None);
+}
+
+#[test]
+fn test_burn_multiple_payloads() {
+    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 = BytesN::from_array(env, &[1u8; 32]);
+    let payload_hash1 = BytesN::from_array(env, &[0xabu8; 32]);
+    let payload_hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
+    let nonce1 = 1;
+    let nonce2 = 2;
+
+    // Set lazy nonce to 2 so both nonces are <= lazy nonce
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &2)
+    });
+
+    // Store multiple payload hashes
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce1, &payload_hash1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce2, &payload_hash2)
+    });
+
+    // Burn first payload
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "burn",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce1, &payload_hash1).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .burn(&receiver, &receiver, &src_eid, &sender, &nonce1, &payload_hash1);
+
+    // Burn second payload
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "burn",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce2, &payload_hash2).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .burn(&receiver, &receiver, &src_eid, &sender, &nonce2, &payload_hash2);
+
+    // Verify both payload hashes were removed
+    let removed_hash1 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce1)
+    });
+    let removed_hash2 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce2)
+    });
+
+    assert_eq!(removed_hash1, None);
+    assert_eq!(removed_hash2, None);
+}
+
+#[test]
+fn test_burn_different_paths() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let receiver1 = Address::generate(env);
+    let receiver2 = Address::generate(env);
+    let src_eid1 = 2;
+    let src_eid2 = 3;
+    let sender1 = BytesN::from_array(env, &[1u8; 32]);
+    let sender2 = BytesN::from_array(env, &[2u8; 32]);
+    let nonce = 1;
+    let payload_hash = BytesN::from_array(env, &[0xefu8; 32]);
+
+    // Set lazy nonces for all paths
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid1, &sender1, &1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver2, src_eid1, &sender1, &1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid2, &sender1, &1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid1, &sender2, &1)
+    });
+
+    // Store payload hashes for different paths
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver1, src_eid1, &sender1, nonce, &payload_hash)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver2, src_eid1, &sender1, nonce, &payload_hash)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver1, src_eid2, &sender1, nonce, &payload_hash)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver1, src_eid1, &sender2, nonce, &payload_hash)
+    });
+
+    // Burn for different receivers
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver1,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "burn",
+                args: (&receiver1, &receiver1, &src_eid1, &sender1, &nonce, &payload_hash).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .burn(&receiver1, &receiver1, &src_eid1, &sender1, &nonce, &payload_hash);
+
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver2,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "burn",
+                args: (&receiver2, &receiver2, &src_eid1, &sender1, &nonce, &payload_hash).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .burn(&receiver2, &receiver2, &src_eid1, &sender1, &nonce, &payload_hash);
+
+    // Burn for different src_eids
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver1,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "burn",
+                args: (&receiver1, &receiver1, &src_eid2, &sender1, &nonce, &payload_hash).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .burn(&receiver1, &receiver1, &src_eid2, &sender1, &nonce, &payload_hash);
+
+    // Burn for different senders
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver1,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "burn",
+                args: (&receiver1, &receiver1, &src_eid1, &sender2, &nonce, &payload_hash).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .burn(&receiver1, &receiver1, &src_eid1, &sender2, &nonce, &payload_hash);
+
+    // Verify all paths have been burned independently
+    let removed_hash1 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver1, src_eid1, &sender1, nonce)
+    });
+    let removed_hash2 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver2, src_eid1, &sender1, nonce)
+    });
+    let removed_hash3 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver1, src_eid2, &sender1, nonce)
+    });
+    let removed_hash4 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver1, src_eid1, &sender2, nonce)
+    });
+
+    assert_eq!(removed_hash1, None);
+    assert_eq!(removed_hash2, None);
+    assert_eq!(removed_hash3, None);
+    assert_eq!(removed_hash4, None);
+}
+
+#[test]
+fn test_burn_at_lazy_nonce_boundary() {
+    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 = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 5;
+    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
+
+    // Set lazy nonce to exactly the nonce we want to burn
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &nonce)
+    });
+
+    // Store a payload hash
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+    });
+
+    // Burn should succeed since nonce == lazy_nonce (nonce <= lazy_nonce)
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "burn",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce, &payload_hash).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .burn(&receiver, &receiver, &src_eid, &sender, &nonce, &payload_hash);
+
+    // Verify PacketBurnt event was emitted
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketBurnt {
+            src_eid,
+            sender: sender.clone(),
+            receiver: receiver.clone(),
+            nonce,
+            payload_hash: payload_hash.clone(),
+        },
+    );
+
+    // Verify payload hash was removed
+    let removed_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(removed_hash, None);
+}