@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,50 +1,100 @@
-use soroban_sdk::{testutils::Address as _, Address, BytesN, IntoVal};
-
-use crate::{endpoint_v2::EndpointV2, events::PacketBurnt, storage, tests::endpoint_setup::setup};
+use soroban_sdk::{testutils::Address as _, Address, BytesN};
 use utils::testing_utils::assert_event;
 
+use crate::{
+    errors::EndpointError,
+    events::PacketBurnt,
+    storage,
+    tests::endpoint_setup::{setup, TestSetup},
+};
+
+// Helpers
+fn burn_with_auth(
+    context: &TestSetup,
+    caller: &Address,
+    receiver: &Address,
+    src_eid: u32,
+    sender: &BytesN<32>,
+    nonce: u64,
+    payload_hash: &BytesN<32>,
+) {
+    context.mock_auth(caller, "burn", (caller, receiver, &src_eid, sender, &nonce, payload_hash));
+    context.endpoint_client.burn(caller, receiver, &src_eid, sender, &nonce, payload_hash);
+}
+
+fn try_burn_with_auth(
+    context: &TestSetup,
+    caller: &Address,
+    receiver: &Address,
+    src_eid: u32,
+    sender: &BytesN<32>,
+    nonce: u64,
+    payload_hash: &BytesN<32>,
+) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+    context.mock_auth(caller, "burn", (caller, receiver, &src_eid, sender, &nonce, payload_hash));
+    context.endpoint_client.try_burn(caller, receiver, &src_eid, sender, &nonce, payload_hash)
+}
+
+// Authorization (receiver or delegate(receiver) must authorize)
 #[test]
-fn test_burn_success() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+fn test_burn_unauthorized() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
+    let unauthorized = Address::generate(env);
     let src_eid = 2;
     let sender = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 1;
+    let nonce = 1u64;
+    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
+
+    let result = endpoint_client.try_burn(&unauthorized, &receiver, &src_eid, &sender, &nonce, &payload_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::Unauthorized.into());
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_burn_requires_auth_even_when_caller_is_receiver() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1u64;
+    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
+
+    // No mock_auth here: require_oapp_auth passes the (caller == receiver) check,
+    // then panics at caller.require_auth().
+    endpoint_client.burn(&receiver, &receiver, &src_eid, &sender, &nonce, &payload_hash);
+}
+
+// Successful burn removes stored payload hash (state update + event emission)
+#[test]
+fn test_burn_success_with_stored_payload() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1u64;
     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
+    // Boundary condition: burn requires nonce <= lazy_nonce.
+    context.set_lazy_inbound_nonce(&receiver, src_eid, &sender, nonce);
+
+    // Store a payload hash first.
+    context.inbound_as_verified(&receiver, src_eid, &sender, nonce, &payload_hash);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), Some(payload_hash.clone()));
+
+    // Burn the payload.
+    burn_with_auth(&context, &receiver, &receiver, src_eid, &sender, nonce, &payload_hash);
+
+    // Verify PacketBurnt event was emitted.
     assert_event(
         env,
         &endpoint_client.address,
@@ -57,18 +107,16 @@ fn test_burn_success() {
         },
     );
 
-    // 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);
+    // Verify payload hash was removed.
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), None);
 }
 
+// Delegate authorization (delegate(receiver) is allowed)
 #[test]
 fn test_burn_with_delegate() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let delegate = Address::generate(env);
@@ -77,33 +125,19 @@ fn test_burn_with_delegate() {
     let nonce = 1;
     let payload_hash = BytesN::from_array(env, &[0xcdu8; 32]);
 
-    // Set delegate for receiver
+    // 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
+    // Burn requires nonce <= lazy_nonce.
+    context.set_lazy_inbound_nonce(&receiver, src_eid, &sender, 1);
+
+    // Store a payload hash first.
+    context.inbound_as_verified(&receiver, src_eid, &sender, nonce, &payload_hash);
+
+    // Delegate can burn on behalf of receiver.
+    burn_with_auth(&context, &delegate, &receiver, src_eid, &sender, nonce, &payload_hash);
+
+    // Verify PacketBurnt event was emitted.
     assert_event(
         env,
         &endpoint_client.address,
@@ -116,18 +150,16 @@ fn test_burn_with_delegate() {
         },
     );
 
-    // 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);
+    // Verify payload hash was removed.
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), None);
 }
 
+// Burn affects only the targeted nonce (multiple nonces stay independent)
 #[test]
 fn test_burn_multiple_payloads() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
@@ -137,62 +169,30 @@ fn test_burn_multiple_payloads() {
     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);
+    // Burn requires nonce <= lazy_nonce.
+    context.set_lazy_inbound_nonce(&receiver, src_eid, &sender, 2);
+
+    // Store multiple payload hashes.
+    context.inbound_as_verified(&receiver, src_eid, &sender, nonce1, &payload_hash1);
+    context.inbound_as_verified(&receiver, src_eid, &sender, nonce2, &payload_hash2);
+
+    // Burn first payload.
+    burn_with_auth(&context, &receiver, &receiver, src_eid, &sender, nonce1, &payload_hash1);
+
+    // Burn second payload.
+    burn_with_auth(&context, &receiver, &receiver, src_eid, &sender, nonce2, &payload_hash2);
+
+    // Verify both payload hashes were removed.
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce1), None);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce2), None);
 }
 
+// Path isolation (receiver/src_eid/sender are isolated)
 #[test]
 fn test_burn_different_paths() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver1 = Address::generate(env);
     let receiver2 = Address::generate(env);
@@ -203,156 +203,95 @@ fn test_burn_different_paths() {
     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);
+    // Burn requires nonce <= lazy_nonce.
+    context.set_lazy_inbound_nonce(&receiver1, src_eid1, &sender1, 1);
+    context.set_lazy_inbound_nonce(&receiver2, src_eid1, &sender1, 1);
+    context.set_lazy_inbound_nonce(&receiver1, src_eid2, &sender1, 1);
+    context.set_lazy_inbound_nonce(&receiver1, src_eid1, &sender2, 1);
+
+    // Store payload hashes for different paths.
+    context.inbound_as_verified(&receiver1, src_eid1, &sender1, nonce, &payload_hash);
+    context.inbound_as_verified(&receiver2, src_eid1, &sender1, nonce, &payload_hash);
+    context.inbound_as_verified(&receiver1, src_eid2, &sender1, nonce, &payload_hash);
+    context.inbound_as_verified(&receiver1, src_eid1, &sender2, nonce, &payload_hash);
+
+    // Burn for different receivers.
+    burn_with_auth(&context, &receiver1, &receiver1, src_eid1, &sender1, nonce, &payload_hash);
+
+    burn_with_auth(&context, &receiver2, &receiver2, src_eid1, &sender1, nonce, &payload_hash);
+
+    // Burn for different src_eids.
+    burn_with_auth(&context, &receiver1, &receiver1, src_eid2, &sender1, nonce, &payload_hash);
+
+    // Burn for different senders.
+    burn_with_auth(&context, &receiver1, &receiver1, src_eid1, &sender2, nonce, &payload_hash);
+
+    // Verify all paths have been burned independently.
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver1, &src_eid1, &sender1, &nonce), None);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver2, &src_eid1, &sender1, &nonce), None);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver1, &src_eid2, &sender1, &nonce), None);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver1, &src_eid1, &sender2, &nonce), None);
 }
 
+// Failure if payload_hash does not match the stored value
 #[test]
-fn test_burn_at_lazy_nonce_boundary() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+fn test_burn_payload_hash_not_found_when_mismatch() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
     let sender = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 5;
+    let nonce = 1u64;
     let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
+    let wrong_payload_hash = BytesN::from_array(env, &[0x11u8; 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(),
-        },
-    );
+    // Burn requires nonce <= lazy_nonce.
+    context.set_lazy_inbound_nonce(&receiver, src_eid, &sender, nonce);
+
+    // Store a payload hash first.
+    context.inbound_as_verified(&receiver, src_eid, &sender, nonce, &payload_hash);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), Some(payload_hash.clone()));
+
+    // Mismatched expected hash should fail.
+    let result = try_burn_with_auth(&context, &receiver, &receiver, src_eid, &sender, nonce, &wrong_payload_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::PayloadHashNotFound.into());
+}
+
+#[test]
+fn test_burn_payload_hash_not_found_when_storage_none() {
+    let context = setup();
+    let env = &context.env;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1u64;
+    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
+
+    // Even if nonce <= lazy_nonce, burn must fail without a stored payload hash.
+    context.set_lazy_inbound_nonce(&receiver, src_eid, &sender, nonce);
+    let result = try_burn_with_auth(&context, &receiver, &receiver, src_eid, &sender, nonce, &payload_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::PayloadHashNotFound.into());
+}
+
+// Failure when nonce is greater than lazy nonce
+#[test]
+fn test_burn_invalid_nonce_when_greater_than_lazy_nonce() {
+    let context = setup();
+    let env = &context.env;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 2u64;
+    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
+
+    // lazy nonce is 1, trying to burn nonce 2 should fail.
+    context.set_lazy_inbound_nonce(&receiver, src_eid, &sender, 1);
+    context.inbound_as_verified(&receiver, src_eid, &sender, nonce, &payload_hash);
 
-    // 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);
+    let result = try_burn_with_auth(&context, &receiver, &receiver, src_eid, &sender, nonce, &payload_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InvalidNonce.into());
 }