feat: save gas by calling verifyable directly

src/apps/layerzero/IncentivizedLayerZeroEscrow.sol

@@ -5,21 +5,20 @@ import { IncentivizedMessageEscrow } from "../../IncentivizedMessageEscrow.sol";
 import { ILayerZeroEndpointV2, MessagingParams, MessagingFee } from "./interfaces/ILayerZeroEndpointV2.sol";
 import { PacketV1Codec } from "./libs/PacketV1Codec.sol";
 import { UlnConfig } from "./interfaces/IUlnBase.sol";
-import { SimpleLZULN } from "./SimpleLZULN.sol";
+import { IReceiveUlnBase, UlnConfig, Verification } from "./interfaces/IUlnBase.sol";
 
 /**
  * @notice LayerZero escrow.
  * TODO: Set config such that we are the executor.
- * TODO: Figure out if we can verify
- *      If not, then figure out how to decode the payload and then do both the composer and the executor step in 1.
  */
-abstract contract BareIncentivizedLayerZeroEscrow is IncentivizedMessageEscrow, SimpleLZULN {
+abstract contract BareIncentivizedLayerZeroEscrow is IncentivizedMessageEscrow {
     using PacketV1Codec for bytes;
 
     error LayerZeroCannotBeAddress0();
     error LZ_ULN_Verifying();
 
     ILayerZeroEndpointV2 immutable ENDPOINT;
+    IReceiveUlnBase immutable ULTRA_LIGHT_NODE;
 
     // TODO: Are these values packed?
     uint128 excessPaid = 1; // Set to 1 so we never have to pay zero to non-zero cost.
@@ -29,10 +28,11 @@ abstract contract BareIncentivizedLayerZeroEscrow is IncentivizedMessageEscrow,
     uint32 public immutable chainId;
     address private constant DEFAULT_CONFIG = address(0);
 
-    constructor(address sendLostGasTo, address lzEndpointV2, address ULN) IncentivizedMessageEscrow(sendLostGasTo) SimpleLZULN(ULN) {
+    constructor(address sendLostGasTo, address lzEndpointV2, address ULN) IncentivizedMessageEscrow(sendLostGasTo) {
         if (lzEndpointV2 == address(0)) revert LayerZeroCannotBeAddress0();
         ENDPOINT = ILayerZeroEndpointV2(lzEndpointV2);
         chainId  = ENDPOINT.eid();
+        ULTRA_LIGHT_NODE = IReceiveUlnBase(ULN);
         // TODO: Set executor as this contract.
     }
 
@@ -76,8 +76,8 @@ abstract contract BareIncentivizedLayerZeroEscrow is IncentivizedMessageEscrow,
 
         bytes32 _headerHash = keccak256(_packetHeader);
         bytes32 _payloadHash = keccak256(_payload);
-        if (!_checkVerifiable(srcEid, _headerHash, _payloadHash)) revert LZ_ULN_Verifying();
-
+        UlnConfig memory _config = ULTRA_LIGHT_NODE.getUlnConfig(address(this), srcEid);
+        if (ULTRA_LIGHT_NODE.verifiable(_config, _headerHash, _payloadHash)) revert LZ_ULN_Verifying();
 
         // TODO: everything below.
         // Load the identifier for the calling contract.

src/apps/layerzero/SimpleLZULN.sol

@@ -13,53 +13,4 @@ contract SimpleLZULN {
         ULTRA_LIGHT_NODE = IReceiveUlnBase(ULN);
     }
 
-    /// @dev for verifiable view function
-    /// @dev checks if this verification is ready to be committed to the endpoint
-    function _checkVerifiable(
-        uint32 _srcEid,
-        bytes32 _headerHash,
-        bytes32 _payloadHash
-    ) internal view returns (bool) {
-        UlnConfig memory _config = ULTRA_LIGHT_NODE.getUlnConfig(address(this), _srcEid);
-        // iterate the required DVNs
-        if (_config.requiredDVNCount > 0) {
-            for (uint8 i = 0; i < _config.requiredDVNCount; ++i) {
-                if (!_verified(_config.requiredDVNs[i], _headerHash, _payloadHash, _config.confirmations)) {
-                    // return if any of the required DVNs haven't signed
-                    return false;
-                }
-            }
-            if (_config.optionalDVNCount == 0) {
-                // returns early if all required DVNs have signed and there are no optional DVNs
-                return true;
-            }
-        }
-
-        // then it must require optional validations
-        uint8 threshold = _config.optionalDVNThreshold;
-        for (uint8 i = 0; i < _config.optionalDVNCount; ++i) {
-            if (_verified(_config.optionalDVNs[i], _headerHash, _payloadHash, _config.confirmations)) {
-                // increment the optional count if the optional DVN has signed
-                threshold--;
-                if (threshold == 0) {
-                    // early return if the optional threshold has hit
-                    return true;
-                }
-            }
-        }
-
-        // return false as a catch-all
-        return false;
-    }
-
-    function _verified(
-        address _dvn,
-        bytes32 _headerHash,
-        bytes32 _payloadHash,
-        uint64 _requiredConfirmation
-    ) internal view returns (bool verified) {
-        Verification memory verification = ULTRA_LIGHT_NODE.hashLookup(_headerHash, _payloadHash, _dvn);
-        // return true if the dvn has signed enough confirmations
-        verified = verification.submitted && verification.confirmations >= _requiredConfirmation;
-    }
 }

src/apps/layerzero/interfaces/IUlnBase.sol

@@ -20,8 +20,11 @@ struct Verification {
 }
 
 interface IReceiveUlnBase {
-    // mapping(bytes32 headerHash => mapping(bytes32 payloadHash => mapping(address dvn => Verification))) public hashLookup;
-    function hashLookup(bytes32 headerHash, bytes32 payloadHash, address dvn) external view returns (Verification memory);
+    function verifiable(
+        UlnConfig memory _config,
+        bytes32 _headerHash,
+        bytes32 _payloadHash
+    ) external view returns (bool);
 
     function getUlnConfig(address _oapp, uint32 _remoteEid) external view returns (UlnConfig memory rtnConfig);
 }