redelivery test changes

2023-03-13 16:55:55 +00:00 · 2023-03-13 16:55:55 +00:00 · f0cb171533
parent 4f3a603839
commit f0cb171533
3 changed files with 15 additions and 424 deletions
--- a/ethereum/forge-test/CoreRelayer.t.sol
+++ b/ethereum/forge-test/CoreRelayer.t.sol
@ -135,6 +135,7 @@ contract TestCoreRelayer is Test {
    struct StandardSetupTwoChains {
        uint16 sourceChainId;
        uint16 targetChainId;
+        uint16 differentChainId;
        Contracts source;
        Contracts target;
    }
@ -182,6 +183,7 @@ contract TestCoreRelayer is Test {

        s.sourceChainId = 1;
        s.targetChainId = 2;
+        s.differentChainId = 3;
        s.source = map[s.sourceChainId];
        s.target = map[s.targetChainId];

@ -833,416 +835,8 @@ contract TestCoreRelayer is Test {
        INVALID_REDELIVERY
    }

-    function testRevertResendMsgValueTooLow(
-        GasParameters memory gasParams,
-        FeeParameters memory feeParams,
-        bytes memory message
-    ) public {
-        StandardSetupTwoChains memory setup = standardAssumeAndSetupTwoChains(gasParams, feeParams, 1000000);
+  

-        vm.recordLogs();
-
-        RedeliveryStackTooDeep memory stack;
-
-        setup.source.integration.sendMessageWithRefundAddress{
-            value: setup.source.coreRelayer.quoteGas(setup.targetChainId, 21000, address(setup.source.relayProvider))
-                + uint256(3) * setup.source.wormhole.messageFee()
-        }(message, setup.targetChainId, address(setup.target.integration), address(setup.target.refundAddress));
-
-        genericRelayer.relay(setup.sourceChainId);
-
-        assertTrue(
-            (keccak256(setup.target.integration.getMessage()) != keccak256(message))
-                || (keccak256(message) == keccak256(bytes("")))
-        );
-
-        stack.deliveryVaaHash = getDeliveryVAAHash();
-
-        stack.payment = setup.source.coreRelayer.quoteGas(
-            setup.targetChainId, gasParams.targetGasLimit, address(setup.source.relayProvider)
-        ) + setup.source.wormhole.messageFee();
-
-        stack.redeliveryRequest = IWormholeRelayer.ResendByTx({
-            sourceChain: setup.sourceChainId,
-            sourceTxHash: stack.deliveryVaaHash,
-            sourceNonce: 1,
-            targetChain: setup.targetChainId,
-            deliveryIndex: 2,
-            multisendIndex: 0,
-            newMaxTransactionFee: stack.payment - setup.source.wormhole.messageFee(),
-            newReceiverValue: 0,
-            newRelayParameters: setup.source.coreRelayer.getDefaultRelayParams()
-        });
-        vm.deal(address(this), stack.payment);
-        vm.expectRevert(abi.encodeWithSignature("MsgValueTooLow()"));
-        setup.source.coreRelayer.resend{value: stack.payment - 1}(
-            stack.redeliveryRequest, address(setup.source.relayProvider)
-        );
-
-    }
-
-    function testRevertRedeliveryInvalidOriginalDeliveryVaa(
-        GasParameters memory gasParams,
-        FeeParameters memory feeParams,
-        bytes memory message
-    ) public {
-        StandardSetupTwoChains memory setup = standardAssumeAndSetupTwoChains(gasParams, feeParams, 1000000);
-
-        vm.recordLogs();
-
-        RedeliveryStackTooDeep memory stack;
-
-        setup.source.integration.sendMessageWithRefundAddress{
-            value: setup.source.coreRelayer.quoteGas(setup.targetChainId, 21000, address(setup.source.relayProvider))
-                + uint256(3) * setup.source.wormhole.messageFee()
-        }(message, setup.targetChainId, address(setup.target.integration), address(setup.target.refundAddress));
-
-        genericRelayer.relay(setup.sourceChainId);
-
-        assertTrue(
-            (keccak256(setup.target.integration.getMessage()) != keccak256(message))
-                || (keccak256(message) == keccak256(bytes("")))
-        );
-
-        stack.deliveryVaaHash = getDeliveryVAAHash();
-
-        stack.payment = setup.source.coreRelayer.quoteGas(
-            setup.targetChainId, gasParams.targetGasLimit, address(setup.source.relayProvider)
-        ) + setup.source.wormhole.messageFee();
-
-        stack.redeliveryRequest = IWormholeRelayer.ResendByTx({
-            sourceChain: setup.sourceChainId,
-            sourceTxHash: stack.deliveryVaaHash,
-            sourceNonce: 1,
-            targetChain: setup.targetChainId,
-            deliveryIndex: 2,
-            multisendIndex: 0,
-            newMaxTransactionFee: stack.payment - setup.source.wormhole.messageFee(),
-            newReceiverValue: 0,
-            newRelayParameters: setup.source.coreRelayer.getDefaultRelayParams()
-        });
-        vm.deal(address(this), stack.payment);
-
-        setup.source.coreRelayer.resend{value: stack.payment}(
-            stack.redeliveryRequest, address(setup.source.relayProvider)
-        );
-
-        stack.entries = vm.getRecordedLogs();
-
-        stack.redeliveryVM = relayerWormholeSimulator.fetchSignedMessageFromLogs(
-            stack.entries[0], setup.sourceChainId, address(setup.source.coreRelayer)
-        );
-
-        stack.originalEncodedVMs = genericRelayer.getPastEncodedVMs(stack.deliveryVaaHash);
-
-        bytes memory fakeVM = abi.encodePacked(stack.originalEncodedVMs[2]);
-        invalidateVM(fakeVM, setup.target.wormholeSimulator);
-        stack.originalEncodedVMs[2] = fakeVM;
-
-        stack.package = IDelivery.TargetRedeliveryByTxHashParamsSingle(
-            stack.redeliveryVM, stack.originalEncodedVMs, payable(setup.target.relayer)
-        );
-
-        stack.parsed = relayerWormhole.parseVM(stack.redeliveryVM);
-        stack.instruction = setup.target.coreRelayerFull.decodeRedeliveryInstruction(stack.parsed.payload);
-
-        stack.budget = stack.instruction.newMaximumRefundTarget + stack.instruction.newReceiverValueTarget
-            + setup.target.wormhole.messageFee();
-
-        vm.deal(setup.target.relayer, stack.budget);
-
-        vm.prank(setup.target.relayer);
-        vm.expectRevert(abi.encodeWithSignature("InvalidVaa(uint8,string)", 2, ""));
-        setup.target.coreRelayerFull.redeliverSingle{value: stack.budget}(stack.package);
-
-    }
-
-    function testRevertRedeliveryInvalidEmitterInOriginalDeliveryVaa(
-        GasParameters memory gasParams,
-        FeeParameters memory feeParams,
-        bytes memory message
-    ) public {
-        StandardSetupTwoChains memory setup = standardAssumeAndSetupTwoChains(gasParams, feeParams, 1000000);
-
-        vm.recordLogs();
-
-        RedeliveryStackTooDeep memory stack;
-
-        setup.source.integration.sendMessageWithRefundAddress{
-            value: setup.source.coreRelayer.quoteGas(setup.targetChainId, 21000, address(setup.source.relayProvider))
-                + uint256(3) * setup.source.wormhole.messageFee()
-        }(message, setup.targetChainId, address(setup.target.integration), address(setup.target.refundAddress));
-
-        genericRelayer.relay(setup.sourceChainId);
-
-        assertTrue(
-            (keccak256(setup.target.integration.getMessage()) != keccak256(message))
-                || (keccak256(message) == keccak256(bytes("")))
-        );
-
-        stack.deliveryVaaHash = getDeliveryVAAHash();
-
-        stack.payment = setup.source.coreRelayer.quoteGas(
-            setup.targetChainId, gasParams.targetGasLimit, address(setup.source.relayProvider)
-        ) + setup.source.wormhole.messageFee();
-
-        stack.redeliveryRequest = IWormholeRelayer.ResendByTx({
-            sourceChain: setup.sourceChainId,
-            sourceTxHash: stack.deliveryVaaHash,
-            sourceNonce: 1,
-            targetChain: setup.targetChainId,
-            deliveryIndex: 2,
-            multisendIndex: 0,
-            newMaxTransactionFee: stack.payment - setup.source.wormhole.messageFee(),
-            newReceiverValue: 0,
-            newRelayParameters: setup.source.coreRelayer.getDefaultRelayParams()
-        });
-
-        setup.source.coreRelayer.resend{value: stack.payment}(
-            stack.redeliveryRequest, address(setup.source.relayProvider)
-        );
-
-        stack.entries = vm.getRecordedLogs();
-
-        stack.redeliveryVM = relayerWormholeSimulator.fetchSignedMessageFromLogs(
-            stack.entries[0], setup.sourceChainId, address(setup.source.coreRelayer)
-        );
-
-        stack.originalEncodedVMs = genericRelayer.getPastEncodedVMs(stack.deliveryVaaHash);
-
-
-        stack.package = IDelivery.TargetRedeliveryByTxHashParamsSingle(
-            stack.redeliveryVM, stack.originalEncodedVMs, payable(setup.target.relayer)
-        );
-
-        stack.parsed = relayerWormhole.parseVM(stack.redeliveryVM);
-        stack.instruction = setup.target.coreRelayerFull.decodeRedeliveryInstruction(stack.parsed.payload);
-
-        stack.budget = stack.instruction.newMaximumRefundTarget + stack.instruction.newReceiverValueTarget
-            + setup.target.wormhole.messageFee();
-
-        stack.originalEncodedVMs[2] = stack.originalEncodedVMs[0];
-
-        stack.package = IDelivery.TargetRedeliveryByTxHashParamsSingle(
-            stack.redeliveryVM, stack.originalEncodedVMs, payable(setup.target.relayer)
-        );
-
-        vm.prank(setup.target.relayer);
-        vm.expectRevert(abi.encodeWithSignature("InvalidEmitterInOriginalDeliveryVM(uint8)", 2));
-        setup.target.coreRelayerFull.redeliverSingle{value: stack.budget}(stack.package);
-    }
-
-    function testRevertRedeliveryInvalidRedeliveryVaa(
-        GasParameters memory gasParams,
-        FeeParameters memory feeParams,
-        bytes memory message
-    ) public {
-        StandardSetupTwoChains memory setup = standardAssumeAndSetupTwoChains(gasParams, feeParams, 1000000);
-
-        vm.recordLogs();
-
-        RedeliveryStackTooDeep memory stack;
-
-        setup.source.integration.sendMessageWithRefundAddress{
-            value: setup.source.coreRelayer.quoteGas(setup.targetChainId, 21000, address(setup.source.relayProvider))
-                + uint256(3) * setup.source.wormhole.messageFee()
-        }(message, setup.targetChainId, address(setup.target.integration), address(setup.target.refundAddress));
-
-        genericRelayer.relay(setup.sourceChainId);
-
-        assertTrue(
-            (keccak256(setup.target.integration.getMessage()) != keccak256(message))
-                || (keccak256(message) == keccak256(bytes("")))
-        );
-
-        stack.deliveryVaaHash = getDeliveryVAAHash();
-
-        stack.payment = setup.source.coreRelayer.quoteGas(
-            setup.targetChainId, gasParams.targetGasLimit, address(setup.source.relayProvider)
-        ) + setup.source.wormhole.messageFee();
-
-        stack.redeliveryRequest = IWormholeRelayer.ResendByTx({
-            sourceChain: setup.sourceChainId,
-            sourceTxHash: stack.deliveryVaaHash,
-            sourceNonce: 1,
-            targetChain: setup.targetChainId,
-            deliveryIndex: 2,
-            multisendIndex: 0,
-            newMaxTransactionFee: stack.payment - setup.source.wormhole.messageFee(),
-            newReceiverValue: 0,
-            newRelayParameters: setup.source.coreRelayer.getDefaultRelayParams()
-        });
-
-        setup.source.coreRelayer.resend{value: stack.payment}(
-            stack.redeliveryRequest, address(setup.source.relayProvider)
-        );
-
-        stack.entries = vm.getRecordedLogs();
-
-        stack.redeliveryVM = relayerWormholeSimulator.fetchSignedMessageFromLogs(
-            stack.entries[0], setup.sourceChainId, address(setup.source.coreRelayer)
-        );
-
-        stack.originalEncodedVMs = genericRelayer.getPastEncodedVMs(stack.deliveryVaaHash);
-
-        stack.parsed = relayerWormhole.parseVM(stack.redeliveryVM);
-        stack.instruction = setup.target.coreRelayerFull.decodeRedeliveryInstruction(stack.parsed.payload);
-
-        stack.budget = stack.instruction.newMaximumRefundTarget + stack.instruction.newReceiverValueTarget
-            + setup.target.wormhole.messageFee();
-
-        bytes memory fakeVM = abi.encodePacked(stack.redeliveryVM);
-        invalidateVM(fakeVM, setup.target.wormholeSimulator);
-
-        stack.package = IDelivery.TargetRedeliveryByTxHashParamsSingle(
-            fakeVM, stack.originalEncodedVMs, payable(setup.target.relayer)
-        );
-
-        vm.prank(setup.target.relayer);
-        vm.expectRevert(abi.encodeWithSignature("InvalidRedeliveryVM(string)", ""));
-        setup.target.coreRelayerFull.redeliverSingle{value: stack.budget}(stack.package);
-    }
-
-    function testRevertRedeliveryInvalidEmitterInRedeliveryVM(
-        GasParameters memory gasParams,
-        FeeParameters memory feeParams,
-        bytes memory message
-    ) public {
-        StandardSetupTwoChains memory setup = standardAssumeAndSetupTwoChains(gasParams, feeParams, 1000000);
-
-        vm.recordLogs();
-
-        RedeliveryStackTooDeep memory stack;
-
-        setup.source.integration.sendMessageWithRefundAddress{
-            value: setup.source.coreRelayer.quoteGas(setup.targetChainId, 21000, address(setup.source.relayProvider))
-                + uint256(3) * setup.source.wormhole.messageFee()
-        }(message, setup.targetChainId, address(setup.target.integration), address(setup.target.refundAddress));
-
-        genericRelayer.relay(setup.sourceChainId);
-
-        assertTrue(
-            (keccak256(setup.target.integration.getMessage()) != keccak256(message))
-                || (keccak256(message) == keccak256(bytes("")))
-        );
-
-        stack.deliveryVaaHash = getDeliveryVAAHash();
-
-        stack.originalEncodedVMs = genericRelayer.getPastEncodedVMs(stack.deliveryVaaHash);
-
-        stack.payment = setup.source.coreRelayer.quoteGas(
-            setup.targetChainId, gasParams.targetGasLimit, address(setup.source.relayProvider)
-        ) + setup.source.wormhole.messageFee();
-
-        stack.redeliveryRequest = IWormholeRelayer.ResendByTx({
-            sourceChain: setup.sourceChainId,
-            sourceTxHash: stack.deliveryVaaHash,
-            sourceNonce: 1,
-            targetChain: setup.targetChainId,
-            deliveryIndex: 2,
-            multisendIndex: 0,
-            newMaxTransactionFee: stack.payment - setup.source.wormhole.messageFee(),
-            newReceiverValue: 0,
-            newRelayParameters: setup.source.coreRelayer.getDefaultRelayParams()
-        });
-
-        setup.source.coreRelayer.resend{value: stack.payment}(
-            stack.redeliveryRequest, address(setup.source.relayProvider)
-        );
-
-        stack.entries = vm.getRecordedLogs();
-
-        stack.redeliveryVM = relayerWormholeSimulator.fetchSignedMessageFromLogs(
-            stack.entries[0], setup.sourceChainId, address(setup.source.coreRelayer)
-        );
-
-        stack.package = IDelivery.TargetRedeliveryByTxHashParamsSingle(
-            stack.redeliveryVM, stack.originalEncodedVMs, payable(setup.target.relayer)
-        );
-
-        stack.parsed = relayerWormhole.parseVM(stack.redeliveryVM);
-        stack.instruction = setup.target.coreRelayerFull.decodeRedeliveryInstruction(stack.parsed.payload);
-
-        stack.budget = stack.instruction.newMaximumRefundTarget + stack.instruction.newReceiverValueTarget
-            + setup.target.wormhole.messageFee();
-
-
-        bytes memory fakeVM = relayerWormholeSimulator.fetchSignedMessageFromLogs(
-            stack.entries[0], setup.sourceChainId, address(setup.source.integration)
-        );
-        
-        stack.package = IDelivery.TargetRedeliveryByTxHashParamsSingle(
-            fakeVM, stack.originalEncodedVMs, payable(setup.target.relayer)
-        );
-
-        vm.prank(setup.target.relayer);
-        vm.expectRevert(abi.encodeWithSignature("InvalidEmitterInRedeliveryVM()"));
-        setup.target.coreRelayerFull.redeliverSingle{value: stack.budget}(stack.package);
-
-    }
-
-    function testRevertRedeliveryMismatchingRelayProviderDeliveryAddresses(
-        GasParameters memory gasParams,
-        FeeParameters memory feeParams,
-        bytes memory message
-    ) public {
-        StandardSetupTwoChains memory setup = standardAssumeAndSetupTwoChains(gasParams, feeParams, 1000000);
-
-        vm.recordLogs();
-
-        RedeliveryStackTooDeep memory stack;
-
-        setup.source.integration.sendMessageWithRefundAddress{
-            value: setup.source.coreRelayer.quoteGas(setup.targetChainId, 21000, address(setup.source.relayProvider))
-                + uint256(3) * setup.source.wormhole.messageFee()
-        }(message, setup.targetChainId, address(setup.target.integration), address(setup.target.refundAddress));
-
-        genericRelayer.relay(setup.sourceChainId);
-
-        assertTrue(
-            (keccak256(setup.target.integration.getMessage()) != keccak256(message))
-                || (keccak256(message) == keccak256(bytes("")))
-        );
-
-        stack.deliveryVaaHash = getDeliveryVAAHash();
-
-        stack.originalEncodedVMs = genericRelayer.getPastEncodedVMs(stack.deliveryVaaHash);
-
-        stack.payment = setup.source.coreRelayer.quoteGas(
-            setup.targetChainId, gasParams.targetGasLimit, address(setup.source.relayProvider)
-        ) + setup.source.wormhole.messageFee();
-
-        stack.redeliveryRequest = IWormholeRelayer.ResendByTx({
-            sourceChain: setup.sourceChainId,
-            sourceTxHash: stack.deliveryVaaHash,
-            sourceNonce: 1,
-            targetChain: setup.targetChainId,
-            deliveryIndex: 2,
-            multisendIndex: 0,
-            newMaxTransactionFee: stack.payment - setup.source.wormhole.messageFee(),
-            newReceiverValue: 0,
-            newRelayParameters: setup.source.coreRelayer.getDefaultRelayParams()
-        });
-
-        setup.source.relayProvider.updateDeliveryAddress(setup.targetChainId, bytes32(uint256(uint160(address(this)))));
-        vm.deal(address(this), stack.payment);
-        vm.getRecordedLogs();
-        setup.source.coreRelayer.resend{value: stack.payment}(
-            stack.redeliveryRequest, address(setup.source.relayProvider)
-        );
-        stack.entries = vm.getRecordedLogs();
-
-        stack.redeliveryVM = relayerWormholeSimulator.fetchSignedMessageFromLogs(
-            stack.entries[0], setup.sourceChainId, address(setup.source.coreRelayer)
-        );
-        stack.package = IDelivery.TargetRedeliveryByTxHashParamsSingle(
-            stack.redeliveryVM, stack.originalEncodedVMs, payable(setup.target.relayer)
-        );
-
-        vm.prank(setup.target.relayer);
-        vm.expectRevert(abi.encodeWithSignature("MismatchingRelayProvidersInRedelivery()"));
-        setup.target.coreRelayerFull.redeliverSingle{value: stack.budget}(stack.package);
-    }

    /**
     * Delivery 18-24
--- a/ethereum/forge-test/IWormholeRelayerInstructionParser.sol
+++ b/ethereum/forge-test/IWormholeRelayerInstructionParser.sol
@ -3,7 +3,6 @@
 pragma solidity ^0.8.0;

 interface IWormholeRelayerInstructionParser {
-
    struct DeliveryInstructionsContainer {
        uint8 payloadId; //1
        bool sufficientlyFunded;
@ -51,5 +50,4 @@ interface IWormholeRelayerInstructionParser {
    function toWormholeFormat(address addr) external pure returns (bytes32 whFormat);

    function fromWormholeFormat(bytes32 whFormatAddress) external pure returns (address addr);
-
-}
+}
--- a/ethereum/forge-test/MockGenericRelayer.sol
+++ b/ethereum/forge-test/MockGenericRelayer.sol
@ -10,7 +10,6 @@ import {WormholeSimulator} from "./WormholeSimulator.sol";
 import "../contracts/libraries/external/BytesLib.sol";
 import "forge-std/Vm.sol";

-
 contract MockGenericRelayer {
    using BytesLib for bytes;

@ -18,8 +17,7 @@ contract MockGenericRelayer {
    WormholeSimulator relayerWormholeSimulator;
    IWormholeRelayerInstructionParser parser;

-    address constant private VM_ADDRESS =
-        address(bytes20(uint160(uint256(keccak256('hevm cheat code')))));
+    address private constant VM_ADDRESS = address(bytes20(uint160(uint256(keccak256("hevm cheat code")))));

    Vm public constant vm = Vm(VM_ADDRESS);

@ -28,7 +26,7 @@ contract MockGenericRelayer {
    mapping(uint16 => address) relayers;

    mapping(uint16 => uint256) wormholeFees;
-    
+
    mapping(uint256 => bool) nonceCompleted;

    mapping(bytes32 => bytes[]) pastEncodedVMs;
@ -50,7 +48,7 @@ contract MockGenericRelayer {
    }

    function setProviderDeliveryAddress(uint16 chainId, address deliveryAddress) public {
-         relayers[chainId] = deliveryAddress;
+        relayers[chainId] = deliveryAddress;
    }

    function setWormholeFee(uint16 chainId, uint256 fee) public {
@ -126,20 +124,21 @@ contract MockGenericRelayer {
                    multisendIndex: k,
                    relayerRefundAddress: payable(relayers[targetChain])
                });
-                if(container.sufficientlyFunded) {
+                if (container.sufficientlyFunded) {
                    vm.prank(relayers[targetChain]);
-                    IDelivery(wormholeRelayerContracts[targetChain]).deliverSingle{value: (budget + wormholeFees[targetChain])}(package);
-                } 
+                    IDelivery(wormholeRelayerContracts[targetChain]).deliverSingle{
+                        value: (budget + wormholeFees[targetChain])
+                    }(package);
+                }
            }
            pastEncodedVMs[parsedInstruction.hash] = encodedVMsToBeDelivered;
        } else if (payloadId == 2) {
            IWormholeRelayerInstructionParser.RedeliveryByTxHashInstruction memory instruction =
                parser.decodeRedeliveryInstruction(parsedInstruction.payload);
-            bytes[] memory originalEncodedVMs =
-                pastEncodedVMs[instruction.sourceTxHash];
+            bytes[] memory originalEncodedVMs = pastEncodedVMs[instruction.sourceTxHash];
            uint16 targetChain = instruction.targetChain;
-            uint256 budget = instruction.newMaximumRefundTarget + instruction.newReceiverValueTarget
-                + wormholeFees[targetChain];
+            uint256 budget =
+                instruction.newMaximumRefundTarget + instruction.newReceiverValueTarget + wormholeFees[targetChain];
            IDelivery.TargetRedeliveryByTxHashParamsSingle memory package = IDelivery
                .TargetRedeliveryByTxHashParamsSingle({
                redeliveryVM: encodedDeliveryInstructionsContainer,