Replaces "bare" with named parameters in struct constructor calls. (#35)

2023-01-13 17:27:59 -03:00 · 2023-01-13 17:27:59 -03:00 · 4a57a6c371
parent f8a75595b8
commit 4a57a6c371
6 changed files with 167 additions and 128 deletions
--- a/ethereum/contracts/coreRelayer/CoreRelayer.sol
+++ b/ethereum/contracts/coreRelayer/CoreRelayer.sol
@ -23,7 +23,11 @@ contract CoreRelayer is CoreRelayerGovernance {
    {
        DeliveryRequest[] memory requests = new DeliveryRequest[](1);
        requests[0] = request;
-        DeliveryRequestsContainer memory container = DeliveryRequestsContainer(1, address(provider), requests);
+        DeliveryRequestsContainer memory container = DeliveryRequestsContainer({
+            payloadId: 1,
+            relayProviderAddress: address(provider),
+            requests: requests
+        });
        return requestMultidelivery(container, nonce);
    }

@ -32,7 +36,11 @@ contract CoreRelayer is CoreRelayerGovernance {
    {
        DeliveryRequest[] memory requests = new DeliveryRequest[](1);
        requests[0] = request;
-        DeliveryRequestsContainer memory container = DeliveryRequestsContainer(1, address(provider), requests);
+        DeliveryRequestsContainer memory container = DeliveryRequestsContainer({
+            payloadId: 1,
+            relayProviderAddress: address(provider),
+            requests: requests
+        });
        return requestMultiforward(container, rolloverChain, nonce);
    }

@ -49,9 +57,14 @@ contract CoreRelayer is CoreRelayerGovernance {
            bool isSufficient,
            string memory reason
        ) = verifyFunding(
-            VerifyFundingCalculation(
-                provider, chainId(), request.targetChain, request.newComputeBudget, request.newApplicationBudget, false
-            )
+            VerifyFundingCalculation({
+                provider: provider,
+                sourceChain: chainId(),
+                targetChain: request.targetChain,
+                computeBudgetSource: request.newComputeBudget,
+                applicationBudgetSource: request.newApplicationBudget,
+                isDelivery: false
+            })
        );
        require(isSufficient, reason);
        uint256 totalFee = requestFee + wormhole().messageFee();
@ -139,7 +152,13 @@ contract CoreRelayer is CoreRelayerGovernance {
        verifyForwardingRequest(deliveryRequests, rolloverChain, nonce);

        bytes memory encodedDeliveryRequestsContainer = encodeDeliveryRequestsContainer(deliveryRequests);
-        setForwardingRequest(ForwardingRequest(encodedDeliveryRequestsContainer, rolloverChain, nonce, msg.value, true));
+        setForwardingRequest(ForwardingRequest({
+            deliveryRequestsContainer: encodedDeliveryRequestsContainer,
+            rolloverChain: rolloverChain,
+            nonce: nonce,
+            msgValue: msg.value,
+            isValid: true
+        }));
    }

    function emitForward(uint256 refundAmount) internal returns (uint64, bool) {
@ -245,9 +264,14 @@ contract CoreRelayer is CoreRelayerGovernance {
                bool isSufficient,
                string memory reason
            ) = verifyFunding(
-                VerifyFundingCalculation(
-                    provider, chainId(), request.targetChain, request.computeBudget, request.applicationBudget, true
-                )
+                VerifyFundingCalculation({
+                    provider: provider,
+                    sourceChain: chainId(),
+                    targetChain: request.targetChain,
+                    computeBudgetSource: request.computeBudget,
+                    applicationBudgetSource: request.applicationBudget,
+                    isDelivery: true
+                })
            );

            if (!isSufficient) {
--- a/ethereum/contracts/coreRelayer/CoreRelayerMessages.sol
+++ b/ethereum/contracts/coreRelayer/CoreRelayerMessages.sol
@ -101,7 +101,11 @@ contract CoreRelayerMessages is CoreRelayerStructs, CoreRelayerGetters {

        require(index == encoded.length, "invalid delivery instructions payload");

-        return DeliveryInstructionsContainer(payloadId, sufficientlyFunded, instructionArray);
+        return DeliveryInstructionsContainer({
+            payloadId: payloadId,
+            sufficientlyFunded: sufficientlyFunded,
+            instructions: instructionArray
+        });
    }

    function encodeDeliveryRequestsContainer(DeliveryRequestsContainer memory container)
@ -183,6 +187,10 @@ contract CoreRelayerMessages is CoreRelayerStructs, CoreRelayerGetters {

        require(index == encoded.length, "invalid delivery requests payload");

-        return DeliveryRequestsContainer(payloadId, relayProviderAddress, requestArray);
+        return DeliveryRequestsContainer({
+            payloadId: payloadId,
+            relayProviderAddress: relayProviderAddress,
+            requests: requestArray
+        });
    }
 }
--- a/ethereum/contracts/example_integrations/xMint/Hub.sol
+++ b/ethereum/contracts/example_integrations/xMint/Hub.sol
@ -96,14 +96,14 @@ contract XmintHub is ERC20, IWormholeReceiver {
        );
        uint256 applicationBudget = 0;

-        ICoreRelayer.DeliveryRequest memory request = ICoreRelayer.DeliveryRequest(
-            targetChain, //target chain
-            trustedContracts[targetChain], //target address
-            intendedRecipient, //refund address. All remaining funds will be returned to the user now
-            computeBudget, //compute budget
-            applicationBudget, //application budget, not needed in this case.
-            core_relayer.getDefaultRelayParams() //no overrides
-        );
+        ICoreRelayer.DeliveryRequest memory request = ICoreRelayer.DeliveryRequest({
+            targetChain: targetChain,
+            targetAddress: trustedContracts[targetChain],
+            refundAddress: intendedRecipient, // All remaining funds will be returned to the user now
+            computeBudget: computeBudget,
+            applicationBudget: applicationBudget, // not needed in this case.
+            relayParameters: core_relayer.getDefaultRelayParams() //no overrides
+        });

        core_relayer.requestDelivery{value: computeBudget + applicationBudget}(
            request, nonce, core_relayer.getDefaultRelayProvider()
--- a/ethereum/contracts/example_integrations/xMint/Spoke.sol
+++ b/ethereum/contracts/example_integrations/xMint/Spoke.sol
@ -93,14 +93,14 @@ contract XmintSpoke is IWormholeReceiver {
        );
        uint256 applicationBudget = 0;

-        ICoreRelayer.DeliveryRequest memory request = ICoreRelayer.DeliveryRequest(
-            hub_contract_chain, //target chain
-            hub_contract_address, //target address
-            hub_contract_address, //refund address, This will be ignored on the target chain because the intent is to perform a forward
-            computeBudget, //compute budget
-            applicationBudget, //application budget, not needed in this case.
-            core_relayer.getDefaultRelayParams() //no overrides
-        );
+        ICoreRelayer.DeliveryRequest memory request = ICoreRelayer.DeliveryRequest({
+            targetChain: hub_contract_chain,
+            targetAddress: hub_contract_address,
+            refundAddress: hub_contract_address, // This will be ignored on the target chain because the intent is to perform a forward
+            computeBudget: computeBudget,
+            applicationBudget: applicationBudget, // not needed in this case.
+            relayParameters: core_relayer.getDefaultRelayParams() //no overrides
+        });

        core_relayer.requestDelivery{value: computeBudget + applicationBudget}(
            request, nonce, core_relayer.getDefaultRelayProvider()
--- a/ethereum/contracts/mock/MockRelayerIntegration.sol
+++ b/ethereum/contracts/mock/MockRelayerIntegration.sol
@ -70,14 +70,14 @@ contract MockRelayerIntegration is IWormholeReceiver {
    ) internal {
        wormhole.publishMessage{value: wormhole.messageFee()}(nonce, fullMessage, 200);

-        ICoreRelayer.DeliveryRequest memory request = ICoreRelayer.DeliveryRequest(
-            targetChainId, //target chain
-            relayer.toWormholeFormat(address(destination)), //target address
-            relayer.toWormholeFormat(address(refundAddress)), //refund address, This will be ignored on the target chain if the intent is to perform a forward
-            msg.value - 2 * wormhole.messageFee(), //compute budget
-            applicationBudget, //application budget, not needed in this case.
-            relayer.getDefaultRelayParams() //no overrides
-        );
+        ICoreRelayer.DeliveryRequest memory request = ICoreRelayer.DeliveryRequest({
+            targetChain: targetChainId,
+            targetAddress: relayer.toWormholeFormat(address(destination)),
+            refundAddress: relayer.toWormholeFormat(address(refundAddress)), // This will be ignored on the target chain if the intent is to perform a forward
+            computeBudget: msg.value - 2 * wormhole.messageFee(),
+            applicationBudget: applicationBudget, // not needed in this case.
+            relayParameters: relayer.getDefaultRelayParams() //no overrides
+        });

        relayer.requestDelivery{value: msg.value - wormhole.messageFee()}(
            request, nonce, relayer.getDefaultRelayProvider()
@ -104,14 +104,14 @@ contract MockRelayerIntegration is IWormholeReceiver {
                uint256 computeBudget =
                    relayer.quoteGasDeliveryFee(parsed.emitterChainId, 500000, relayer.getDefaultRelayProvider());

-                ICoreRelayer.DeliveryRequest memory request = ICoreRelayer.DeliveryRequest(
-                    parsed.emitterChainId,
-                    parsed.emitterAddress,
-                    parsed.emitterAddress,
-                    computeBudget,
-                    0,
-                    relayer.getDefaultRelayParams()
-                );
+                ICoreRelayer.DeliveryRequest memory request = ICoreRelayer.DeliveryRequest({
+                    targetChain: parsed.emitterChainId,
+                    targetAddress: parsed.emitterAddress,
+                    refundAddress: parsed.emitterAddress,
+                    computeBudget: computeBudget,
+                    applicationBudget: 0,
+                    relayParameters: relayer.getDefaultRelayParams()
+                });

                relayer.requestForward(request, parsed.emitterChainId, parsed.nonce, relayer.getDefaultRelayProvider());
            }
--- a/ethereum/forge-test/CoreRelayer.t.sol
+++ b/ethereum/forge-test/CoreRelayer.t.sol
@ -414,15 +414,15 @@ contract TestCoreRelayer is Test {

        bytes32 deliveryVaaHash = vm.getRecordedLogs()[0].data.toBytes32(0);

-        ICoreRelayer.RedeliveryByTxHashRequest memory redeliveryRequest = ICoreRelayer.RedeliveryByTxHashRequest(
-            SOURCE_CHAIN_ID,
-            deliveryVaaHash,
-            1,
-            TARGET_CHAIN_ID,
-            payment - source.wormhole.messageFee(),
-            0,
-            source.coreRelayer.getDefaultRelayParams()
-        );
+        ICoreRelayer.RedeliveryByTxHashRequest memory redeliveryRequest = ICoreRelayer.RedeliveryByTxHashRequest({
+            sourceChain: SOURCE_CHAIN_ID,
+            sourceTxHash: deliveryVaaHash,
+            sourceNonce: 1,
+            targetChain: TARGET_CHAIN_ID,
+            newComputeBudget: payment - source.wormhole.messageFee(),
+            newApplicationBudget: 0,
+            newRelayParameters: source.coreRelayer.getDefaultRelayParams()
+        });

        source.coreRelayer.requestRedelivery{value: payment}(redeliveryRequest, 1, source.relayProvider);

@ -544,15 +544,15 @@ contract TestCoreRelayer is Test {
        stack.payment =
            source.coreRelayer.quoteGasDeliveryFee(TARGET_CHAIN_ID, gasParams.targetGasLimit, source.relayProvider);

-        stack.redeliveryRequest = ICoreRelayer.RedeliveryByTxHashRequest(
-            SOURCE_CHAIN_ID,
-            stack.deliveryVaaHash,
-            1,
-            TARGET_CHAIN_ID,
-            stack.payment - source.wormhole.messageFee(),
-            0,
-            source.coreRelayer.getDefaultRelayParams()
-        );
+        stack.redeliveryRequest = ICoreRelayer.RedeliveryByTxHashRequest({
+            sourceChain: SOURCE_CHAIN_ID,
+            sourceTxHash: stack.deliveryVaaHash,
+            sourceNonce: 1,
+            targetChain: TARGET_CHAIN_ID,
+            newComputeBudget: stack.payment - source.wormhole.messageFee(),
+            newApplicationBudget: 0,
+            newRelayParameters: source.coreRelayer.getDefaultRelayParams()
+        });

        vm.expectRevert(bytes("1"));
        source.coreRelayer.requestRedelivery{value: stack.payment - 1}(stack.redeliveryRequest, 1, source.relayProvider);
@ -572,12 +572,12 @@ contract TestCoreRelayer is Test {
        change(fakeVM, fakeVM.length - 1);
        stack.originalDelivery.encodedVMs[1] = fakeVM;

-        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle(
-            stack.redeliveryVM,
-            stack.originalDelivery.encodedVMs,
-            stack.originalDelivery.deliveryIndex,
-            stack.originalDelivery.multisendIndex
-        );
+        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
+            redeliveryVM: stack.redeliveryVM,
+            sourceEncodedVMs: stack.originalDelivery.encodedVMs,
+            deliveryIndex: stack.originalDelivery.deliveryIndex,
+            multisendIndex: stack.originalDelivery.multisendIndex
+        });

        stack.parsed = relayerWormhole.parseVM(stack.redeliveryVM);
        stack.instruction = target.coreRelayer.getRedeliveryByTxHashInstruction(stack.parsed.payload);
@ -591,12 +591,12 @@ contract TestCoreRelayer is Test {

        stack.originalDelivery.encodedVMs[1] = stack.originalDelivery.encodedVMs[0];

-        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle(
-            stack.redeliveryVM,
-            stack.originalDelivery.encodedVMs,
-            stack.originalDelivery.deliveryIndex,
-            stack.originalDelivery.multisendIndex
-        );
+        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
+            redeliveryVM: stack.redeliveryVM,
+            sourceEncodedVMs: stack.originalDelivery.encodedVMs,
+            deliveryIndex: stack.originalDelivery.deliveryIndex,
+            multisendIndex: stack.originalDelivery.multisendIndex
+        });

        vm.prank(target.relayer);
        vm.expectRevert(bytes("10"));
@ -604,23 +604,23 @@ contract TestCoreRelayer is Test {

        stack.originalDelivery.encodedVMs[1] = correctVM;

-        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle(
-            stack.redeliveryVM,
-            stack.originalDelivery.encodedVMs,
-            stack.originalDelivery.deliveryIndex,
-            stack.originalDelivery.multisendIndex
-        );
+        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
+            redeliveryVM: stack.redeliveryVM,
+            sourceEncodedVMs: stack.originalDelivery.encodedVMs,
+            deliveryIndex: stack.originalDelivery.deliveryIndex,
+            multisendIndex: stack.originalDelivery.multisendIndex
+        });

        correctVM = abi.encodePacked(stack.redeliveryVM);
        fakeVM = abi.encodePacked(correctVM);
        change(fakeVM, fakeVM.length - 1);

-        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle(
-            fakeVM,
-            stack.originalDelivery.encodedVMs,
-            stack.originalDelivery.deliveryIndex,
-            stack.originalDelivery.multisendIndex
-        );
+        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
+            redeliveryVM: fakeVM,
+            sourceEncodedVMs: stack.originalDelivery.encodedVMs,
+            deliveryIndex: stack.originalDelivery.deliveryIndex,
+            multisendIndex: stack.originalDelivery.multisendIndex
+        });

        vm.prank(target.relayer);
        vm.expectRevert(bytes("11"));
@ -629,12 +629,12 @@ contract TestCoreRelayer is Test {
        fakeVM = relayerWormholeSimulator.fetchSignedMessageFromLogs(
            stack.entries[0], SOURCE_CHAIN_ID, address(source.integration)
        );
-        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle(
-            fakeVM,
-            stack.originalDelivery.encodedVMs,
-            stack.originalDelivery.deliveryIndex,
-            stack.originalDelivery.multisendIndex
-        );
+        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
+            redeliveryVM: fakeVM,
+            sourceEncodedVMs: stack.originalDelivery.encodedVMs,
+            deliveryIndex: stack.originalDelivery.deliveryIndex,
+            multisendIndex: stack.originalDelivery.multisendIndex
+        });

        vm.prank(target.relayer);
        vm.expectRevert(bytes("12"));
@ -649,23 +649,23 @@ contract TestCoreRelayer is Test {
        fakeVM = relayerWormholeSimulator.fetchSignedMessageFromLogs(
            stack.entries[0], SOURCE_CHAIN_ID, address(source.coreRelayer)
        );
-        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle(
-            fakeVM,
-            stack.originalDelivery.encodedVMs,
-            stack.originalDelivery.deliveryIndex,
-            stack.originalDelivery.multisendIndex
-        );
+        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
+            redeliveryVM: fakeVM,
+            sourceEncodedVMs: stack.originalDelivery.encodedVMs,
+            deliveryIndex: stack.originalDelivery.deliveryIndex,
+            multisendIndex: stack.originalDelivery.multisendIndex
+        });

        vm.prank(target.relayer);
        vm.expectRevert(bytes("13"));
        target.coreRelayer.redeliverSingle{value: stack.budget}(stack.package);

-        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle(
-            stack.redeliveryVM,
-            stack.originalDelivery.encodedVMs,
-            stack.originalDelivery.deliveryIndex,
-            stack.originalDelivery.multisendIndex
-        );
+        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
+            redeliveryVM: stack.redeliveryVM,
+            sourceEncodedVMs: stack.originalDelivery.encodedVMs,
+            deliveryIndex: stack.originalDelivery.deliveryIndex,
+            multisendIndex: stack.originalDelivery.multisendIndex
+        });

        vm.expectRevert(bytes("14"));
        target.coreRelayer.redeliverSingle{value: stack.budget}(stack.package);
@ -680,15 +680,15 @@ contract TestCoreRelayer is Test {
        vm.prank(target.relayer);
        map[differentChainId].coreRelayer.redeliverSingle{value: stack.budget}(stack.package);

-        stack.redeliveryRequest = ICoreRelayer.RedeliveryByTxHashRequest(
-            SOURCE_CHAIN_ID,
-            stack.deliveryVaaHash,
-            1,
-            differentChainId,
-            stack.payment - source.wormhole.messageFee(),
-            0,
-            source.coreRelayer.getDefaultRelayParams()
-        );
+        stack.redeliveryRequest = ICoreRelayer.RedeliveryByTxHashRequest({
+            sourceChain: SOURCE_CHAIN_ID,
+            sourceTxHash: stack.deliveryVaaHash,
+            sourceNonce: 1,
+            targetChain: differentChainId,
+            newComputeBudget: stack.payment - source.wormhole.messageFee(),
+            newApplicationBudget: 0,
+            newRelayParameters: source.coreRelayer.getDefaultRelayParams()
+        });
        source.relayProvider.updatePrice(differentChainId, gasParams.targetGasPrice, gasParams.targetNativePrice);
        source.relayProvider.updatePrice(differentChainId, gasParams.sourceGasPrice, gasParams.sourceNativePrice);
        source.relayProvider.updateDeliveryAddress(differentChainId, bytes32(uint256(uint160(address(target.relayer)))));
@ -702,23 +702,23 @@ contract TestCoreRelayer is Test {
        fakeVM = relayerWormholeSimulator.fetchSignedMessageFromLogs(
            stack.entries[0], SOURCE_CHAIN_ID, address(source.coreRelayer)
        );
-        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle(
-            fakeVM,
-            stack.originalDelivery.encodedVMs,
-            stack.originalDelivery.deliveryIndex,
-            stack.originalDelivery.multisendIndex
-        );
+        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
+            redeliveryVM: fakeVM,
+            sourceEncodedVMs: stack.originalDelivery.encodedVMs,
+            deliveryIndex: stack.originalDelivery.deliveryIndex,
+            multisendIndex: stack.originalDelivery.multisendIndex
+        });

        vm.expectRevert(bytes("16"));
        vm.prank(target.relayer);
        map[differentChainId].coreRelayer.redeliverSingle{value: stack.budget}(stack.package);

-        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle(
-            correctVM,
-            stack.originalDelivery.encodedVMs,
-            stack.originalDelivery.deliveryIndex,
-            stack.originalDelivery.multisendIndex
-        );
+        stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
+            redeliveryVM: correctVM,
+            sourceEncodedVMs: stack.originalDelivery.encodedVMs,
+            deliveryIndex: stack.originalDelivery.deliveryIndex,
+            multisendIndex: stack.originalDelivery.multisendIndex
+        });

        vm.expectRevert(bytes("17"));
        vm.prank(target.relayer);
@ -1034,7 +1034,11 @@ contract TestCoreRelayer is Test {
                uint256 budget =
                    container.instructions[k].maximumRefundTarget + container.instructions[k].applicationBudgetTarget;
                ICoreRelayer.TargetDeliveryParametersSingle memory package =
-                    ICoreRelayer.TargetDeliveryParametersSingle(deliveryInstructions, counter, k);
+                    ICoreRelayer.TargetDeliveryParametersSingle({
+                        encodedVMs: deliveryInstructions,
+                        deliveryIndex: counter,
+                        multisendIndex: k
+                    });
                uint16 targetChain = container.instructions[k].targetChain;
                uint256 wormholeFee = map[targetChain].wormhole.messageFee();
                vm.prank(map[targetChain].relayer);
@ -1051,9 +1055,12 @@ contract TestCoreRelayer is Test {
                + map[targetChain].wormhole.messageFee();

            ICoreRelayer.TargetRedeliveryByTxHashParamsSingle memory package = ICoreRelayer
-                .TargetRedeliveryByTxHashParamsSingle(
-                encodedVM, originalDelivery.encodedVMs, originalDelivery.deliveryIndex, originalDelivery.multisendIndex
-            );
+                .TargetRedeliveryByTxHashParamsSingle({
+                redeliveryVM: encodedVM,
+                sourceEncodedVMs: originalDelivery.encodedVMs,
+                deliveryIndex: originalDelivery.deliveryIndex,
+                multisendIndex: originalDelivery.multisendIndex
+            });

            vm.prank(map[targetChain].relayer);
            map[targetChain].coreRelayer.redeliverSingle{value: budget}(package);