certusone
/
trustless-generic-relayer
mirror of https://github.com/certusone/trustless-generic-relayer.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Save Gas: Remove Relay Protection on deliverSingle and redeliverSingle (#45) 

* Remove replay protection on deliverSingle and redeliverSingle

* forge fmt

* redelivery fixes, events & relayer refund address

* Got tests passing again (still have to alter a few redelivery tests to validate the new emitted error)

* forge fmt

* Attempt at fixing typescript error

* Forge fmt

* Add indexed

* Fix tests to correctly obtain deliveryVaaHash due to new event structure

* forge fmt

Co-authored-by: chase-45 <chasemoran45@gmail.com>
This commit is contained in:
derpy-duck 2023-01-19 14:38:52 -05:00 committed by GitHub
parent 1e14fe901f
commit 546fc1969e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 140 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

133
ethereum/contracts/coreRelayer/CoreRelayer.sol
View File

@ -8,9 +8,30 @@ import "../libraries/external/BytesLib.sol";
import "./CoreRelayerGovernance.sol";
import "./CoreRelayerStructs.sol";
import "forge-std/console.sol";
contract CoreRelayer is CoreRelayerGovernance {
using BytesLib for bytes;
event DeliverySuccess(
bytes32 indexed deliveryVaaHash, address indexed recipientContract, uint16 sourceChain, uint64 indexed sequence
);
event DeliveryFailure(
bytes32 indexed deliveryVaaHash, address indexed recipientContract, uint16 sourceChain, uint64 indexed sequence
);
event ForwardRequestFailure(
bytes32 indexed deliveryVaaHash, address indexed recipientContract, uint16 sourceChain, uint64 indexed sequence
);
event ForwardRequestSuccess(
bytes32 indexed deliveryVaaHash, address indexed recipientContract, uint16 sourceChain, uint64 indexed sequence
);
event InvalidRedelivery(
bytes32 indexed redeliveryVaaHash,
address indexed recipientContract,
uint16 sourceChain,
uint64 indexed sequence
);
error InsufficientFunds(string reason);
error MsgValueTooLow(); // msg.value must cover the budget specified
error NonceIsZero();
@ -37,11 +58,6 @@ contract CoreRelayer is CoreRelayerGovernance {
error SrcNativeCurrencyPriceIsZero();
error DstNativeCurrencyPriceIsZero();
event DeliverySuccess(bytes32 deliveryVaaHash, address recipientContract);
event DeliveryFailure(bytes32 deliveryVaaHash, address recipientContract);
event ForwardRequestFailure(bytes32 deliveryVaaHash, address recipientContract);
event ForwardRequestSuccess(bytes32 deliveryVaaHash, address recipientContract);
function requestDelivery(DeliveryRequest memory request, uint32 nonce, IRelayProvider provider)
public
payable
@ -383,8 +399,11 @@ contract CoreRelayer is CoreRelayerGovernance {
IWormhole wormhole,
DeliveryInstruction memory internalInstruction,
bytes[] memory encodedVMs,
bytes32 deliveryVaaHash
) internal returns (uint64 sequence) {
bytes32 deliveryVaaHash,
address payable relayerRefund,
uint16 sourceChain,
uint64 sourceSequence
) internal {
//REVISE Decide whether we want to remove the DeliveryInstructionContainer from encodedVMs.
// lock the contract to prevent reentrancy
@ -429,9 +448,11 @@ contract CoreRelayer is CoreRelayerGovernance {
// wormhole.publishMessage{value: wormhole.messageFee()}(0, encodeDeliveryStatus(status), consistencyLevel());
if (getForwardingRequest().isValid) {
(sequence, success) = emitForward(weiToRefund);
(, success) = emitForward(weiToRefund);
if (success) {
emit ForwardRequestSuccess(deliveryVaaHash, fromWormholeFormat(internalInstruction.targetAddress));
emit ForwardRequestSuccess(
deliveryVaaHash, fromWormholeFormat(internalInstruction.targetAddress), sourceChain, sourceSequence
);
} else {
(bool sent,) = fromWormholeFormat(internalInstruction.refundAddress).call{value: weiToRefund}("");
@ -439,7 +460,9 @@ contract CoreRelayer is CoreRelayerGovernance {
// if refunding fails, pay out full refund to relayer
weiToRefund = 0;
}
emit ForwardRequestFailure(deliveryVaaHash, fromWormholeFormat(internalInstruction.targetAddress));
emit ForwardRequestFailure(
deliveryVaaHash, fromWormholeFormat(internalInstruction.targetAddress), sourceChain, sourceSequence
);
}
} else {
(bool sent,) = fromWormholeFormat(internalInstruction.refundAddress).call{value: weiToRefund}("");
@ -450,9 +473,13 @@ contract CoreRelayer is CoreRelayerGovernance {
}
if (success) {
emit DeliverySuccess(deliveryVaaHash, fromWormholeFormat(internalInstruction.targetAddress));
emit DeliverySuccess(
deliveryVaaHash, fromWormholeFormat(internalInstruction.targetAddress), sourceChain, sourceSequence
);
} else {
emit DeliveryFailure(deliveryVaaHash, fromWormholeFormat(internalInstruction.targetAddress));
emit DeliveryFailure(
deliveryVaaHash, fromWormholeFormat(internalInstruction.targetAddress), sourceChain, sourceSequence
);
}
}
@ -460,7 +487,7 @@ contract CoreRelayer is CoreRelayerGovernance {
uint256 wormholeFeePaid = getForwardingRequest().isValid ? wormhole.messageFee() : 0;
uint256 relayerRefundAmount = msg.value - weiToRefund - applicationBudgetPaid - wormholeFeePaid;
// refund the rest to relayer
msg.sender.call{value: relayerRefundAmount}("");
relayerRefund.call{value: relayerRefundAmount}("");
}
//REVISE, consider implementing this system into the RelayProvider.
@ -511,11 +538,7 @@ contract CoreRelayer is CoreRelayerGovernance {
return defaultRelayProvider();
}
function redeliverSingle(TargetRedeliveryByTxHashParamsSingle memory targetParams)
public
payable
returns (uint64 sequence)
{
function redeliverSingle(TargetRedeliveryByTxHashParamsSingle memory targetParams) public payable {
//cache wormhole
IWormhole wormhole = wormhole();
@ -541,27 +564,40 @@ contract CoreRelayer is CoreRelayerGovernance {
revert InvalidEmitterInRedeliveryVM();
}
DeliveryInstruction memory instruction = validateRedeliverySingle(
DeliveryInstruction memory instruction;
(instruction, valid) = validateRedeliverySingle(
decodeRedeliveryByTxHashInstruction(redeliveryVM.payload),
decodeDeliveryInstructionsContainer(originalDeliveryVM.payload).instructions[targetParams.multisendIndex]
);
//redelivery request cannot have already been attempted
if (isDeliveryCompleted(redeliveryVM.hash)) {
revert AlreadyDelivered();
if (!valid) {
emit InvalidRedelivery(
redeliveryVM.hash,
fromWormholeFormat(instruction.targetAddress),
redeliveryVM.emitterChainId,
redeliveryVM.sequence
);
targetParams.relayerRefundAddress.send(msg.value);
return;
}
//mark redelivery as attempted
markAsDelivered(redeliveryVM.hash);
return _executeDelivery(wormhole, instruction, targetParams.sourceEncodedVMs, originalDeliveryVM.hash);
_executeDelivery(
wormhole,
instruction,
targetParams.sourceEncodedVMs,
originalDeliveryVM.hash,
targetParams.relayerRefundAddress,
originalDeliveryVM.emitterChainId,
originalDeliveryVM.sequence
);
}
function validateRedeliverySingle(
RedeliveryByTxHashInstruction memory redeliveryInstruction,
DeliveryInstruction memory originalInstruction
) internal view returns (DeliveryInstruction memory deliveryInstruction) {
) internal view returns (DeliveryInstruction memory deliveryInstruction, bool isValid) {
//All the same checks as delivery single, with a couple additional
isValid = true;
// The same relay provider must be specified when doing a single VAA redeliver.
address providerAddress = fromWormholeFormat(redeliveryInstruction.executionParameters.providerDeliveryAddress);
@ -569,19 +605,28 @@ contract CoreRelayer is CoreRelayerGovernance {
revert MismatchingRelayProvidersInRedelivery();
}
// msg.sender must be the provider
//msg.sender must be the provider
if (msg.sender != providerAddress) {
revert ProviderAddressIsNotSender();
isValid = false; //"Relay provider differed from the specified address");
}
//redelivery must target this chain
if (chainId() != redeliveryInstruction.targetChain) {
revert RedeliveryRequestDoesNotTargetThisChain();
isValid = false; //"Redelivery request does not target this chain.");
}
//original delivery request must target this chain
//original delivery must target this chain
if (chainId() != originalInstruction.targetChain) {
revert OriginalDeliveryRequestDidNotTargetThisChain();
isValid = false; //"Original delivery request did not target this chain.");
}
//computeBudget & applicationBudget must be at least as large as the initial delivery
if (originalInstruction.applicationBudgetTarget > redeliveryInstruction.newApplicationBudgetTarget) {
isValid = false; //new application budget is smaller than the original
}
if (originalInstruction.executionParameters.gasLimit > redeliveryInstruction.executionParameters.gasLimit) {
isValid = false; //new gasLimit is smaller than the original
}
//relayer must have covered the necessary funds
@ -600,11 +645,7 @@ contract CoreRelayer is CoreRelayerGovernance {
deliveryInstruction = originalInstruction;
}
function deliverSingle(TargetDeliveryParametersSingle memory targetParams)
public
payable
returns (uint64 sequence)
{
function deliverSingle(TargetDeliveryParametersSingle memory targetParams) public payable {
// cache wormhole instance
IWormhole wormhole = wormhole();
@ -641,20 +682,20 @@ contract CoreRelayer is CoreRelayerGovernance {
revert InsufficientRelayerFunds();
}
//make sure this has not already been delivered
if (isDeliveryCompleted(deliveryVM.hash)) {
revert AlreadyDelivered();
}
//mark as delivered, so it can't be reattempted
markAsDelivered(deliveryVM.hash);
//make sure this delivery is intended for this chain
if (chainId() != deliveryInstruction.targetChain) {
revert TargetChainIsNotThisChain(deliveryInstruction.targetChain);
}
return _executeDelivery(wormhole, deliveryInstruction, targetParams.encodedVMs, deliveryVM.hash);
_executeDelivery(
wormhole,
deliveryInstruction,
targetParams.encodedVMs,
deliveryVM.hash,
targetParams.relayerRefundAddress,
deliveryVM.emitterChainId,
deliveryVM.sequence
);
}
function toWormholeFormat(address addr) public pure returns (bytes32 whFormat) {

16
ethereum/contracts/coreRelayer/CoreRelayerGetters.sol
View File

@ -53,26 +53,10 @@ contract CoreRelayerGetters is CoreRelayerState {
return IRelayProvider(_state.defaultRelayProvider);
}
// function getSelectedRelayProvider(bytes memory relayerParams) internal view returns (IRelayProvider) {
// if(relayerParams.length == 0){
// return defaultRelayProvider();
// } else {
// require(relayerParams.length == 33, "Wrong length of relayerParams");
// if(relayerParams.toUint8(0) == 0) {
// return defaultRelayProvider();
// }
// return IRelayProvider(address(uint160(uint256(relayerParams.toBytes32(1)))));
// }
// }
function getForwardingRequest() internal view returns (CoreRelayerStructs.ForwardingRequest memory) {
return _state.forwardingRequest;
}
function isDeliveryCompleted(bytes32 deliveryHash) public view returns (bool) {
return _state.completedDeliveries[deliveryHash];
}
function isContractLocked() internal view returns (bool) {
return _state.contractLock;
}

4
ethereum/contracts/coreRelayer/CoreRelayerSetters.sol
View File

@ -50,10 +50,6 @@ contract CoreRelayerSetters is CoreRelayerState, Context {
delete _state.forwardingRequest; //TODO is this the best way to accomplish this?
}
function markAsDelivered(bytes32 deliveryHash) internal {
_state.completedDeliveries[deliveryHash] = true;
}
function setContractLock(bool status) internal {
_state.contractLock = status;
}

2
ethereum/contracts/coreRelayer/CoreRelayerState.sol
View File

@ -29,8 +29,6 @@ contract CoreRelayerStorage {
mapping(address => bool) initializedImplementations;
// mapping of relayer contracts on other chains
mapping(uint16 => bytes32) registeredCoreRelayerContract;
// mapping of delivered relayer VAAs
mapping(bytes32 => bool) completedDeliveries;
// storage gap to reduce risk of storage collisions
uint256[50] ______gap;
}

3
ethereum/contracts/coreRelayer/CoreRelayerStructs.sol
View File

@ -31,6 +31,8 @@ abstract contract CoreRelayerStructs {
uint8 deliveryIndex;
// Index of the target chain inside the delivery VM
uint8 multisendIndex;
// relayer refund address
address payable relayerRefundAddress;
}
// Optional gasOverride which can be supplied by the relayer
// uint32 targetCallGasOverride;
@ -40,6 +42,7 @@ abstract contract CoreRelayerStructs {
bytes[] sourceEncodedVMs;
uint8 deliveryIndex;
uint8 multisendIndex;
address payable relayerRefundAddress;
}
struct DeliveryRequest {

15
ethereum/contracts/interfaces/ICoreRelayer.sol
View File

@ -39,15 +39,9 @@ interface ICoreRelayer {
IRelayProvider provider
) external payable;
function deliverSingle(TargetDeliveryParametersSingle memory targetParams)
external
payable
returns (uint64 sequence);
function deliverSingle(TargetDeliveryParametersSingle memory targetParams) external payable;
function redeliverSingle(TargetRedeliveryByTxHashParamsSingle memory targetParams)
external
payable
returns (uint64 sequence);
function redeliverSingle(TargetRedeliveryByTxHashParamsSingle memory targetParams) external payable;
// function requestRewardPayout(uint16 rewardChain, bytes32 receiver, uint32 nonce) external payable returns (uint64 sequence);
@ -126,6 +120,8 @@ interface ICoreRelayer {
uint8 deliveryIndex;
// Index of the target chain inside the delivery VM
uint8 multisendIndex;
//refund address
address payable relayerRefundAddress;
}
// Optional gasOverride which can be supplied by the relayer
// uint32 targetCallGasOverride;
@ -137,6 +133,8 @@ interface ICoreRelayer {
uint8 deliveryIndex;
// Index of the target chain inside the delivery VM
uint8 multisendIndex;
//refund address
address payable relayerRefundAddress;
}
// Optional gasOverride which can be supplied by the relayer
// uint32 targetCallGasOverride;
@ -146,6 +144,7 @@ interface ICoreRelayer {
bytes[] sourceEncodedVMs;
uint8 deliveryIndex;
uint8 multisendIndex;
address payable relayerRefundAddress;
}
//REVISE consider removing this, or keeping for future compatibility

8
ethereum/contracts/relayProvider/RelayProvider.sol
View File

@ -95,19 +95,19 @@ contract RelayProvider is RelayProviderGovernance, IRelayProvider {
public
payable
onlyApprovedSender
returns (uint64 sequence)
{
ICoreRelayer cr = ICoreRelayer(coreRelayer());
return cr.redeliverSingle{value: msg.value}(targetParams);
targetParams.relayerRefundAddress = payable(msg.sender);
cr.redeliverSingle{value: msg.value}(targetParams);
}
function deliverSingle(ICoreRelayer.TargetDeliveryParametersSingle memory targetParams)
public
payable
onlyApprovedSender
returns (uint64 sequence)
{
ICoreRelayer cr = ICoreRelayer(coreRelayer());
return cr.deliverSingle{value: msg.value}(targetParams);
targetParams.relayerRefundAddress = payable(msg.sender);
cr.deliverSingle{value: msg.value}(targetParams);
}
}

54
ethereum/forge-test/CoreRelayer.t.sol
View File

@ -456,7 +456,7 @@ contract TestCoreRelayer is Test {
|| (keccak256(message) == keccak256(bytes("")))
);
bytes32 deliveryVaaHash = vm.getRecordedLogs()[0].data.toBytes32(0);
bytes32 deliveryVaaHash = vm.getRecordedLogs()[0].topics[1];
ICoreRelayer.RedeliveryByTxHashRequest memory redeliveryRequest = ICoreRelayer.RedeliveryByTxHashRequest({
sourceChain: SOURCE_CHAIN_ID,
@ -580,7 +580,7 @@ contract TestCoreRelayer is Test {
|| (keccak256(message) == keccak256(bytes("")))
);
stack.deliveryVaaHash = vm.getRecordedLogs()[0].data.toBytes32(0);
stack.deliveryVaaHash = vm.getRecordedLogs()[0].topics[1];
stack.payment =
source.coreRelayer.quoteGasDeliveryFee(TARGET_CHAIN_ID, gasParams.targetGasLimit, source.relayProvider);
@ -617,7 +617,8 @@ contract TestCoreRelayer is Test {
redeliveryVM: stack.redeliveryVM,
sourceEncodedVMs: stack.originalDelivery.encodedVMs,
deliveryIndex: stack.originalDelivery.deliveryIndex,
multisendIndex: stack.originalDelivery.multisendIndex
multisendIndex: stack.originalDelivery.multisendIndex,
relayerRefundAddress: payable(target.relayer)
});
stack.parsed = relayerWormhole.parseVM(stack.redeliveryVM);
@ -636,7 +637,8 @@ contract TestCoreRelayer is Test {
redeliveryVM: stack.redeliveryVM,
sourceEncodedVMs: stack.originalDelivery.encodedVMs,
deliveryIndex: stack.originalDelivery.deliveryIndex,
multisendIndex: stack.originalDelivery.multisendIndex
multisendIndex: stack.originalDelivery.multisendIndex,
relayerRefundAddress: payable(target.relayer)
});
vm.prank(target.relayer);
@ -649,7 +651,8 @@ contract TestCoreRelayer is Test {
redeliveryVM: stack.redeliveryVM,
sourceEncodedVMs: stack.originalDelivery.encodedVMs,
deliveryIndex: stack.originalDelivery.deliveryIndex,
multisendIndex: stack.originalDelivery.multisendIndex
multisendIndex: stack.originalDelivery.multisendIndex,
relayerRefundAddress: payable(target.relayer)
});
correctVM = abi.encodePacked(stack.redeliveryVM);
@ -660,7 +663,8 @@ contract TestCoreRelayer is Test {
redeliveryVM: fakeVM,
sourceEncodedVMs: stack.originalDelivery.encodedVMs,
deliveryIndex: stack.originalDelivery.deliveryIndex,
multisendIndex: stack.originalDelivery.multisendIndex
multisendIndex: stack.originalDelivery.multisendIndex,
relayerRefundAddress: payable(target.relayer)
});
vm.prank(target.relayer);
@ -674,7 +678,8 @@ contract TestCoreRelayer is Test {
redeliveryVM: fakeVM,
sourceEncodedVMs: stack.originalDelivery.encodedVMs,
deliveryIndex: stack.originalDelivery.deliveryIndex,
multisendIndex: stack.originalDelivery.multisendIndex
multisendIndex: stack.originalDelivery.multisendIndex,
relayerRefundAddress: payable(target.relayer)
});
vm.prank(target.relayer);
@ -694,9 +699,11 @@ contract TestCoreRelayer is Test {
redeliveryVM: fakeVM,
sourceEncodedVMs: stack.originalDelivery.encodedVMs,
deliveryIndex: stack.originalDelivery.deliveryIndex,
multisendIndex: stack.originalDelivery.multisendIndex
multisendIndex: stack.originalDelivery.multisendIndex,
relayerRefundAddress: payable(target.relayer)
});
/*
vm.prank(target.relayer);
vm.expectRevert(abi.encodeWithSignature("MismatchingRelayProvidersInRedelivery()"));
target.coreRelayer.redeliverSingle{value: stack.budget}(stack.package);
@ -705,7 +712,8 @@ contract TestCoreRelayer is Test {
redeliveryVM: stack.redeliveryVM,
sourceEncodedVMs: stack.originalDelivery.encodedVMs,
deliveryIndex: stack.originalDelivery.deliveryIndex,
multisendIndex: stack.originalDelivery.multisendIndex
multisendIndex: stack.originalDelivery.multisendIndex,
relayerRefundAddress: payable(msg.sender)
});
vm.expectRevert(abi.encodeWithSignature("ProviderAddressIsNotSender()"));
@ -747,18 +755,20 @@ contract TestCoreRelayer is Test {
redeliveryVM: fakeVM,
sourceEncodedVMs: stack.originalDelivery.encodedVMs,
deliveryIndex: stack.originalDelivery.deliveryIndex,
multisendIndex: stack.originalDelivery.multisendIndex
multisendIndex: stack.originalDelivery.multisendIndex,
relayerRefundAddress: payable(target.relayer)
});
vm.expectRevert(abi.encodeWithSignature("OriginalDeliveryRequestDidNotTargetThisChain()"));
vm.prank(target.relayer);
map[differentChainId].coreRelayer.redeliverSingle{value: stack.budget}(stack.package);
*/
stack.package = ICoreRelayer.TargetRedeliveryByTxHashParamsSingle({
redeliveryVM: correctVM,
sourceEncodedVMs: stack.originalDelivery.encodedVMs,
deliveryIndex: stack.originalDelivery.deliveryIndex,
multisendIndex: stack.originalDelivery.multisendIndex
multisendIndex: stack.originalDelivery.multisendIndex,
relayerRefundAddress: payable(target.relayer)
});
vm.expectRevert(abi.encodeWithSignature("InsufficientRelayerFunds()"));
@ -827,7 +837,7 @@ contract TestCoreRelayer is Test {
stack.encodedVMs[0] = stack.actualVM;
stack.encodedVMs[1] = stack.deliveryVM;
stack.package = ICoreRelayer.TargetDeliveryParametersSingle(stack.encodedVMs, 1, 0);
stack.package = ICoreRelayer.TargetDeliveryParametersSingle(stack.encodedVMs, 1, 0, payable(target.relayer));
stack.parsed = relayerWormhole.parseVM(stack.deliveryVM);
stack.instruction =
@ -876,7 +886,7 @@ contract TestCoreRelayer is Test {
stack.encodedVMs[0] = stack.actualVM;
stack.encodedVMs[1] = fakeVM;
stack.package = ICoreRelayer.TargetDeliveryParametersSingle(stack.encodedVMs, 1, 0);
stack.package = ICoreRelayer.TargetDeliveryParametersSingle(stack.encodedVMs, 1, 0, payable(target.relayer));
stack.parsed = relayerWormhole.parseVM(stack.deliveryVM);
stack.instruction = target.coreRelayer.getDeliveryInstructionsContainer(stack.parsed.payload).instructions[0];
@ -890,7 +900,7 @@ contract TestCoreRelayer is Test {
stack.encodedVMs[1] = stack.encodedVMs[0];
stack.package = ICoreRelayer.TargetDeliveryParametersSingle(stack.encodedVMs, 1, 0);
stack.package = ICoreRelayer.TargetDeliveryParametersSingle(stack.encodedVMs, 1, 0, payable(target.relayer));
vm.prank(target.relayer);
vm.expectRevert(abi.encodeWithSignature("InvalidEmitter()"));
@ -898,7 +908,7 @@ contract TestCoreRelayer is Test {
stack.encodedVMs[1] = stack.deliveryVM;
stack.package = ICoreRelayer.TargetDeliveryParametersSingle(stack.encodedVMs, 1, 0);
stack.package = ICoreRelayer.TargetDeliveryParametersSingle(stack.encodedVMs, 1, 0, payable(target.relayer));
vm.expectRevert(abi.encodeWithSignature("UnexpectedRelayer()"));
target.coreRelayer.deliverSingle{value: stack.budget}(stack.package);
@ -918,10 +928,6 @@ contract TestCoreRelayer is Test {
vm.prank(target.relayer);
target.coreRelayer.deliverSingle{value: stack.budget}(stack.package);
vm.prank(target.relayer);
vm.expectRevert(abi.encodeWithSignature("AlreadyDelivered()"));
target.coreRelayer.deliverSingle{value: stack.budget}(stack.package);
}
struct RequestDeliveryStackTooDeep {
@ -1072,12 +1078,13 @@ contract TestCoreRelayer is Test {
for (uint8 k = 0; k < container.instructions.length; k++) {
uint256 budget =
container.instructions[k].maximumRefundTarget + container.instructions[k].applicationBudgetTarget;
uint16 targetChain = container.instructions[k].targetChain;
ICoreRelayer.TargetDeliveryParametersSingle memory package = ICoreRelayer.TargetDeliveryParametersSingle({
encodedVMs: deliveryInstructions,
deliveryIndex: counter,
multisendIndex: k
multisendIndex: k,
relayerRefundAddress: payable(map[targetChain].relayer)
});
uint16 targetChain = container.instructions[k].targetChain;
uint256 wormholeFee = map[targetChain].wormhole.messageFee();
vm.prank(map[targetChain].relayer);
map[targetChain].coreRelayer.deliverSingle{value: (budget + wormholeFee)}(package);
@ -1097,7 +1104,8 @@ contract TestCoreRelayer is Test {
redeliveryVM: encodedVM,
sourceEncodedVMs: originalDelivery.encodedVMs,
deliveryIndex: originalDelivery.deliveryIndex,
multisendIndex: originalDelivery.multisendIndex
multisendIndex: originalDelivery.multisendIndex,
relayerRefundAddress: payable(map[targetChain].relayer)
});
vm.prank(map[targetChain].relayer);

13
relayer_engine/src/plugin/src/plugin.ts
View File

@ -441,11 +441,7 @@ export class GenericRelayerPlugin implements Plugin<WorkflowPayload> {
// todo: add wormhole fee
const budget = ix.applicationBudgetTarget.add(ix.maximumRefundTarget).add(100)
const input: CoreRelayerStructs.TargetDeliveryParametersSingleStruct = {
encodedVMs: payload.vaas,
deliveryIndex: payload.coreRelayerVaaIndex,
multisendIndex: i,
}
const chainId = ix.targetChain as wh.EVMChainId
// todo: consider parallelizing this
@ -457,6 +453,13 @@ export class GenericRelayerPlugin implements Plugin<WorkflowPayload> {
wallet
)
const input: CoreRelayerStructs.TargetDeliveryParametersSingleStruct = {
encodedVMs: payload.vaas,
deliveryIndex: payload.coreRelayerVaaIndex,
multisendIndex: i,
relayerRefundAddress: relayProvider.address
}
if (!(await relayProvider.approvedSender(wallet.address))) {
this.logger.warn(
`Approved sender not set correctly for chain ${chainId}, should be ${wallet.address}`