564 lines
24 KiB
Solidity
564 lines
24 KiB
Solidity
// contracts/Bridge.sol
|
|
// SPDX-License-Identifier: Apache 2
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
import "../libraries/external/BytesLib.sol";
|
|
|
|
import "./CoreRelayerGetters.sol";
|
|
import "./CoreRelayerStructs.sol";
|
|
import "../interfaces/IWormholeRelayer.sol";
|
|
|
|
contract CoreRelayerMessages is CoreRelayerStructs, CoreRelayerGetters {
|
|
using BytesLib for bytes;
|
|
|
|
error InvalidPayloadId(uint8 payloadId);
|
|
error InvalidDeliveryInstructionsPayload(uint256 length);
|
|
|
|
/**
|
|
* @notice This function calculates the total fee to execute all of the Send requests in this MultichainSend container
|
|
* @param sendContainer A MultichainSend struct describing all of the Send requests
|
|
* @return totalFee
|
|
*/
|
|
function getTotalFeeMultichainSend(IWormholeRelayer.MultichainSend memory sendContainer, uint256 wormholeMessageFee)
|
|
internal
|
|
view
|
|
returns (uint256 totalFee)
|
|
{
|
|
totalFee = wormholeMessageFee;
|
|
uint256 length = sendContainer.requests.length;
|
|
for (uint256 i = 0; i < length; i++) {
|
|
IWormholeRelayer.Send memory request = sendContainer.requests[i];
|
|
totalFee += request.maxTransactionFee + request.receiverValue;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @notice This function converts a MultichainSend struct into a DeliveryInstructionsContainer struct that
|
|
* describes to the relayer exactly how to relay for each of the Send requests.
|
|
* Specifically, each Send is converted to a DeliveryInstruction, which is a struct that contains six fields:
|
|
* 1) targetChain, 2) targetAddress, 3) refundAddress (all which are part of the Send struct),
|
|
* 4) maximumRefundTarget: The maximum amount that can be refunded to 'refundAddress' (e.g. if the call to 'receiveWormholeMessages' takes 0 gas),
|
|
* 5) receiverValueTarget: The amount that will be passed into 'receiveWormholeMessages' as value, in target chain currency
|
|
* 6) executionParameters: a struct with information about execution, specifically:
|
|
* executionParameters.gasLimit: The maximum amount of gas 'receiveWormholeMessages' is allowed to use
|
|
* executionParameters.providerDeliveryAddress: The address of the relayer that will execute this Send request
|
|
* The latter 3 fields are calculated using the relayProvider's getters
|
|
* @param sendContainer A MultichainSend struct describing all of the Send requests
|
|
* @return instructionsContainer A DeliveryInstructionsContainer struct
|
|
*/
|
|
function convertMultichainSendToDeliveryInstructionsContainer(IWormholeRelayer.MultichainSend memory sendContainer)
|
|
internal
|
|
view
|
|
returns (DeliveryInstructionsContainer memory instructionsContainer)
|
|
{
|
|
instructionsContainer.payloadId = 1;
|
|
IRelayProvider relayProvider = IRelayProvider(sendContainer.relayProviderAddress);
|
|
uint256 length = sendContainer.requests.length;
|
|
instructionsContainer.instructions = new DeliveryInstruction[](length);
|
|
for (uint256 i = 0; i < length; i++) {
|
|
instructionsContainer.instructions[i] =
|
|
convertSendToDeliveryInstruction(sendContainer.requests[i], relayProvider);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @notice This function converts a Send struct into a DeliveryInstruction struct that
|
|
* describes to the relayer exactly how to relay for the Send.
|
|
* Specifically, the DeliveryInstruction struct that contains six fields:
|
|
* 1) targetChain, 2) targetAddress, 3) refundAddress (all which are part of the Send struct),
|
|
* 4) maximumRefundTarget: The maximum amount that can be refunded to 'refundAddress' (e.g. if the call to 'receiveWormholeMessages' takes 0 gas),
|
|
* 5) receiverValueTarget: The amount that will be passed into 'receiveWormholeMessages' as value, in target chain currency
|
|
* 6) executionParameters: a struct with information about execution, specifically:
|
|
* executionParameters.gasLimit: The maximum amount of gas 'receiveWormholeMessages' is allowed to use
|
|
* executionParameters.providerDeliveryAddress: The address of the relayer that will execute this Send request
|
|
* The latter 3 fields are calculated using the relayProvider's getters
|
|
* @param send A Send struct
|
|
* @param relayProvider The relay provider chosen for this Send
|
|
* @return instruction A DeliveryInstruction
|
|
*/
|
|
function convertSendToDeliveryInstruction(IWormholeRelayer.Send memory send, IRelayProvider relayProvider)
|
|
internal
|
|
view
|
|
returns (DeliveryInstruction memory instruction)
|
|
{
|
|
instruction.targetChain = send.targetChain;
|
|
instruction.targetAddress = send.targetAddress;
|
|
instruction.refundAddress = send.refundAddress;
|
|
instruction.maximumRefundTarget =
|
|
calculateTargetDeliveryMaximumRefund(send.targetChain, send.maxTransactionFee, relayProvider);
|
|
instruction.receiverValueTarget =
|
|
convertReceiverValueAmount(send.receiverValue, send.targetChain, relayProvider);
|
|
instruction.executionParameters = ExecutionParameters({
|
|
version: 1,
|
|
gasLimit: calculateTargetGasDeliveryAmount(send.targetChain, send.maxTransactionFee, relayProvider),
|
|
providerDeliveryAddress: relayProvider.getDeliveryAddress(send.targetChain)
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @notice Check if for each instruction in the DeliveryInstructionContainer,
|
|
* - the total amount of target chain currency needed for execution of the instruction is within the maximum budget,
|
|
* i.e. (maximumRefundTarget + receiverValueTarget) <= (the relayProvider's maximum budget for the target chain)
|
|
* - the gasLimit is greater than 0
|
|
* @param container A DeliveryInstructionsContainer
|
|
* @param relayProvider The relayProvider whos maximum budget we are checking against
|
|
*/
|
|
function checkInstructions(DeliveryInstructionsContainer memory container, IRelayProvider relayProvider)
|
|
internal
|
|
view
|
|
{
|
|
uint256 length = container.instructions.length;
|
|
for (uint8 i = 0; i < length; i++) {
|
|
DeliveryInstruction memory instruction = container.instructions[i];
|
|
if (instruction.executionParameters.gasLimit == 0) {
|
|
revert IWormholeRelayer.MaxTransactionFeeNotEnough(i);
|
|
}
|
|
if (
|
|
instruction.maximumRefundTarget + instruction.receiverValueTarget
|
|
> relayProvider.quoteMaximumBudget(instruction.targetChain)
|
|
) {
|
|
revert IWormholeRelayer.FundsTooMuch(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @notice Check if for a redelivery instruction,
|
|
* - the total amount of target chain currency needed for execution of this instruction is within the maximum budget,
|
|
* i.e. (maximumRefundTarget + receiverValueTarget) <= (the relayProvider's maximum budget for the target chain)
|
|
* - the gasLimit is greater than 0
|
|
* @param instruction A RedeliveryByTxHashInstruction
|
|
* @param relayProvider The relayProvider whos maximum budget we are checking against
|
|
*/
|
|
function checkRedeliveryInstruction(
|
|
RedeliveryByTxHashInstruction memory instruction,
|
|
IRelayProvider relayProvider,
|
|
uint256 wormholeMessageFee
|
|
) internal view {
|
|
if (instruction.executionParameters.gasLimit == 0) {
|
|
revert IWormholeRelayer.MaxTransactionFeeNotEnough(0);
|
|
}
|
|
if (
|
|
instruction.newMaximumRefundTarget + instruction.newReceiverValueTarget + wormholeMessageFee
|
|
> relayProvider.quoteMaximumBudget(instruction.targetChain)
|
|
) {
|
|
revert IWormholeRelayer.FundsTooMuch(0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @notice This function converts a ResendByTx struct into a RedeliveryByTxHashInstruction struct that
|
|
* describes to the relayer exactly how to relay for the ResendByTx.
|
|
* Specifically, the RedeliveryByTxHashInstruction struct that contains nine fields:
|
|
* 1) sourceChain, 2) sourceTxHash, 3) sourceNonce, 4) targetChain, 5) deliveryIndex, 6) multisendIndex (all which are part of the ResendByTxHash struct),
|
|
* 7) newMaximumRefundTarget: The new maximum amount that can be refunded to 'refundAddress' (e.g. if the call to 'receiveWormholeMessages' takes 0 gas),
|
|
* 8) newReceiverValueTarget: The new amount that will be passed into 'receiveWormholeMessages' as value, in target chain currency
|
|
* 9) executionParameters: a struct with information about execution, specifically:
|
|
* executionParameters.gasLimit: The maximum amount of gas 'receiveWormholeMessages' is allowed to use
|
|
* executionParameters.providerDeliveryAddress: The address of the relayer that will execute this ResendByTx request
|
|
* The latter 3 fields are calculated using the relayProvider's getters
|
|
* @param resend A ResendByTx struct
|
|
* @param relayProvider The relay provider chosen for this ResendByTx
|
|
* @return instruction A DeliveryInstruction
|
|
*/
|
|
function convertResendToRedeliveryInstruction(
|
|
IWormholeRelayer.ResendByTx memory resend,
|
|
IRelayProvider relayProvider
|
|
) internal view returns (RedeliveryByTxHashInstruction memory instruction) {
|
|
instruction.payloadId = 2;
|
|
instruction.sourceChain = resend.sourceChain;
|
|
instruction.sourceTxHash = resend.sourceTxHash;
|
|
instruction.sourceNonce = resend.sourceNonce;
|
|
instruction.targetChain = resend.targetChain;
|
|
instruction.deliveryIndex = resend.deliveryIndex;
|
|
instruction.multisendIndex = resend.multisendIndex;
|
|
instruction.newMaximumRefundTarget =
|
|
calculateTargetRedeliveryMaximumRefund(resend.targetChain, resend.newMaxTransactionFee, relayProvider);
|
|
instruction.newReceiverValueTarget =
|
|
convertReceiverValueAmount(resend.newReceiverValue, resend.targetChain, relayProvider);
|
|
instruction.executionParameters = ExecutionParameters({
|
|
version: 1,
|
|
gasLimit: calculateTargetGasRedeliveryAmount(resend.targetChain, resend.newMaxTransactionFee, relayProvider),
|
|
providerDeliveryAddress: relayProvider.getDeliveryAddress(resend.targetChain)
|
|
});
|
|
}
|
|
|
|
// encode a 'RedeliveryByTxHashInstruction' into bytes
|
|
function encodeRedeliveryInstruction(RedeliveryByTxHashInstruction memory instruction)
|
|
internal
|
|
pure
|
|
returns (bytes memory encoded)
|
|
{
|
|
encoded = abi.encodePacked(
|
|
instruction.payloadId,
|
|
instruction.sourceChain,
|
|
instruction.sourceTxHash,
|
|
instruction.sourceNonce,
|
|
instruction.targetChain,
|
|
instruction.deliveryIndex,
|
|
instruction.multisendIndex,
|
|
instruction.newMaximumRefundTarget,
|
|
instruction.newReceiverValueTarget,
|
|
instruction.executionParameters.version,
|
|
instruction.executionParameters.gasLimit,
|
|
instruction.executionParameters.providerDeliveryAddress
|
|
);
|
|
}
|
|
|
|
// encode a 'DeliveryInstructionsContainer' into bytes
|
|
function encodeDeliveryInstructionsContainer(DeliveryInstructionsContainer memory container)
|
|
internal
|
|
pure
|
|
returns (bytes memory encoded)
|
|
{
|
|
encoded = abi.encodePacked(
|
|
container.payloadId, uint8(container.sufficientlyFunded ? 1 : 0), uint8(container.instructions.length)
|
|
);
|
|
|
|
for (uint256 i = 0; i < container.instructions.length; i++) {
|
|
encoded = abi.encodePacked(encoded, encodeDeliveryInstruction(container.instructions[i]));
|
|
}
|
|
}
|
|
|
|
// encode a 'DeliveryInstruction' into bytes
|
|
function encodeDeliveryInstruction(DeliveryInstruction memory instruction)
|
|
internal
|
|
pure
|
|
returns (bytes memory encoded)
|
|
{
|
|
encoded = abi.encodePacked(
|
|
instruction.targetChain,
|
|
instruction.targetAddress,
|
|
instruction.refundAddress,
|
|
instruction.maximumRefundTarget,
|
|
instruction.receiverValueTarget,
|
|
instruction.executionParameters.version,
|
|
instruction.executionParameters.gasLimit,
|
|
instruction.executionParameters.providerDeliveryAddress
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Given a targetChain, maxTransactionFee, and a relay provider, this function calculates what the gas limit of the delivery transaction
|
|
* should be
|
|
*
|
|
* It does this by calculating (maxTransactionFee - deliveryOverhead)/gasPrice
|
|
* where 'deliveryOverhead' is the relayProvider's base fee for delivering to targetChain (in units of source chain currency)
|
|
* and 'gasPrice' is the relayProvider's fee per unit of target chain gas (in units of source chain currency)
|
|
*
|
|
* @param targetChain target chain
|
|
* @param maxTransactionFee uint256
|
|
* @param provider IRelayProvider
|
|
* @return gasAmount
|
|
*/
|
|
function calculateTargetGasDeliveryAmount(uint16 targetChain, uint256 maxTransactionFee, IRelayProvider provider)
|
|
internal
|
|
view
|
|
returns (uint32 gasAmount)
|
|
{
|
|
gasAmount = calculateTargetGasDeliveryAmountHelper(
|
|
targetChain, maxTransactionFee, provider.quoteDeliveryOverhead(targetChain), provider
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Given a targetChain, maxTransactionFee, and a relay provider, this function calculates what the maximum refund of the delivery transaction
|
|
* should be, in terms of target chain currency
|
|
*
|
|
* The maximum refund is the amount that would be refunded to refundAddress if the call to 'receiveWormholeMessages' takes 0 gas
|
|
*
|
|
* It does this by calculating (maxTransactionFee - deliveryOverhead) and converting (using the relay provider's prices) to target chain currency
|
|
* (where 'deliveryOverhead' is the relayProvider's base fee for delivering to targetChain [in units of source chain currency])
|
|
*
|
|
* @param targetChain target chain
|
|
* @param maxTransactionFee uint256
|
|
* @param provider IRelayProvider
|
|
* @return maximumRefund uint256
|
|
*/
|
|
function calculateTargetDeliveryMaximumRefund(
|
|
uint16 targetChain,
|
|
uint256 maxTransactionFee,
|
|
IRelayProvider provider
|
|
) internal view returns (uint256 maximumRefund) {
|
|
maximumRefund = calculateTargetDeliveryMaximumRefundHelper(
|
|
targetChain, maxTransactionFee, provider.quoteDeliveryOverhead(targetChain), provider
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Given a targetChain, maxTransactionFee, and a relay provider, this function calculates what the gas limit of the redelivery transaction
|
|
* should be
|
|
*
|
|
* It does this by calculating (maxTransactionFee - redeliveryOverhead)/gasPrice
|
|
* where 'redeliveryOverhead' is the relayProvider's base fee for redelivering to targetChain (in units of source chain currency)
|
|
* and 'gasPrice' is the relayProvider's fee per unit of target chain gas (in units of source chain currency)
|
|
*
|
|
* @param targetChain target chain
|
|
* @param maxTransactionFee uint256
|
|
* @param provider IRelayProvider
|
|
* @return gasAmount
|
|
*/
|
|
function calculateTargetGasRedeliveryAmount(uint16 targetChain, uint256 maxTransactionFee, IRelayProvider provider)
|
|
internal
|
|
view
|
|
returns (uint32 gasAmount)
|
|
{
|
|
gasAmount = calculateTargetGasDeliveryAmountHelper(
|
|
targetChain, maxTransactionFee, provider.quoteRedeliveryOverhead(targetChain), provider
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Given a targetChain, maxTransactionFee, and a relay provider, this function calculates what the maximum refund of the redelivery transaction
|
|
* should be, in terms of target chain currency
|
|
*
|
|
* The maximum refund is the amount that would be refunded to refundAddress if the call to 'receiveWormholeMessages' takes 0 gas
|
|
*
|
|
* It does this by calculating (maxTransactionFee - redeliveryOverhead) and converting (using the relay provider's prices) to target chain currency
|
|
* (where 'redeliveryOverhead' is the relayProvider's base fee for redelivering to targetChain [in units of source chain currency])
|
|
*
|
|
* @param targetChain target chain
|
|
* @param maxTransactionFee uint256
|
|
* @param provider IRelayProvider
|
|
* @return maximumRefund uint256
|
|
*/
|
|
function calculateTargetRedeliveryMaximumRefund(
|
|
uint16 targetChain,
|
|
uint256 maxTransactionFee,
|
|
IRelayProvider provider
|
|
) internal view returns (uint256 maximumRefund) {
|
|
maximumRefund = calculateTargetDeliveryMaximumRefundHelper(
|
|
targetChain, maxTransactionFee, provider.quoteRedeliveryOverhead(targetChain), provider
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Performs the calculation (maxTransactionFee - overhead)/(price of 1 unit of target chain gas, in source chain currency)
|
|
* and bounds the result between 0 and 2^32-1, inclusive
|
|
*
|
|
* @param targetChain uint16
|
|
* @param maxTransactionFee uint256
|
|
* @param overhead uint256
|
|
* @param provider IRelayProvider
|
|
*/
|
|
function calculateTargetGasDeliveryAmountHelper(
|
|
uint16 targetChain,
|
|
uint256 maxTransactionFee,
|
|
uint256 overhead,
|
|
IRelayProvider provider
|
|
) internal view returns (uint32 gasAmount) {
|
|
if (maxTransactionFee <= overhead) {
|
|
gasAmount = 0;
|
|
} else {
|
|
uint256 gas = (maxTransactionFee - overhead) / provider.quoteGasPrice(targetChain);
|
|
if (gas > type(uint32).max) {
|
|
gasAmount = type(uint32).max;
|
|
} else {
|
|
gasAmount = uint32(gas);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts (maxTransactionFee - overhead) from source to target chain currency, using the provider's prices
|
|
*
|
|
* @param targetChain uint16
|
|
* @param maxTransactionFee uint256
|
|
* @param overhead uint256
|
|
* @param provider IRelayProvider
|
|
*/
|
|
function calculateTargetDeliveryMaximumRefundHelper(
|
|
uint16 targetChain,
|
|
uint256 maxTransactionFee,
|
|
uint256 overhead,
|
|
IRelayProvider provider
|
|
) internal view returns (uint256 maximumRefund) {
|
|
if (maxTransactionFee >= overhead) {
|
|
uint256 remainder = maxTransactionFee - overhead;
|
|
maximumRefund = assetConversionHelper(chainId(), remainder, targetChain, 1, 1, false, provider);
|
|
} else {
|
|
maximumRefund = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts 'sourceAmount' of source chain currency to units of target chain currency
|
|
* using the prices of 'provider'
|
|
* and also multiplying by a specified fraction 'multiplier/multiplierDenominator',
|
|
* rounding up or down specified by 'roundUp', and without performing intermediate rounding,
|
|
* i.e. the result should be as if float arithmetic was done and the rounding performed at the end
|
|
*
|
|
* @param sourceChain source chain
|
|
* @param sourceAmount amount of source chain currency to be converted
|
|
* @param targetChain target chain
|
|
* @param multiplier numerator of a fraction to multiply by
|
|
* @param multiplierDenominator denominator of a fraction to multiply by
|
|
* @param roundUp whether or not to round up
|
|
* @param provider relay provider
|
|
* @return targetAmount amount of target chain currency
|
|
*/
|
|
function assetConversionHelper(
|
|
uint16 sourceChain,
|
|
uint256 sourceAmount,
|
|
uint16 targetChain,
|
|
uint256 multiplier,
|
|
uint256 multiplierDenominator,
|
|
bool roundUp,
|
|
IRelayProvider provider
|
|
) internal view returns (uint256 targetAmount) {
|
|
uint256 srcNativeCurrencyPrice = provider.quoteAssetPrice(sourceChain);
|
|
if (srcNativeCurrencyPrice == 0) {
|
|
revert IWormholeRelayer.RelayProviderDoesNotSupportTargetChain();
|
|
}
|
|
|
|
uint256 dstNativeCurrencyPrice = provider.quoteAssetPrice(targetChain);
|
|
if (dstNativeCurrencyPrice == 0) {
|
|
revert IWormholeRelayer.RelayProviderDoesNotSupportTargetChain();
|
|
}
|
|
uint256 numerator = sourceAmount * srcNativeCurrencyPrice * multiplier;
|
|
uint256 denominator = dstNativeCurrencyPrice * multiplierDenominator;
|
|
if (roundUp) {
|
|
targetAmount = (numerator + denominator - 1) / denominator;
|
|
} else {
|
|
targetAmount = numerator / denominator;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If the user specifies (for 'receiverValue) 'sourceAmount' of source chain currency, with relay provider 'provider',
|
|
* then this function calculates how much the relayer will pass into receiveWormholeMessages on the target chain (in target chain currency)
|
|
*
|
|
* The calculation simply converts this amount to target chain currency, but also applies a multiplier of 'denominator/(denominator + buffer)'
|
|
* where these values are also specified by the relay provider 'provider'
|
|
*
|
|
* @param sourceAmount amount of source chain currency
|
|
* @param targetChain target chain
|
|
* @param provider relay provider
|
|
* @return targetAmount amount of target chain currency
|
|
*/
|
|
function convertReceiverValueAmount(uint256 sourceAmount, uint16 targetChain, IRelayProvider provider)
|
|
internal
|
|
view
|
|
returns (uint256 targetAmount)
|
|
{
|
|
(uint16 buffer, uint16 denominator) = provider.getAssetConversionBuffer(targetChain);
|
|
|
|
targetAmount = assetConversionHelper(
|
|
chainId(), sourceAmount, targetChain, denominator, uint256(0) + denominator + buffer, false, provider
|
|
);
|
|
}
|
|
|
|
// decode a 'RedeliveryByTxHashInstruction' from bytes
|
|
function decodeRedeliveryInstruction(bytes memory encoded)
|
|
public
|
|
pure
|
|
returns (RedeliveryByTxHashInstruction memory instruction)
|
|
{
|
|
uint256 index = 0;
|
|
|
|
instruction.payloadId = encoded.toUint8(index);
|
|
if (instruction.payloadId != 2) {
|
|
revert InvalidPayloadId(instruction.payloadId);
|
|
}
|
|
index += 1;
|
|
|
|
instruction.sourceChain = encoded.toUint16(index);
|
|
index += 2;
|
|
|
|
instruction.sourceTxHash = encoded.toBytes32(index);
|
|
index += 32;
|
|
|
|
instruction.sourceNonce = encoded.toUint32(index);
|
|
index += 4;
|
|
|
|
instruction.targetChain = encoded.toUint16(index);
|
|
index += 2;
|
|
|
|
instruction.deliveryIndex = encoded.toUint8(index);
|
|
index += 1;
|
|
|
|
instruction.multisendIndex = encoded.toUint8(index);
|
|
index += 1;
|
|
|
|
instruction.newMaximumRefundTarget = encoded.toUint256(index);
|
|
index += 32;
|
|
|
|
instruction.newReceiverValueTarget = encoded.toUint256(index);
|
|
index += 32;
|
|
|
|
instruction.executionParameters.version = encoded.toUint8(index);
|
|
index += 1;
|
|
|
|
instruction.executionParameters.gasLimit = encoded.toUint32(index);
|
|
index += 4;
|
|
|
|
instruction.executionParameters.providerDeliveryAddress = encoded.toBytes32(index);
|
|
index += 32;
|
|
}
|
|
|
|
// decode a 'DeliveryInstructionsContainer' from bytes
|
|
function decodeDeliveryInstructionsContainer(bytes memory encoded)
|
|
public
|
|
pure
|
|
returns (DeliveryInstructionsContainer memory)
|
|
{
|
|
uint256 index = 0;
|
|
|
|
uint8 payloadId = encoded.toUint8(index);
|
|
if (payloadId != 1) {
|
|
revert InvalidPayloadId(payloadId);
|
|
}
|
|
index += 1;
|
|
bool sufficientlyFunded = encoded.toUint8(index) == 1;
|
|
index += 1;
|
|
uint8 arrayLen = encoded.toUint8(index);
|
|
index += 1;
|
|
|
|
DeliveryInstruction[] memory instructionArray = new DeliveryInstruction[](arrayLen);
|
|
|
|
for (uint8 i = 0; i < arrayLen; i++) {
|
|
DeliveryInstruction memory instruction;
|
|
|
|
// target chain of the delivery instruction
|
|
instruction.targetChain = encoded.toUint16(index);
|
|
index += 2;
|
|
|
|
// target contract address
|
|
instruction.targetAddress = encoded.toBytes32(index);
|
|
index += 32;
|
|
|
|
// address to send the refund to
|
|
instruction.refundAddress = encoded.toBytes32(index);
|
|
index += 32;
|
|
|
|
instruction.maximumRefundTarget = encoded.toUint256(index);
|
|
index += 32;
|
|
|
|
instruction.receiverValueTarget = encoded.toUint256(index);
|
|
index += 32;
|
|
|
|
instruction.executionParameters.version = encoded.toUint8(index);
|
|
index += 1;
|
|
|
|
instruction.executionParameters.gasLimit = encoded.toUint32(index);
|
|
index += 4;
|
|
|
|
instruction.executionParameters.providerDeliveryAddress = encoded.toBytes32(index);
|
|
index += 32;
|
|
|
|
instructionArray[i] = instruction;
|
|
}
|
|
|
|
if (index != encoded.length) {
|
|
revert InvalidDeliveryInstructionsPayload(encoded.length);
|
|
}
|
|
|
|
return DeliveryInstructionsContainer({
|
|
payloadId: payloadId,
|
|
sufficientlyFunded: sufficientlyFunded,
|
|
instructions: instructionArray
|
|
});
|
|
}
|
|
}
|