fix: correctly provide all of the package in rawMessage

Author: reednaa

src/apps/layerzero/IncentivizedLayerZeroEscrow.sol

@@ -187,17 +187,17 @@ contract IncentivizedLayerZeroEscrow is IncentivizedMessageEscrow, ExecutorZero
         asset =  address(0);
     }
 
-    function _verifyPacket(bytes calldata _packetHeader, bytes calldata _packet) internal view override returns(bytes32 sourceIdentifier, bytes memory implementationIdentifier, bytes calldata message_) {
-        _assertHeader(_packetHeader);
+    function _verifyPacket(bytes calldata /* _packetHeader */, bytes calldata _packet) view internal override returns(bytes32 sourceIdentifier, bytes memory implementationIdentifier, bytes calldata message_) {
+        _assertHeader(_packet.header());
 
         // Check that we are the receiver
-        address receiver = _packetHeader.receiverB20();
+        address receiver = _packet.receiverB20();
         if (receiver != address(this)) revert IncorrectDestination(receiver);
 
         // Get the source chain.
-        uint32 srcEid = _packetHeader.srcEid();
+        uint32 srcEid = _packet.srcEid();
 
-        bytes32 _headerHash = keccak256(_packetHeader);
+        bytes32 _headerHash = keccak256(_packet);
         bytes32 _payloadHash = _packet.payloadHash();
 
         // The ULN may not be constant since it depends on the srcEid. :(
@@ -213,6 +213,7 @@ contract IncentivizedLayerZeroEscrow is IncentivizedMessageEscrow, ExecutorZero
         if (!verifyable) {
             // LayerZero may have migrated to a new receive library. Check the timeout receive library.
             (address timeoutULN, ) = ENDPOINT.defaultReceiveLibraryTimeout(srcEid);
+            if (timeoutULN == address(0)) revert LZ_ULN_Verifying();
             ULN = IReceiveUlnBase(timeoutULN);
             verifyable = ULN.verifiable(_config, _headerHash, _payloadHash);
             if (!verifyable) revert LZ_ULN_Verifying();
@@ -221,7 +222,7 @@ contract IncentivizedLayerZeroEscrow is IncentivizedMessageEscrow, ExecutorZero
         // Get the source chain
         sourceIdentifier = bytes32(uint256(srcEid));
         // Get the sender
-        implementationIdentifier = abi.encode(_packetHeader.sender());
+        implementationIdentifier = abi.encode(_packet.sender());
         // Get the message
         message_ = _packet.message();
     }
@@ -258,10 +259,7 @@ contract IncentivizedLayerZeroEscrow is IncentivizedMessageEscrow, ExecutorZero
         require(allowExternalCall != 1, "Do not send ether to this address");
     }
 
-
     function _assertHeader(bytes calldata _packetHeader) internal view {
-        // assert packet header is of right size 81
-        if (_packetHeader.length != 81) revert LZ_ULN_InvalidPacketHeader();
         // assert packet header version is the same as ULN
         if (_packetHeader.version() != PacketV1Codec.PACKET_VERSION) revert LZ_ULN_InvalidPacketVersion();
         // assert the packet is for this endpoint

test/layerzero/LZCommon.t.sol

@@ -49,7 +49,7 @@ contract LZCommon is Test {
 
         // Set ULN Config
         UlnConfig memory baseConfig = UlnConfig({
-            confirmations: 0,
+            confirmations: 1,
             requiredDVNCount: 1,
             optionalDVNCount: 0,
             optionalDVNThreshold: 0,

test/layerzero/TestLZVerifyPacket.t.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.22;
+
+import { LZCommon } from "./LZCommon.t.sol";
+
+import { Packet } from "LayerZero-v2/protocol/contracts/interfaces/ISendLib.sol";
+import { PacketV1Codec } from "LayerZero-v2/protocol/contracts/messagelib/libs/PacketV1Codec.sol";
+import { GUID } from "LayerZero-v2/protocol/contracts/libs/GUID.sol";
+
+contract TestLZVerifyPacket is LZCommon {
+    using PacketV1Codec for bytes;
+    using PacketV1Codec for Packet;
+
+    event ExecutorFeePaid(address executor, uint256 fee);
+    event PacketSent(bytes encodedPayload, bytes options, address sendLibrary);
+
+    function _set_init_config() internal {
+        uint32[] memory remoteEids = new uint32[](2);
+        remoteEids[0] = remoteEid;
+        remoteEids[1] = localEid;
+
+        address sendLibrary = endpoint.getSendLibrary(address(layerZeroEscrow), remoteEid);
+        layerZeroEscrow.initConfig(sendLibrary, remoteEids);
+    }
+
+    function setUp() public override {
+        super.setUp();
+        _set_init_config();
+    }
+
+    function test_revert_verify_packet_no_proof(bytes calldata message) external {
+        vm.assume(message.length > 0);
+        address target = address(layerZeroEscrow);
+
+        uint64 nonce = 1;
+        uint32 dstEid = localEid;
+        bytes32 receiver = bytes32(uint256(uint160(target)));
+        address sender = address(layerZeroEscrow);
+        
+        bytes32 guid = GUID.generate(nonce, localEid, sender, dstEid, receiver);
+
+        Packet memory packet = Packet({
+            nonce: nonce,
+            srcEid: remoteEid,
+            sender: sender,
+            dstEid: dstEid,
+            receiver: receiver,
+            guid: guid,
+            message: message
+        });
+
+        bytes memory _packet = PacketV1Codec.encode(packet);
+
+        vm.expectRevert(abi.encodeWithSignature("LZ_ULN_Verifying()"));
+        layerZeroEscrow.verifyPacket(hex"", _packet);
+    }
+
+    function test_verify_packet(bytes calldata message) external {
+        vm.assume(message.length > 0);
+        address target = address(layerZeroEscrow);
+
+        uint64 nonce = 1;
+        uint32 dstEid = localEid;
+        bytes32 receiver = bytes32(uint256(uint160(target)));
+        address sender = address(layerZeroEscrow);
+        
+        bytes32 guid = GUID.generate(nonce, localEid, sender, dstEid, receiver);
+
+        Packet memory packet = Packet({
+            nonce: nonce,
+            srcEid: remoteEid,
+            sender: sender,
+            dstEid: dstEid,
+            receiver: receiver,
+            guid: guid,
+            message: message
+        });
+
+        bytes memory _packet = packet.encode();
+
+        bytes32 ph = this.payloadHash(packet.encode());
+    
+        vm.prank(address(mockDVN));
+        receiveULN.verify(
+            packet.encodePacketHeader(),
+            ph,
+            10
+        );
+
+        layerZeroEscrow.verifyPacket(hex"", _packet);
+    }
+
+    function payloadHash(bytes calldata pl) pure public returns(bytes32) {
+        return pl.payloadHash();
+    }
+}

test/layerzero/mock/MockLayerZeroEscrow.sol

@@ -10,7 +10,7 @@ contract MockLayerZeroEscrow is IncentivizedLayerZeroEscrow {
 
     constructor(address sendLostGasTo, address lzEndpointV2) IncentivizedLayerZeroEscrow(sendLostGasTo, lzEndpointV2) {}
 
-    function verifyPacket(bytes calldata _packetHeader, bytes calldata _packet) external view returns(bytes32 sourceIdentifier, bytes memory implementationIdentifier, bytes calldata message_) {
+    function verifyPacket(bytes calldata _packetHeader, bytes calldata _packet) view external returns(bytes32 sourceIdentifier, bytes memory implementationIdentifier, bytes calldata message_) {
         return _verifyPacket(_packetHeader, _packet);
     }