@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,388 +0,0 @@
-use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
-
-use crate::{endpoint_v2::EndpointV2, storage, tests::endpoint_setup::setup};
-
-// ============================================================================
-// Tests for outbound function
-// ============================================================================
-
-#[test]
-fn test_outbound() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
-
-    let sender = Address::generate(env);
-    let dst_eid = 2;
-    let receiver = BytesN::from_array(env, &[1u8; 32]);
-
-    // First call should return nonce 1
-    let nonce1 = env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
-    assert_eq!(nonce1, 1);
-
-    // Second call should return nonce 2
-    let nonce2 = env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
-    assert_eq!(nonce2, 2);
-
-    // Third call should return nonce 3
-    let nonce3 = env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
-    assert_eq!(nonce3, 3);
-
-    // Different sender should have independent nonce counter (starts at 1)
-    let different_sender = Address::generate(env);
-    let nonce_diff_sender =
-        env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &different_sender, dst_eid, &receiver));
-    assert_eq!(nonce_diff_sender, 1);
-
-    // Different dst_eid should have independent nonce counter (starts at 1)
-    let different_dst_eid = 3;
-    let nonce_diff_dst =
-        env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, different_dst_eid, &receiver));
-    assert_eq!(nonce_diff_dst, 1);
-
-    // Different receiver should have independent nonce counter (starts at 1)
-    let different_receiver = BytesN::from_array(env, &[2u8; 32]);
-    let nonce_diff_receiver =
-        env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &different_receiver));
-    assert_eq!(nonce_diff_receiver, 1);
-
-    // Verify storage was updated correctly for original path
-    let stored_nonce = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::outbound_nonce(env, &sender, dst_eid, &receiver)
-    });
-    assert_eq!(stored_nonce, 3);
-}
-
-// ============================================================================
-// Tests for inbound function
-// ============================================================================
-
-#[test]
-fn test_inbound_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]); // Valid non-empty payload hash
-
-    // Call inbound with non-empty payload hash - should succeed
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
-    });
-
-    // Verify storage was updated correctly
-    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()));
-
-    // Test with different nonce for same path
-    let nonce2 = 2;
-    let payload_hash2 = BytesN::from_array(env, &[0xcdu8; 32]); // Different payload hash
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce2, &payload_hash2)
-    });
-
-    let stored_hash2 = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce2)
-    });
-    assert_eq!(stored_hash2, Some(payload_hash2.clone()));
-
-    // Test with different receiver - should have independent storage
-    let different_receiver = Address::generate(env);
-    let payload_hash3 = BytesN::from_array(env, &[0xefu8; 32]);
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &different_receiver, src_eid, &sender, nonce, &payload_hash3)
-    });
-
-    let stored_hash_diff = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(
-            env,
-            &different_receiver,
-            src_eid,
-            &sender,
-            nonce,
-        )
-    });
-    assert_eq!(stored_hash_diff, Some(payload_hash3.clone()));
-
-    // Original receiver's storage should be unchanged
-    let original_hash = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
-    });
-    assert_eq!(original_hash, Some(payload_hash));
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #11)")] // EndpointError::InvalidPayloadHash
-fn test_inbound_empty_payload_hash() {
-    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 empty_hash = BytesN::from_array(env, &[0u8; 32]); // empty_payload_hash - now invalid
-
-    // Should panic with InvalidPayloadHash error because empty hash is not allowed
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &empty_hash)
-    });
-}
-
-// ============================================================================
-// Tests for clear_payload function
-// ============================================================================
-
-#[test]
-fn test_clear_payload_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 = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
-
-    // Compute the expected hash
-    let payload_hash = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
-    });
-
-    // First store the payload hash via inbound
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
-    });
-
-    // Verify it's 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()));
-
-    // Clear the payload
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, nonce, &payload)
-    });
-
-    // Verify it's removed from storage
-    let cleared_hash = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
-    });
-    assert_eq!(cleared_hash, 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)
-    });
-    assert_eq!(lazy_nonce, nonce);
-}
-
-#[test]
-fn test_clear_payload_with_lazy_nonce_update() {
-    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]);
-
-    // Store three payloads (nonce 1, 2, 3)
-    let payload1 = Bytes::from_array(env, &[0x01]);
-    let payload2 = Bytes::from_array(env, &[0x02]);
-    let payload3 = Bytes::from_array(env, &[0x03]);
-
-    let hash1 = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload1).to_array())
-    });
-    let hash2 = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload2).to_array())
-    });
-    let hash3 = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload3).to_array())
-    });
-
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 1, &hash1));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 2, &hash2));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 3, &hash3));
-
-    // Lazy nonce should be 0 (not updated yet)
-    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
-    });
-    assert_eq!(lazy_nonce, 0);
-
-    // Clear payload 3 directly (skipping 1 and 2)
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 3, &payload3)
-    });
-
-    // Lazy nonce should be updated to 3
-    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
-    });
-    assert_eq!(lazy_nonce, 3);
-
-    // Payload 3 should be cleared
-    let hash3_after = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, 3)
-    });
-    assert_eq!(hash3_after, None);
-}
-
-#[test]
-fn test_clear_payload_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 = BytesN::from_array(env, &[1u8; 32]);
-
-    // Store three payloads
-    let payload1 = Bytes::from_array(env, &[0x01]);
-    let payload2 = Bytes::from_array(env, &[0x02]);
-    let payload3 = Bytes::from_array(env, &[0x03]);
-
-    let hash1 = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload1).to_array())
-    });
-    let hash2 = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload2).to_array())
-    });
-    let hash3 = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload3).to_array())
-    });
-
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 1, &hash1));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 2, &hash2));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 3, &hash3));
-
-    // Clear them in order: 1, 2, 3
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 1, &payload1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 2, &payload2)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 3, &payload3)
-    });
-
-    // All should be cleared
-    let hash1_after = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, 1)
-    });
-    let hash2_after = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, 2)
-    });
-    let hash3_after = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, 3)
-    });
-
-    assert_eq!(hash1_after, None);
-    assert_eq!(hash2_after, None);
-    assert_eq!(hash3_after, None);
-
-    // Lazy nonce should be 3
-    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
-    });
-    assert_eq!(lazy_nonce, 3);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #19)")] // EndpointError::PayloadHashNotFound
-fn test_clear_payload_wrong_payload() {
-    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 = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
-    let wrong_payload = Bytes::from_array(env, &[0xdd, 0xee, 0xff]); // Different payload
-
-    let payload_hash = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
-    });
-
-    // Store the correct hash
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
-    });
-
-    // Try to clear with wrong payload - should panic
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, nonce, &wrong_payload)
-    });
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #10)")] // EndpointError::InvalidNonce
-fn test_clear_payload_not_stored() {
-    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 = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
-
-    // Try to clear without storing first - should panic with InvalidNonce
-    // (because intermediate nonce validation fails before checking payload hash)
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, nonce, &payload)
-    });
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #10)")] // EndpointError::InvalidNonce
-fn test_clear_payload_missing_intermediate_nonce() {
-    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]);
-
-    // Store only nonce 1 and 3, skip nonce 2
-    let payload1 = Bytes::from_array(env, &[0x01]);
-    let payload3 = Bytes::from_array(env, &[0x03]);
-
-    let hash1 = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload1).to_array())
-    });
-    let hash3 = env.as_contract(&endpoint_client.address, || {
-        BytesN::from_array(env, &env.crypto().keccak256(&payload3).to_array())
-    });
-
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 1, &hash1));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 3, &hash3));
-
-    // Clear nonce 1 first
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 1, &payload1)
-    });
-
-    // Try to clear nonce 3 - should panic because nonce 2 is missing
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 3, &payload3)
-    });
-}

package/contracts/message-libs/message-lib-common/src/tests/packet_codec_v1.rs

@@ -1,162 +0,0 @@
-use crate::packet_codec_v1::*;
-use endpoint_v2::{
-    util::{compute_guid, keccak256},
-    OutboundPacket,
-};
-use hex_literal::hex;
-use soroban_sdk::{address_payload::AddressPayload, Address, Bytes, BytesN, Env};
-use utils::buffer_reader::BufferReader;
-
-// Test constants matching Sui's test values
-const TEST_SRC_EID: u32 = 101;
-const TEST_DST_EID: u32 = 102;
-const TEST_NONCE: u64 = 0x123456789abcdef0;
-const TEST_MESSAGE: [u8; 5] = hex!("0102030405");
-// @0x1234567890abcdef1234567890abcdef12345678 padded to 32 bytes
-const TEST_SENDER_BYTES: [u8; 32] = hex!("0000000000000000000000001234567890abcdef1234567890abcdef12345678");
-// @0x9876543210fedcba9876543210fedcba98765432 padded to 32 bytes
-const TEST_RECEIVER_BYTES: [u8; 32] = hex!("0000000000000000000000009876543210fedcba9876543210fedcba98765432");
-
-#[test]
-fn test_encode_decode_packet_header() {
-    let env = Env::default();
-    let packet = create_test_outbound_packet(&env);
-
-    // Encode the packet header
-    let encoded_header = encode_packet_header(&env, &packet);
-
-    // Verify the encoded header has the correct length
-    assert_eq!(encoded_header.len(), HEADER_LENGTH); // HEADER_LENGTH = 81
-
-    // Decode the header back
-    let decoded_header = decode_packet_header(&env, &encoded_header);
-
-    // Verify all fields match
-    assert_eq!(decoded_header.version, PACKET_VERSION);
-    assert_eq!(decoded_header.nonce, TEST_NONCE);
-    assert_eq!(decoded_header.src_eid, TEST_SRC_EID);
-    assert_eq!(decoded_header.dst_eid, TEST_DST_EID);
-    assert_eq!(decoded_header.sender, BytesN::from_array(&env, &TEST_SENDER_BYTES));
-    assert_eq!(decoded_header.receiver, BytesN::from_array(&env, &TEST_RECEIVER_BYTES));
-}
-
-#[test]
-fn test_payload_functions() {
-    let env = Env::default();
-    let packet = create_test_outbound_packet(&env);
-
-    // Test payload extraction
-    let payload_result = payload(&env, &packet);
-
-    // Expected payload is guid + message
-    let mut expected_payload = Bytes::new(&env);
-    expected_payload.extend_from_array(&packet.guid.to_array());
-    expected_payload.append(&packet.message);
-    assert_eq!(payload_result, expected_payload);
-
-    // Test payload hash
-    let hash_result = payload_hash(&env, &packet);
-    let expected_hash = keccak256(&env, &payload_result);
-    assert_eq!(hash_result, expected_hash);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1001)")] // PacketCodecV1Error::InvalidPacketHeader
-fn test_invalid_header_length() {
-    let env = Env::default();
-    // Create a header with wrong length (too short) - only 3 bytes instead of 81
-    let invalid_header = Bytes::from_array(&env, &[0x01, 0x02, 0x03]);
-    decode_packet_header(&env, &invalid_header);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1002)")] // PacketCodecV1Error::InvalidPacketVersion
-fn test_invalid_packet_version() {
-    let env = Env::default();
-    // Create a header with correct length but wrong version
-    let mut invalid_header_bytes: [u8; 81] = [0u8; HEADER_LENGTH as usize];
-    invalid_header_bytes[0] = 2; // Wrong version (should be 1)
-    let invalid_header = Bytes::from_array(&env, &invalid_header_bytes);
-    decode_packet_header(&env, &invalid_header);
-}
-
-#[test]
-fn test_header_getters() {
-    let env = Env::default();
-    let header = create_test_header(&env);
-    // Test all getter/field accesses
-    assert_eq!(header.version, PACKET_VERSION);
-    assert_eq!(header.nonce, TEST_NONCE);
-    assert_eq!(header.src_eid, TEST_SRC_EID);
-    assert_eq!(header.dst_eid, TEST_DST_EID);
-    assert_eq!(header.sender, BytesN::from_array(&env, &TEST_SENDER_BYTES));
-    assert_eq!(header.receiver, BytesN::from_array(&env, &TEST_RECEIVER_BYTES));
-}
-
-#[test]
-fn test_empty_message() {
-    let env = Env::default();
-    let empty_message = Bytes::new(&env);
-    let packet = create_test_outbound_packet_with_message(&env, empty_message);
-
-    // Test encoding and decoding with empty message
-    let encoded = encode_packet(&env, &packet);
-    let (header, decoded_guid, decoded_message) = decode_packet_for_test(&env, &encoded);
-
-    assert_eq!(header.src_eid, TEST_SRC_EID);
-    assert_eq!(decoded_guid, packet.guid);
-    assert_eq!(decoded_message.len(), 0);
-}
-
-#[test]
-fn test_large_message() {
-    let env = Env::default();
-
-    // Create a large message (1024 bytes, matching Sui's 1KB)
-    let mut large_msg_array = [0u8; 1024];
-    for (i, byte) in large_msg_array.iter_mut().enumerate() {
-        *byte = (i % 256) as u8;
-    }
-    let large_message = Bytes::from_slice(&env, &large_msg_array);
-    let packet = create_test_outbound_packet_with_message(&env, large_message.clone());
-
-    // Test encoding and decoding with large message
-    let encoded = encode_packet(&env, &packet);
-    let (header, decoded_guid, decoded_message) = decode_packet_for_test(&env, &encoded);
-
-    assert_eq!(header.src_eid, TEST_SRC_EID);
-    assert_eq!(decoded_guid, packet.guid);
-    assert_eq!(decoded_message.len(), 1024);
-    assert_eq!(decoded_message, large_message);
-}
-
-fn create_test_header(env: &Env) -> PacketHeader {
-    let mut header_bytes = Bytes::new(env);
-    header_bytes.extend_from_array(&[PACKET_VERSION]); // version
-    header_bytes.extend_from_array(&TEST_NONCE.to_be_bytes()); // nonce
-    header_bytes.extend_from_array(&TEST_SRC_EID.to_be_bytes()); // src_eid
-    header_bytes.extend_from_array(&TEST_SENDER_BYTES); // sender
-    header_bytes.extend_from_array(&TEST_DST_EID.to_be_bytes()); // dst_eid
-    header_bytes.extend_from_array(&TEST_RECEIVER_BYTES); // receiver
-    decode_packet_header(env, &header_bytes)
-}
-
-fn create_test_outbound_packet(env: &Env) -> OutboundPacket {
-    create_test_outbound_packet_with_message(env, Bytes::from_array(env, &TEST_MESSAGE))
-}
-
-fn create_test_outbound_packet_with_message(env: &Env, message: Bytes) -> OutboundPacket {
-    let sender =
-        Address::from_payload(env, AddressPayload::ContractIdHash(BytesN::from_array(env, &TEST_SENDER_BYTES)));
-    let receiver = BytesN::from_array(env, &TEST_RECEIVER_BYTES);
-    let guid = compute_guid(env, TEST_NONCE, TEST_SRC_EID, &sender, TEST_DST_EID, &receiver);
-    OutboundPacket { nonce: TEST_NONCE, src_eid: TEST_SRC_EID, sender, dst_eid: TEST_DST_EID, receiver, guid, message }
-}
-
-fn decode_packet_for_test(env: &Env, encoded: &Bytes) -> (PacketHeader, BytesN<32>, Bytes) {
-    let mut reader = BufferReader::new(encoded);
-    let header = decode_packet_header(env, &reader.read_bytes(HEADER_LENGTH));
-    let guid = reader.read_bytes_n();
-    let message = reader.read_bytes_until_end();
-    (header, guid, message)
-}