evm: Update endpoint instruction handling (#180)

* evm: Update endpoint instruction handling

* evm: forge formatting

Author: djb15

evm/src/Manager.sol

@@ -227,8 +227,7 @@ contract Manager is
         revert CannotRenounceManagerOwnership(owner());
     }
 
-    /// @dev This will either cross-call or internal call, depending on whether the contract is standalone or not.
-    ///      This method should return an array of delivery prices corresponding to each endpoint.
+    /// @dev This method should return an array of delivery prices corresponding to each endpoint.
     function quoteDeliveryPrice(
         uint16 recipientChain,
         EndpointStructs.EndpointInstruction[] memory endpointInstructions,
@@ -251,8 +250,6 @@ contract Manager is
         return (priceQuotes, totalPriceQuote);
     }
 
-    /// @dev This will either cross-call or internal call, depending on
-    /// whether the contract is standalone or not.
     function _sendMessageToEndpoints(
         uint16 recipientChain,
         uint256[] memory priceQuotes,
@@ -420,12 +417,6 @@ contract Manager is
             revert InvalidRecipient();
         }
 
-        // parse the instructions up front to ensure they:
-        // - are encoded correctly
-        // - follow payload length restrictions
-
-        EndpointStructs.parseEndpointInstructions(endpointInstructions);
-
         {
             // Lock/burn tokens before checking rate limits
             if (mode == Mode.LOCKING) {
@@ -530,15 +521,14 @@ contract Manager is
         address sender,
         bytes memory endpointInstructions
     ) internal returns (uint64 msgSequence) {
-        // parse and reorganize the endpoint instructions based on index
-        EndpointStructs.EndpointInstruction[] memory sortedInstructions = EndpointStructs
-            .sortEndpointInstructions(EndpointStructs.parseEndpointInstructions(endpointInstructions));
-
         // cache enabled endpoints to avoid multiple storage reads
         address[] memory enabledEndpoints = _getEnabledEndpointsStorage();
 
+        EndpointStructs.EndpointInstruction[] memory instructions =
+            EndpointStructs.parseEndpointInstructions(endpointInstructions, enabledEndpoints.length);
+
         (uint256[] memory priceQuotes, uint256 totalPriceQuote) =
-            quoteDeliveryPrice(recipientChain, sortedInstructions, enabledEndpoints);
+            quoteDeliveryPrice(recipientChain, instructions, enabledEndpoints);
         {
             // check up front that msg.value will cover the delivery price
             if (msg.value < totalPriceQuote) {
@@ -567,7 +557,7 @@ contract Manager is
 
         // send the message
         _sendMessageToEndpoints(
-            recipientChain, priceQuotes, sortedInstructions, enabledEndpoints, encodedManagerPayload
+            recipientChain, priceQuotes, instructions, enabledEndpoints, encodedManagerPayload
         );
 
         emit TransferSent(recipient, nttDenormalize(amount), recipientChain, sequence);

evm/src/libraries/EndpointStructs.sol

@@ -10,6 +10,7 @@ library EndpointStructs {
 
     error PayloadTooLong(uint256 size);
     error IncorrectPrefix(bytes4 prefix);
+    error UnorderedInstructions();
 
     /// @dev Prefix for all NativeTokenTransfer payloads
     ///      This is 0x99'N''T''T'
@@ -307,50 +308,47 @@ library EndpointStructs {
         if (instructions.length > type(uint8).max) {
             revert PayloadTooLong(instructions.length);
         }
-        uint8 instructionsLength = uint8(instructions.length);
+        uint256 instructionsLength = instructions.length;
 
         bytes memory encoded;
-        for (uint8 i = 0; i < instructionsLength; i++) {
+        for (uint256 i = 0; i < instructionsLength; i++) {
             bytes memory innerEncoded = encodeEndpointInstruction(instructions[i]);
             encoded = bytes.concat(encoded, innerEncoded);
         }
-        return abi.encodePacked(instructionsLength, encoded);
+        return abi.encodePacked(uint8(instructionsLength), encoded);
     }
 
-    function parseEndpointInstructions(bytes memory encoded)
-        public
-        pure
-        returns (EndpointInstruction[] memory)
-    {
+    function parseEndpointInstructions(
+        bytes memory encoded,
+        uint256 numEnabledEndpoints
+    ) public pure returns (EndpointInstruction[] memory) {
         uint256 offset = 0;
-        uint8 instructionsLength;
+        uint256 instructionsLength;
         (instructionsLength, offset) = encoded.asUint8Unchecked(offset);
-        EndpointInstruction[] memory instructions = new EndpointInstruction[](instructionsLength);
 
-        for (uint8 i = 0; i < instructionsLength; i++) {
+        // We allocate an array with the length of the number of enabled endpoints
+        // This gives us the flexibility to not have to pass instructions for endpoints that
+        // don't need them
+        EndpointInstruction[] memory instructions = new EndpointInstruction[](numEnabledEndpoints);
+
+        uint256 lastIndex = 0;
+        for (uint256 i = 0; i < instructionsLength; i++) {
             EndpointInstruction memory instruction;
             (instruction, offset) = parseEndpointInstructionUnchecked(encoded, offset);
-            instructions[i] = instruction;
+
+            uint8 instructionIndex = instruction.index;
+
+            // The instructions passed in have to be strictly increasing in terms of endpoint index
+            if (i != 0 && instructionIndex <= lastIndex) {
+                revert UnorderedInstructions();
+            }
+            lastIndex = instructionIndex;
+
+            instructions[instructionIndex] = instruction;
         }
 
         encoded.checkLength(offset);
 
         return instructions;
     }
-
-    /*
-    * @dev This function takes a list of EndpointInstructions and expands them to a 256-length list,
-    *      inserting each instruction into the expanded list based on `instruction.index`.
-    */
-    function sortEndpointInstructions(EndpointInstruction[] memory instructions)
-        public
-        pure
-        returns (EndpointInstruction[] memory)
-    {
-        EndpointInstruction[] memory sortedInstructions = new EndpointInstruction[](type(uint8).max);
-        for (uint8 i = 0; i < instructions.length; i++) {
-            sortedInstructions[instructions[i].index] = instructions[i];
-        }
-        return sortedInstructions;
-    }
 }