From 0b9e81ffc5dfc374908385031a584f3a31758072 Mon Sep 17 00:00:00 2001 From: A5 Pickle <5342825+a5-pickle@users.noreply.github.com> Date: Thu, 6 Oct 2022 12:16:57 -0500 Subject: [PATCH] Clean up send (#2) * Update README.md with trustlessness * ethereum: rename AllowedEmitterSequence; remove arbitrary payloads * ethereum: refactor integrator contract; add verifying payload * ethereum: update IWormhole * ethereum: add message verifying in mock integration * Remove deliveryList from DeliveryInstructions and fix stack too deep * Remove maximum batch size from relay parameters * ethereum: fix observation loop; formatting * sdk: fix eth-integration test * offchain-relayer: add regenerate-abi.sh * fix Makefile * offchain-relayer: add relayer.tilt.yaml Co-authored-by: Evan Gray <56235822+evan-gray@users.noreply.github.com> Co-authored-by: A5 Pickle Co-authored-by: gator-boi --- Makefile | 1 + README.md | 7 +- WHITEPAPER.md | 34 +- .../contracts/coreRelayer/CoreRelayer.sol | 266 +-- .../coreRelayer/CoreRelayerMessages.sol | 54 - .../coreRelayer/CoreRelayerStructs.sol | 27 +- .../contracts/interfaces/ICoreRelayer.sol | 10 +- ethereum/contracts/interfaces/IWormhole.sol | 4 +- .../contracts/mock/MockRelayerIntegration.sol | 180 +- ethereum/forge-test/CoreRelayer.t.sol | 111 +- ethereum/ts-test/2_core_relayer.ts | 263 +-- ethereum/ts-test/helpers/structs.ts | 1 - ethereum/ts-test/helpers/utils.ts | 14 +- offchain-relayer/.gitignore | 2 + offchain-relayer/get-addresses.sh | 1 + offchain-relayer/regenerate-abi.sh | 5 + .../relay/ethereum/core_relayer/abi.go | 2040 ----------------- .../{.relayer.yaml => relayer.tilt.yaml} | 4 +- sdk/src/__tests__/eth-integration.ts | 35 +- sdk/src/__tests__/helpers/structs.ts | 3 +- 20 files changed, 305 insertions(+), 2757 deletions(-) create mode 100644 offchain-relayer/.gitignore create mode 100755 offchain-relayer/regenerate-abi.sh delete mode 100644 offchain-relayer/relay/ethereum/core_relayer/abi.go rename offchain-relayer/{.relayer.yaml => relayer.tilt.yaml} (75%) diff --git a/Makefile b/Makefile index bc40341..0df312b 100644 --- a/Makefile +++ b/Makefile @@ -6,6 +6,7 @@ all: build build: sdk/node_modules cd ethereum && make build cd sdk && npm run build + cd offchain-relayer && bash regenerate-abi.sh sdk/node_modules: cd sdk && npm ci diff --git a/README.md b/README.md index f73a26b..6118c88 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,8 @@ # Generic Relayers -[TOC] - ## Objective -Develop a common standard for cross-chain relaying system that any application can interface with on-chain to enable better composability. +Develop a common standard for a cross-chain relaying system that any application can interface with on-chain to enable better composability. ## Background @@ -14,10 +12,13 @@ Both of these paradigms present shortcomings for users and integrators respectiv A decentralized network of generic relayers can address the shortcomings of both of the two current relaying methods by handling the cross-chain message redemption and submission on behalf of users and be a separate decentralized service that integrators can leverage. +Fundamentally, the relayer service should require no additional trust assumptions from the integrating contract's perspective. This service should merely serve as a third delivery mechanism option without changing any composing protocol's messaging. See the best practices for [protocol design](https://book.wormhole.com/dapps/architecture/3_protocolDesign.html). + ## Goals - Allow developers to send and receive cross-chain messages through on-chain entrypoints to Wormhole. - Develop relayers that are capable of redeeming and submitting full or subset of Batch VAAs. +- Provide a composable, trustless relaying service in line with the Wormhole ecosystem. ## Non-Goals diff --git a/WHITEPAPER.md b/WHITEPAPER.md index 8eb4569..d7045ba 100644 --- a/WHITEPAPER.md +++ b/WHITEPAPER.md @@ -61,20 +61,10 @@ struct DeliveryInstructions { // Chain ID of the receiver ToChain uint16 - // Length of user Payload - PayloadLen uint16 - // Payload - Payload bytes - - // Length of chain-specific payload - ChainPayloadLen uint16 - // chain-specific delivery payload (accounts, storage slots...) - ChainPayload bytes - // Length of VAA whitelist WhitelistLen uint16 // VAA whitelist - Whitelist []VAAId + Whitelist []AllowedEmitterSequence // Length of Relayer Parameters RelayerParamsLen uint16 @@ -82,7 +72,7 @@ struct DeliveryInstructions { RelayerParams bytes } -struct VAAId { +struct AllowedEmitterSequence { // VAA emitter EmitterAddress bytes32 // VAA sequence @@ -96,7 +86,7 @@ struct DeliveryStatus { // Hash of the relayed batch BatchHash bytes32 // Delivery - Delivery VAAId + Delivery AllowedEmitterSequence // Delivery try DeliveryCount uint16 @@ -112,7 +102,7 @@ struct ReDeliveryInstructions { // Hash of the batch to re-deliver BatchHash bytes32 // Point to the original delivery instruction - OriginalDelivery VAAId + OriginalDelivery AllowedEmitterSequence // Current deliverycount DeliveryCount uint16 @@ -136,14 +126,14 @@ A relaying system that handles payment on the source chain could have minimal Re struct MinimalRelayerParamsExample { // All payloads should be versioned Version uint8 - // Limit the gas amount forwarded to wormholeReceiver() + // Limit the gas amount forwarded to receiveWormholeMessages() DeliveryGasAmount uint32 } struct RelayerParamsExample { // All payloads should be versioned Version uint8 - // Limit the gas amount forwarded to wormholeReceiver() + // Limit the gas amount forwarded to receiveWormholeMessages() DeliveryGasAmount uint32 // Limit the max batch size that was paid for -> fail delivery if batch is too big MaxVAAsInBatch bytes32 @@ -156,7 +146,7 @@ struct RelayerParamsExample { ### Relaying Contract Endpoints -`send(uint16 targetChain, bytes32 targetAddress, bytes payload, VAAWhitelist VAAId[], bytes relayerParams, bytes[] chainPayload, uint32 nonce, uint8 consistencyLevel) payable` +`send(uint16 targetChain, bytes32 targetAddress, bytes payload, VAAWhitelist AllowedEmitterSequence[], bytes relayerParams, bytes[] chainPayload, uint32 nonce, uint8 consistencyLevel) payable` - Optionally: handle payment - Emit `DeliveryInstructions` VAA with specified `targetChain, targetAddress, payload, relayerParams, nonce, VAAWhitelist` and `msg.sender`, the entry-point’s `chainId` @@ -166,19 +156,19 @@ struct RelayerParamsExample { - Optionally: handle payment - Emit `RedeliveryInstructions` VAA with the batch hash & delivery reference and new `relayerParams` -`estimateCost(uint16 targetChainId, bytes[] relayerParams) view` +`estimateEvmCost(uint16 targetChainId, bytes[] relayerParams) view` - provide a quote for given relayerParams - Gas Price, Limit should be encoded in `relayerParams` -`deliver(VAAv2 batchVAA, VAAId delivery, uint targetCallGasOverwrite)` +`deliver(VAAv2 batchVAA, AllowedEmitterSequence delivery, uint targetCallGasOverwrite)` -- Check the delivery hash (`hash(batchHash, VAAId)`) against already successfully delivered ones and revert if it was successfully delivered before +- Check the delivery hash (`hash(batchHash, AllowedEmitterSequence)`) against already successfully delivered ones and revert if it was successfully delivered before - Parse and verify VAAv2 at Wormhole contract with caching enabled - Check if the emitter of the `DeliveryInstructions` VAA is a known and trusted relaying contract - Check if the `DeliveryInstructions.ToChain` is the right chain - If a whitelist is specified, check if all specified VAAs are in the delivered VAAv2, if no whitelist is specified check that the full batch was delivered -- Call `wormholeReceiver` on the `DeliveryInstructions.ToAddress` +- Call `receiveWormholeMessages` on the `DeliveryInstructions.ToAddress` - If the length of the VAA whitelist is > 0, just forward the whitelist of VAAs, otherwise the full batch - If `targetCallGasOverwrite` is higher than what might be specified in `DeliveryInstructions.RelayerParams` take the overwrite value - Emit `DeliveryStatus` depending on success or failure of the `receive` call @@ -195,7 +185,7 @@ struct RelayerParamsExample { ### Receiver Contract Endpoints -`wormholeReceiver(VAAv4[] vaas, uint16 sourceChain, bytes32 sourceAddress, bytes payload)` +`receiveWormholeMessages(VAAv4[] vaas, uint16 sourceChain, bytes32 sourceAddress, bytes payload)` - verify `msg.sender == relayer contract` - verify `sourceAddress` and `sourceChain` diff --git a/ethereum/contracts/coreRelayer/CoreRelayer.sol b/ethereum/contracts/coreRelayer/CoreRelayer.sol index d9ef7e7..724a723 100644 --- a/ethereum/contracts/coreRelayer/CoreRelayer.sol +++ b/ethereum/contracts/coreRelayer/CoreRelayer.sol @@ -12,10 +12,10 @@ contract CoreRelayer is CoreRelayerGovernance { using BytesLib for bytes; /** - * @dev `estimateCost` computes the estimated cost of delivering a batch VAA to a target chain. + * @dev `estimateEvmCost` computes the estimated cost of delivering a batch VAA to a target chain. * it fetches the gas price in native currency for one unit of gas on the target chain */ - function estimateCost(uint16 chainId, uint256 gasLimit) public view returns (uint256 gasEstimate) { + function estimateEvmCost(uint16 chainId, uint256 gasLimit) public view returns (uint256 gasEstimate) { return (gasOracle().computeGasCost(chainId, gasLimit + evmDeliverGasOverhead()) + wormhole().messageFee()); } @@ -32,16 +32,8 @@ contract CoreRelayer is CoreRelayerGovernance { // decode the relay parameters RelayParameters memory relayParams = decodeRelayParameters(deliveryParams.relayParameters); - require(relayParams.deliveryGasLimit > 0, "invalid deliveryGasLimit in relayParameters"); - - // Estimate the gas costs of the delivery, and confirm the user sent the right amount of gas. - // The user needs to make sure to send a little extra value to cover the wormhole messageFee on this chain. - uint256 deliveryCostEstimate = estimateCost(deliveryParams.targetChain, relayParams.deliveryGasLimit); - - require( - relayParams.nativePayment == deliveryCostEstimate && msg.value == deliveryCostEstimate, - "insufficient fee specified in msg.value" - ); + // estimate relay cost and check to see if the user sent enough eth to cover the relay + collectRelayerParameterPayment(relayParams, deliveryParams.targetChain, relayParams.deliveryGasLimit); // sanity check a few of the values before composing the DeliveryInstructions require(deliveryParams.targetAddress != bytes32(0), "invalid targetAddress"); @@ -76,6 +68,8 @@ contract CoreRelayer is CoreRelayerGovernance { incrementRedeliveryAttempt(deliveryHash); RelayParameters memory relayParams = decodeRelayParameters(newRelayerParams); + + // estimate relay cost and check to see if the user sent enough eth to cover the relay collectRelayerParameterPayment(relayParams, vm.emitterChainId, relayParams.deliveryGasLimit); RedeliveryInstructions memory redeliveryInstructions = RedeliveryInstructions({ @@ -98,13 +92,11 @@ contract CoreRelayer is CoreRelayerGovernance { RelayParameters memory relayParams, uint16 targetChain, uint32 targetGasLimit - ) - internal - { + ) internal { require(relayParams.deliveryGasLimit > 0, "invalid deliveryGasLimit in relayParameters"); // Estimate the gas costs of the delivery, and confirm the user sent the right amount of gas. - uint256 deliveryCostEstimate = estimateCost(targetChain, targetGasLimit); + uint256 deliveryCostEstimate = estimateEvmCost(targetChain, targetGasLimit); require( relayParams.nativePayment == deliveryCostEstimate && msg.value == deliveryCostEstimate, @@ -118,8 +110,7 @@ contract CoreRelayer is CoreRelayerGovernance { * it locates the DeliveryInstructions VAA in the batch * it checks to see if the batch has been delivered already * it verifies that the delivery instructions were generated by a registered relayer contract - * it verifies that the delivered batch contains all VAAs specified in the deliveryList (if it's a partial batch) - * it forwards the array of VAAs in the batch to the target contract by calling the `wormholeReceiver` endpoint + * it forwards the array of VAAs in the batch to the target contract by calling the `receiveWormholeMessages` endpoint * it records the specified relayer fees for the caller * it emits a DeliveryStatus message containing the results of the delivery */ @@ -127,28 +118,37 @@ contract CoreRelayer is CoreRelayerGovernance { // cache wormhole instance IWormhole wormhole = wormhole(); + // build InternalDelivery struct to reduce local variable count + InternalDeliveryParams memory internalParams; + // parse the batch VAA - IWormhole.VM2 memory batchVM = wormhole.parseBatchVM(targetParams.encodedVM); + internalParams.batchVM = wormhole.parseBatchVM(targetParams.encodedVM); // cache the deliveryVM - IWormhole.VM memory deliveryVM = batchVM.indexedObservations[targetParams.deliveryIndex].vm3; + IWormhole.VM memory deliveryVM = + parseWormholeObservation(internalParams.batchVM.observations[targetParams.deliveryIndex]); require(verifyRelayerVM(deliveryVM), "invalid emitter"); - // create the VAAId for the delivery VAA - VAAId memory deliveryId = VAAId({emitterAddress: deliveryVM.emitterAddress, sequence: deliveryVM.sequence}); + // create the AllowedEmitterSequence for the delivery VAA + internalParams.deliveryId = + AllowedEmitterSequence({emitterAddress: deliveryVM.emitterAddress, sequence: deliveryVM.sequence}); // parse the deliveryVM payload into the DeliveryInstructions struct - DeliveryInstructions memory deliveryInstructions = decodeDeliveryInstructions(deliveryVM.payload); + internalParams.deliveryInstructions = decodeDeliveryInstructions(deliveryVM.payload); // parse the relayParams - RelayParameters memory relayParams = decodeRelayParameters(deliveryInstructions.relayParameters); + internalParams.relayParams = decodeRelayParameters(internalParams.deliveryInstructions.relayParameters); - // Override the target gas if requested by the relayer - if (targetParams.targetCallGasOverride > relayParams.deliveryGasLimit) { - relayParams.deliveryGasLimit = targetParams.targetCallGasOverride; + // override the target gas if requested by the relayer + if (targetParams.targetCallGasOverride > internalParams.relayParams.deliveryGasLimit) { + internalParams.relayParams.deliveryGasLimit = targetParams.targetCallGasOverride; } - return _deliver(wormhole, batchVM, deliveryInstructions, deliveryId, relayParams, 0); + // set the remaining values in the InternalDeliveryParams struct + internalParams.deliveryIndex = targetParams.deliveryIndex; + internalParams.deliveryAttempts = 0; + + return _deliver(wormhole, internalParams); } // TODO: WIP @@ -160,53 +160,58 @@ contract CoreRelayer is CoreRelayerGovernance { // cache wormhole instance IWormhole wormhole = wormhole(); + // build InternalDeliveryParams struct to reduce local variable count + InternalDeliveryParams memory internalParams; + // parse the batch - IWormhole.VM2 memory batchVM = wormhole.parseBatchVM(targetParams.encodedVM); + internalParams.batchVM = wormhole.parseBatchVM(targetParams.encodedVM); // cache the deliveryVM - IWormhole.VM memory deliveryVM = batchVM.indexedObservations[targetParams.deliveryIndex].vm3; + IWormhole.VM memory deliveryVM = + parseWormholeObservation(internalParams.batchVM.observations[targetParams.deliveryIndex]); require(verifyRelayerVM(deliveryVM), "invalid emitter"); - // create the VAAId for the delivery VAA - VAAId memory deliveryId = VAAId({emitterAddress: deliveryVM.emitterAddress, sequence: deliveryVM.sequence}); + // create the AllowedEmitterSequence for the delivery VAA + internalParams.deliveryId = + AllowedEmitterSequence({emitterAddress: deliveryVM.emitterAddress, sequence: deliveryVM.sequence}); // parse the deliveryVM payload into the DeliveryInstructions struct - DeliveryInstructions memory deliveryInstructions = decodeDeliveryInstructions(deliveryVM.payload); + internalParams.deliveryInstructions = decodeDeliveryInstructions(deliveryVM.payload); + // parse and verify the encoded redelivery message (IWormhole.VM memory redeliveryVm, bool valid, string memory reason) = wormhole.parseAndVerifyVM(encodedRedeliveryVm); require(valid, reason); require(verifyRelayerVM(redeliveryVm), "invalid emitter"); + // parse the RedeliveryInstructions RedeliveryInstructions memory redeliveryInstructions = parseRedeliveryInstructions(redeliveryVm.payload); - require(redeliveryInstructions.batchHash == batchVM.hash, "invalid batch"); - require(redeliveryInstructions.emitterAddress == deliveryVM.emitterAddress, "invalid delivery"); - require(redeliveryInstructions.sequence == deliveryVM.sequence, "invalid delivery"); + require(redeliveryInstructions.batchHash == internalParams.batchVM.hash, "invalid batch"); + require( + redeliveryInstructions.emitterAddress == internalParams.deliveryId.emitterAddress, + "invalid delivery emitter" + ); + require(redeliveryInstructions.sequence == internalParams.deliveryId.sequence, "invalid delivery sequence"); - // overwrite the DeliveryInstruction's relayParams - deliveryInstructions.relayParameters = redeliveryInstructions.relayParameters; + // override the DeliveryInstruction's relayParams + internalParams.deliveryInstructions.relayParameters = redeliveryInstructions.relayParameters; // parse the new relayParams - RelayParameters memory relayParams = decodeRelayParameters(redeliveryInstructions.relayParameters); + internalParams.relayParams = decodeRelayParameters(redeliveryInstructions.relayParameters); - // Overwrite the target gas if requested by the relayer - if (targetParams.targetCallGasOverride > relayParams.deliveryGasLimit) { - relayParams.deliveryGasLimit = targetParams.targetCallGasOverride; + // override the target gas if requested by the relayer + if (targetParams.targetCallGasOverride > internalParams.relayParams.deliveryGasLimit) { + internalParams.relayParams.deliveryGasLimit = targetParams.targetCallGasOverride; } - return _deliver( - wormhole, batchVM, deliveryInstructions, deliveryId, relayParams, redeliveryInstructions.deliveryCount - ); + // set the remaining values in the InternalDeliveryParams struct + internalParams.deliveryIndex = targetParams.deliveryIndex; + internalParams.deliveryAttempts = redeliveryInstructions.deliveryCount; + + return _deliver(wormhole, internalParams); } - function _deliver( - IWormhole wormhole, - IWormhole.VM2 memory batchVM, - DeliveryInstructions memory deliveryInstructions, - VAAId memory deliveryId, - RelayParameters memory relayParams, - uint16 attempt - ) + function _deliver(IWormhole wormhole, InternalDeliveryParams memory internalParams) internal returns (uint64 sequence) { @@ -214,51 +219,50 @@ contract CoreRelayer is CoreRelayerGovernance { // Compute the hash(batchHash, deliveryId) and check to see if the batch // was successfully delivered already. Revert if it was. - bytes32 deliveryHash = keccak256(abi.encodePacked(batchVM.hash, deliveryId.emitterAddress, deliveryId.sequence)); + bytes32 deliveryHash = keccak256( + abi.encodePacked( + internalParams.batchVM.hash, + internalParams.deliveryId.emitterAddress, + internalParams.deliveryId.sequence + ) + ); require(!isDeliveryCompleted(deliveryHash), "batch already delivered"); // confirm this is the correct destination chain - require(chainId() == deliveryInstructions.targetChain, "targetChain is not this chain"); + require(chainId() == internalParams.deliveryInstructions.targetChain, "targetChain is not this chain"); // confirm the correct delivery attempt sequence uint256 attemptedDeliveryCount = attemptedDeliveryCount(deliveryHash); - require(attempt == attemptedDeliveryCount, "wrong delivery attempt index"); - - // Check to see if a deliveryList is specified. If not, confirm that all VAAs made it to this contract. - // If a deliveryList is specified, forward the list of VAAs to the receiving contract. - IWormhole.VM[] memory targetVMs; - { - // bypass stack-too-deep - uint256 deliveryListLength = deliveryInstructions.deliveryList.length; - if (deliveryListLength > 0) { - targetVMs = - preparePartialBatchForDelivery(batchVM.indexedObservations, deliveryInstructions.deliveryList); - } else { - targetVMs = - prepareBatchForDelivery(batchVM.indexedObservations, relayParams.maximumBatchSize, deliveryId); - } - } + require(internalParams.deliveryAttempts == attemptedDeliveryCount, "wrong delivery attempt index"); // verify the batchVM before calling the receiver - (bool valid, string memory reason) = wormhole.verifyBatchVM(batchVM, true); + (bool valid, string memory reason) = wormhole.verifyBatchVM(internalParams.batchVM, true); require(valid, reason); + // remove the deliveryVM from the array of observations in the batch + uint256 numObservations = internalParams.batchVM.observations.length; + bytes[] memory targetObservations = new bytes[](numObservations - 1); + uint256 lastIndex = 0; + for (uint256 i = 0; i < numObservations;) { + if (i != internalParams.deliveryIndex) { + targetObservations[lastIndex] = internalParams.batchVM.observations[i]; + unchecked { + lastIndex += 1; + } + } + unchecked { + i += 1; + } + } + // lock the contract to prevent reentrancy require(!isContractLocked(), "reentrant call"); setContractLock(true); - // process the delivery by calling the wormholeReceiver endpoint on the target contract - (bool success,) = address(uint160(uint256(deliveryInstructions.targetAddress))).call{ - gas: relayParams.deliveryGasLimit - }( - abi.encodeWithSignature( - "wormholeReceiver((uint8,uint32,uint32,uint16,bytes32,uint64,uint8,bytes,uint32,(bytes32,bytes32,uint8,uint8)[],bytes32)[],uint16,bytes32,bytes)", - targetVMs, - deliveryInstructions.fromChain, - deliveryInstructions.fromAddress, - deliveryInstructions.payload - ) - ); + // call the receiveWormholeMessages endpoint on the target contract + (bool success,) = address(uint160(uint256(internalParams.deliveryInstructions.targetAddress))).call{ + gas: internalParams.relayParams.deliveryGasLimit + }(abi.encodeWithSignature("receiveWormholeMessages(bytes[])", targetObservations)); // unlock the contract setContractLock(false); @@ -275,17 +279,19 @@ contract CoreRelayer is CoreRelayerGovernance { } // increment the relayer rewards - incrementRelayerRewards(msg.sender, deliveryInstructions.fromChain, relayParams.nativePayment); + incrementRelayerRewards( + msg.sender, internalParams.deliveryInstructions.fromChain, internalParams.relayParams.nativePayment + ); // clear the cache to reduce gas overhead - wormhole.clearBatchCache(batchVM.hashes); + wormhole.clearBatchCache(internalParams.batchVM.hashes); // emit delivery status message DeliveryStatus memory status = DeliveryStatus({ payloadID: 2, - batchHash: batchVM.hash, - emitterAddress: deliveryId.emitterAddress, - sequence: deliveryId.sequence, + batchHash: internalParams.batchVM.hash, + emitterAddress: internalParams.deliveryId.emitterAddress, + sequence: internalParams.deliveryId.sequence, deliveryCount: uint16(attemptedDeliveryCount + 1), deliverySuccess: success }); @@ -294,7 +300,7 @@ contract CoreRelayer is CoreRelayerGovernance { } // TODO: WIP - function rewardPayout(uint16 rewardChain, bytes32 receiver, uint32 nonce) + function collectRewards(uint16 rewardChain, bytes32 receiver, uint32 nonce) public payable returns (uint64 sequence) @@ -321,7 +327,7 @@ contract CoreRelayer is CoreRelayerGovernance { } // TODO: WIP - function finaliseRewardPayout(bytes memory encodedVm) public { + function payRewards(bytes memory encodedVm) public { (IWormhole.VM memory vm, bool valid, string memory reason) = wormhole().parseAndVerifyVM(encodedVm); require(valid, reason); @@ -334,80 +340,6 @@ contract CoreRelayer is CoreRelayerGovernance { payable(address(uint160(uint256(payout.receiver)))).transfer(payout.amount); } - function prepareBatchForDelivery( - IWormhole.IndexedObservation[] memory indexedObservations, - uint8 maximumBatchSize, - VAAId memory deliveryId - ) - internal - pure - returns (IWormhole.VM[] memory batch) - { - // array that will hold the resulting VAAs - batch = new IWormhole.VM[](maximumBatchSize); - - uint8 observationCount = 0; - uint256 observationsLen = indexedObservations.length; - for (uint256 i = 0; i < observationsLen;) { - // parse the VM - IWormhole.VM memory vm = indexedObservations[i].vm3; - - // make sure not to include any deliveryVMs - if (vm.emitterAddress != deliveryId.emitterAddress) { - batch[i] = vm; - observationCount += 1; - } - - unchecked { - i += 1; - } - } - - // confirm that the whole batch was sent - require(observationCount == maximumBatchSize, "invalid batch size"); - } - - function preparePartialBatchForDelivery( - IWormhole.IndexedObservation[] memory indexedObservations, - VAAId[] memory deliveryList - ) - internal - pure - returns (IWormhole.VM[] memory partialBatch) - { - // cache deliveryList length - uint256 deliveryListLen = deliveryList.length; - - // final array with the individual VMs - partialBatch = new IWormhole.VM[](deliveryListLen); - - // cache observationsLen to save on gas - uint256 observationsLen = indexedObservations.length; - - // loop through the delivery list and save VAAs if they are included in the batch - for (uint256 i = 0; i < deliveryListLen;) { - for (uint256 j = 0; j < observationsLen;) { - // parse the VM - IWormhole.VM memory vm = indexedObservations[j].vm3; - - // save if there is a match - if (vm.emitterAddress == deliveryList[i].emitterAddress && vm.sequence == deliveryList[i].sequence) { - partialBatch[i] = vm; - break; - } - - unchecked { - j += 1; - } - } - unchecked { - i += 1; - } - } - // confirm that the whole batch was sent - require(partialBatch.length == deliveryListLen, "invalid batch size"); - } - function verifyRelayerVM(IWormhole.VM memory vm) internal view returns (bool) { if (registeredRelayer(vm.emitterChainId) == vm.emitterAddress) { return true; @@ -415,4 +347,8 @@ contract CoreRelayer is CoreRelayerGovernance { return false; } + + function parseWormholeObservation(bytes memory observation) public view returns (IWormhole.VM memory) { + return wormhole().parseVM(observation); + } } diff --git a/ethereum/contracts/coreRelayer/CoreRelayerMessages.sol b/ethereum/contracts/coreRelayer/CoreRelayerMessages.sol index e1eda9c..275b696 100644 --- a/ethereum/contracts/coreRelayer/CoreRelayerMessages.sol +++ b/ethereum/contracts/coreRelayer/CoreRelayerMessages.sol @@ -11,16 +11,6 @@ import "./CoreRelayerStructs.sol"; contract CoreRelayerMessages is CoreRelayerStructs, CoreRelayerGetters { using BytesLib for bytes; - function encodeDeliveryList(VAAId[] memory deliveryList) internal pure returns (bytes memory encoded) { - uint256 len = deliveryList.length; - for (uint8 i = 0; i < len;) { - encoded = abi.encodePacked(encoded, deliveryList[i].emitterAddress, deliveryList[i].sequence); - unchecked { - i += 1; - } - } - } - function encodeDeliveryInstructions(DeliveryParameters memory instructions) internal view @@ -32,12 +22,6 @@ contract CoreRelayerMessages is CoreRelayerStructs, CoreRelayerGetters { chainId(), instructions.targetAddress, instructions.targetChain, - uint16(instructions.payload.length), - instructions.payload, - uint16(instructions.chainPayload.length), - instructions.chainPayload, - uint16(instructions.deliveryList.length), - encodeDeliveryList(instructions.deliveryList), uint16(instructions.relayParameters.length), instructions.relayParameters ); @@ -104,40 +88,6 @@ contract CoreRelayerMessages is CoreRelayerStructs, CoreRelayerGetters { instructions.targetChain = encoded.toUint16(index); index += 2; - // length of payload - uint16 payloadLen = encoded.toUint16(index); - index += 2; - - // payload - instructions.payload = encoded.slice(index, payloadLen); - index += payloadLen; - - // length of chain payload - uint16 chainPayloadLen = encoded.toUint16(index); - index += 2; - - // chain payload - instructions.chainPayload = encoded.slice(index, chainPayloadLen); - index += chainPayloadLen; - - // length of the deliveryList - uint16 deliveryListLen = encoded.toUint16(index); - index += 2; - - // list of VAAs to deliver - instructions.deliveryList = new VAAId[](deliveryListLen); - for (uint16 i = 0; i < deliveryListLen;) { - instructions.deliveryList[i].emitterAddress = encoded.toBytes32(index); - index += 32; - - instructions.deliveryList[i].sequence = encoded.toUint64(index); - index += 8; - - unchecked { - i += 1; - } - } - // length of relayParameters uint16 relayParametersLen = encoded.toUint16(index); index += 2; @@ -162,10 +112,6 @@ contract CoreRelayerMessages is CoreRelayerStructs, CoreRelayerGetters { relayParams.deliveryGasLimit = encoded.toUint32(index); index += 4; - // maximum batch size - relayParams.maximumBatchSize = encoded.toUint8(index); - index += 1; - // payment made on the source chain relayParams.nativePayment = encoded.toUint256(index); index += 32; diff --git a/ethereum/contracts/coreRelayer/CoreRelayerStructs.sol b/ethereum/contracts/coreRelayer/CoreRelayerStructs.sol index 2b4636b..8d86bec 100644 --- a/ethereum/contracts/coreRelayer/CoreRelayerStructs.sol +++ b/ethereum/contracts/coreRelayer/CoreRelayerStructs.sol @@ -3,11 +3,13 @@ pragma solidity ^0.8.0; +import "../interfaces/IWormhole.sol"; + contract CoreRelayerStructs { - struct VAAId { - // VAA emitter address + struct AllowedEmitterSequence { + // wormhole emitter address bytes32 emitterAddress; - // VAA sequence + // wormhole message sequence uint64 sequence; } @@ -23,10 +25,7 @@ contract CoreRelayerStructs { struct DeliveryParameters { uint16 targetChain; bytes32 targetAddress; - bytes payload; - VAAId[] deliveryList; bytes relayParameters; - bytes chainPayload; uint32 nonce; uint8 consistencyLevel; } @@ -37,12 +36,18 @@ contract CoreRelayerStructs { uint16 fromChain; bytes32 targetAddress; uint16 targetChain; - bytes payload; - bytes chainPayload; - VAAId[] deliveryList; bytes relayParameters; } + struct InternalDeliveryParams { + IWormhole.VM2 batchVM; + DeliveryInstructions deliveryInstructions; + AllowedEmitterSequence deliveryId; + RelayParameters relayParams; + uint8 deliveryIndex; + uint16 deliveryAttempts; + } + // TODO: WIP struct RedeliveryInstructions { uint8 payloadID; // payloadID = 3; @@ -51,7 +56,7 @@ contract CoreRelayerStructs { // Point to the original delivery instruction bytes32 emitterAddress; uint64 sequence; - // Current deliverycount + // Current number of delivery attempts uint16 deliveryCount; // New Relayer-Specific Parameters bytes relayParameters; @@ -71,8 +76,6 @@ contract CoreRelayerStructs { uint8 version; // gasLimit to call the receiving contract with uint32 deliveryGasLimit; - // maximum batch size - uint8 maximumBatchSize; // the payment made on the source chain, which is later paid to the relayer uint256 nativePayment; } diff --git a/ethereum/contracts/interfaces/ICoreRelayer.sol b/ethereum/contracts/interfaces/ICoreRelayer.sol index 4c68967..6816b3d 100644 --- a/ethereum/contracts/interfaces/ICoreRelayer.sol +++ b/ethereum/contracts/interfaces/ICoreRelayer.sol @@ -4,7 +4,7 @@ pragma solidity ^0.8.0; interface ICoreRelayer { - struct VAAId { + struct AllowedEmitterSequence { // VAA emitter address bytes32 emitterAddress; // VAA sequence @@ -23,10 +23,7 @@ interface ICoreRelayer { struct DeliveryParameters { uint16 targetChain; bytes32 targetAddress; - bytes payload; - VAAId[] deliveryList; bytes relayParameters; - bytes chainPayload; uint32 nonce; uint8 consistencyLevel; } @@ -37,9 +34,6 @@ interface ICoreRelayer { uint16 fromChain; bytes32 targetAddress; uint16 targetChain; - bytes payload; - bytes chainPayload; - VAAId[] deliveryList; bytes relayParameters; } @@ -59,7 +53,7 @@ interface ICoreRelayer { bytes32 batchHash; } - function estimateCost(uint16 chainId, uint256 gasLimit) external view returns (uint256 gasEstimate); + function estimateEvmCost(uint16 chainId, uint256 gasLimit) external view returns (uint256 gasEstimate); function send(DeliveryParameters memory deliveryParams) external payable returns (uint64 sequence); diff --git a/ethereum/contracts/interfaces/IWormhole.sol b/ethereum/contracts/interfaces/IWormhole.sol index 75628ea..54adeae 100644 --- a/ethereum/contracts/interfaces/IWormhole.sol +++ b/ethereum/contracts/interfaces/IWormhole.sol @@ -59,8 +59,8 @@ interface IWormhole { bytes32[] hashes; // Computed batch hash - hash(hash(Observation1), hash(Observation2), ...) bytes32 hash; - // Array of IndexedObservations - IndexedObservation[] indexedObservations; + // Array of observations with prepended version 3 + bytes[] observations; } event LogMessagePublished( diff --git a/ethereum/contracts/mock/MockRelayerIntegration.sol b/ethereum/contracts/mock/MockRelayerIntegration.sol index c959653..1cb1a64 100644 --- a/ethereum/contracts/mock/MockRelayerIntegration.sol +++ b/ethereum/contracts/mock/MockRelayerIntegration.sol @@ -19,9 +19,6 @@ contract MockRelayerIntegration { // deployer of this contract address immutable owner; - // trusted mock integration contracts - mapping(uint16 => bytes32) trustedSenders; - // map that stores payloads from received VAAs mapping(bytes32 => bytes) verifiedPayloads; @@ -32,7 +29,7 @@ contract MockRelayerIntegration { } function estimateRelayCosts(uint16 targetChainId, uint256 targetGasLimit) public view returns (uint256) { - return relayer.estimateCost(targetChainId, targetGasLimit); + return relayer.estimateEvmCost(targetChainId, targetGasLimit); } struct RelayerArgs { @@ -41,22 +38,56 @@ contract MockRelayerIntegration { address targetAddress; uint32 targetGasLimit; uint8 consistencyLevel; - uint8[] deliveryListIndices; + } + + function doStuff(uint32 batchNonce, bytes[] calldata payload, uint8[] calldata consistencyLevel) + public + payable + returns (uint64[] memory sequences) + { + // cache the payload count to save on gas + uint256 numInputPayloads = payload.length; + require(numInputPayloads == consistencyLevel.length, "invalid input parameters"); + + // Cache the wormhole fee to save on gas costs. Then make sure the user sent + // enough native asset to cover the cost of delivery (plus the cost of generating wormhole messages). + uint256 wormholeFee = wormhole.messageFee(); + require(msg.value >= wormholeFee * (numInputPayloads + 1)); + + // Create an array to store the wormhole message sequences. Add + // a slot for the relay message sequence. + sequences = new uint64[](numInputPayloads + 1); + + // send each wormhole message and save the message sequence + uint256 messageIdx = 0; + bytes memory verifyingPayload = abi.encodePacked(wormhole.chainId(), uint8(numInputPayloads)); + for (; messageIdx < numInputPayloads;) { + sequences[messageIdx] = wormhole.publishMessage{value: wormholeFee}( + batchNonce, payload[messageIdx], consistencyLevel[messageIdx] + ); + + verifyingPayload = abi.encodePacked(verifyingPayload, emitterAddress(), sequences[messageIdx]); + unchecked { + messageIdx += 1; + } + } + + // Encode app-relevant info regarding the input payloads. + // All we care about is source chain id and number of input payloads. + sequences[messageIdx] = wormhole.publishMessage{value: wormholeFee}( + batchNonce, + verifyingPayload, + 1 // consistencyLevel + ); } function sendBatchToTargetChain( bytes[] calldata payload, uint8[] calldata consistencyLevel, RelayerArgs memory relayerArgs - ) - public - payable - returns (uint64[] memory messageSequences) - { - // cache the payload count to save on gas - uint256 numPayloads = payload.length; - - require(numPayloads == consistencyLevel.length, "invalid input parameters"); + ) public payable returns (uint64 relayerMessageSequence) { + uint64[] memory doStuffSequences = doStuff(relayerArgs.nonce, payload, consistencyLevel); + uint256 numMessageSequences = doStuffSequences.length; // estimate the cost of sending the batch based on the user specified gas limit uint256 gasEstimate = estimateRelayCosts(relayerArgs.targetChainId, relayerArgs.targetGasLimit); @@ -64,76 +95,78 @@ contract MockRelayerIntegration { // Cache the wormhole fee to save on gas costs. Then make sure the user sent // enough native asset to cover the cost of delivery (plus the cost of generating wormhole messages). uint256 wormholeFee = wormhole.messageFee(); - require(msg.value >= gasEstimate + wormholeFee * numPayloads); - - // Create an array to store the wormhole message sequences. Add - // a slot for the relay message sequence. - messageSequences = new uint64[](numPayloads+1); - - // create the deliveryList - uint256 deliveryListLength = relayerArgs.deliveryListIndices.length; - ICoreRelayer.VAAId[] memory deliveryList = new ICoreRelayer.VAAId[](deliveryListLength); - - // send each wormhole message and save the message sequence - for (uint256 i = 0; i < numPayloads; i++) { - messageSequences[i] = - wormhole.publishMessage{value: wormholeFee}(relayerArgs.nonce, payload[i], consistencyLevel[i]); - - // add to delivery list based on the index (if indices are specified) - for (uint256 j = 0; j < deliveryListLength; j++) { - if (i == relayerArgs.deliveryListIndices[j]) { - deliveryList[j] = ICoreRelayer.VAAId({ - emitterAddress: bytes32(uint256(uint160(address(this)))), - sequence: messageSequences[i] - }); - } - } - } + require(msg.value >= gasEstimate + wormholeFee * (numMessageSequences + 1)); // encode the relay parameters - bytes memory relayParameters = - abi.encodePacked(uint8(1), relayerArgs.targetGasLimit, uint8(numPayloads), gasEstimate); + bytes memory relayParameters = abi.encodePacked(uint8(1), relayerArgs.targetGasLimit, gasEstimate); // create the relayer params to call the relayer with ICoreRelayer.DeliveryParameters memory deliveryParams = ICoreRelayer.DeliveryParameters({ targetChain: relayerArgs.targetChainId, targetAddress: bytes32(uint256(uint160(relayerArgs.targetAddress))), - payload: new bytes(0), - deliveryList: deliveryList, - relayParameters: relayParameters, - chainPayload: new bytes(0), + relayParameters: relayParameters, // REVIEW: rename to encodedRelayParameters? nonce: relayerArgs.nonce, consistencyLevel: relayerArgs.consistencyLevel }); // call the relayer contract and save the sequence. - messageSequences[numPayloads] = relayer.send{value: gasEstimate}(deliveryParams); - - return messageSequences; + relayerMessageSequence = relayer.send{value: gasEstimate}(deliveryParams); } - function wormholeReceiver( - IWormhole.VM[] memory vmList, - uint16 sourceChain, - bytes32 sourceAddress, - bytes memory payload - ) + struct EmitterSequence { + bytes32 emitter; + uint64 sequence; + } + + function parseVerifyingMessage(bytes memory verifyingObservation, uint256 numObservations) public + returns (EmitterSequence[] memory emitterSequences) { - // make sure the caller is a trusted relayer contract - require(msg.sender == address(relayer), "caller not trusted"); + (IWormhole.VM memory parsed, bool valid, string memory reason) = wormhole.parseAndVerifyVM(verifyingObservation); + require(valid, reason); - // make sure the sender of the batch is a trusted contract - require(sourceAddress == trustedSender(sourceChain), "batch sender not trusted"); + bytes memory payload = parsed.payload; + require(payload.toUint16(0) == parsed.emitterChainId, "source chain != emitterChainId"); + require(uint256(payload.toUint8(2)) == numObservations, "incorrect number of observations"); - // loop through the array of VMs and store each payload - uint256 vmCount = vmList.length; - for (uint256 i = 0; i < vmCount;) { - (bool valid, string memory reason) = wormhole.verifyVM(vmList[i]); + verifiedPayloads[parsed.hash] = payload; + + // TODO: instead of returning VM, return a struct that has info to verify observations + emitterSequences = new EmitterSequence[](numObservations); + uint256 index = 3; + for (uint256 i = 0; i < numObservations;) { + emitterSequences[i].emitter = payload.toBytes32(index); + unchecked { + index += 32; + } + emitterSequences[i].sequence = payload.toUint64(index); + unchecked { + index += 8; + } + unchecked { + i += 1; + } + } + require(payload.length == index, "payload.length != index"); + } + + function receiveWormholeMessages(bytes[] memory wormholeObservations) public { + // loop through the array of wormhole observations from the batch and store each payload + uint256 numObservations = wormholeObservations.length - 1; + + EmitterSequence[] memory emitterSequences = + parseVerifyingMessage(wormholeObservations[numObservations], numObservations); + + for (uint256 i = 0; i < numObservations;) { + (IWormhole.VM memory parsed, bool valid, string memory reason) = + wormhole.parseAndVerifyVM(wormholeObservations[i]); require(valid, reason); - // save the payload from each VAA - verifiedPayloads[vmList[i].hash] = vmList[i].payload; + require(emitterSequences[i].emitter == parsed.emitterAddress, "verifying emitter != emitterAddress"); + require(emitterSequences[i].sequence == parsed.sequence, "verifying sequence != sequence"); + + // save the payload from each wormhole message + verifiedPayloads[parsed.hash] = parsed.payload; unchecked { i += 1; @@ -141,17 +174,6 @@ contract MockRelayerIntegration { } } - // setters - function registerTrustedSender(uint16 chainId, bytes32 senderAddress) public { - require(msg.sender == owner, "caller must be the owner"); - trustedSenders[chainId] = senderAddress; - } - - // getters - function trustedSender(uint16 chainId) public view returns (bytes32) { - return trustedSenders[chainId]; - } - function getPayload(bytes32 hash) public view returns (bytes memory) { return verifiedPayloads[hash]; } @@ -160,11 +182,15 @@ contract MockRelayerIntegration { delete verifiedPayloads[hash]; } - function parseBatchVM(bytes memory encoded) public view returns (IWormhole.VM2 memory) { + function parseWormholeBatch(bytes memory encoded) public view returns (IWormhole.VM2 memory) { return wormhole.parseBatchVM(encoded); } - function parseVM(bytes memory encoded) public view returns (IWormhole.VM memory) { + function parseWormholeObservation(bytes memory encoded) public view returns (IWormhole.VM memory) { return wormhole.parseVM(encoded); } + + function emitterAddress() public view returns (bytes32) { + return bytes32(uint256(uint160(address(this)))); + } } diff --git a/ethereum/forge-test/CoreRelayer.t.sol b/ethereum/forge-test/CoreRelayer.t.sol index 0105884..4bcf4d6 100644 --- a/ethereum/forge-test/CoreRelayer.t.sol +++ b/ethereum/forge-test/CoreRelayer.t.sol @@ -34,7 +34,7 @@ contract TestCoreRelayer is CoreRelayer, Test { struct VMParams { uint32 nonce; uint8 consistencyLevel; - uint8 deliveryListCount; + uint8 batchCount; address VMEmitterAddress; address targetAddress; } @@ -83,9 +83,7 @@ contract TestCoreRelayer is CoreRelayer, Test { address wormhole_, uint16 chainId_, uint32 evmGasOverhead_ - ) - public - { + ) public { vm.assume(chainId_ > 0); vm.assume(gasOracle_ != address(0)); vm.assume(wormhole_ != address(0)); @@ -125,7 +123,7 @@ contract TestCoreRelayer is CoreRelayer, Test { gasOracle.updatePrice(SOURCE_CHAIN_ID, gasParams.sourceGasPrice, gasParams.sourceNativePrice); // estimate the cost based on the intialized values - uint256 gasEstimate = estimateCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); + uint256 gasEstimate = estimateEvmCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); // compute the expected output uint256 expectedGasEstimate = ( @@ -196,34 +194,6 @@ contract TestCoreRelayer is CoreRelayer, Test { assertEq(TARGET_CHAIN_ID, payload.toUint16(index)); index += 2; - // payload length - assertEq(deliveryParams.payload.length, payload.toUint16(index)); - index += 2; - - // payload - assertEq(deliveryParams.payload, payload.slice(index, deliveryParams.payload.length)); - index += deliveryParams.payload.length; - - // chainPayload length - assertEq(deliveryParams.chainPayload.length, payload.toUint16(index)); - index += 2; - - // chainPayload - assertEq(deliveryParams.chainPayload, payload.slice(index, deliveryParams.chainPayload.length)); - index += deliveryParams.chainPayload.length; - - // deliveryList length - assertEq(deliveryParams.deliveryList.length, payload.toUint16(index)); - index += 2; - - for (uint16 i = 0; i < deliveryParams.deliveryList.length; i++) { - assertEq(deliveryParams.deliveryList[i].emitterAddress, payload.toBytes32(index)); - index += 32; - - assertEq(deliveryParams.deliveryList[i].sequence, payload.toUint64(index)); - index += 8; - } - // relayParameters length assertEq(deliveryParams.relayParameters.length, payload.toUint16(index)); index += 2; @@ -237,14 +207,7 @@ contract TestCoreRelayer is CoreRelayer, Test { // This test confirms that the `send` method generates the correct delivery Instructions payload // to be delivered on the target chain. - function testSend( - GasParameters memory gasParams, - VMParams memory batchParams, - bytes memory relayPayload, - bytes memory chainPayload - ) - public - { + function testSend(GasParameters memory gasParams, VMParams memory batchParams) public { uint128 halfMaxUint128 = 2 ** (128 / 2) - 1; vm.assume(gasParams.evmGasOverhead > 0); vm.assume(gasParams.targetGasLimit > 0); @@ -255,8 +218,6 @@ contract TestCoreRelayer is CoreRelayer, Test { vm.assume(batchParams.targetAddress != address(0)); vm.assume(batchParams.nonce > 0); vm.assume(batchParams.consistencyLevel > 0); - vm.assume(relayPayload.length < MAX_UINT16_VALUE); - vm.assume(chainPayload.length < MAX_UINT16_VALUE); vm.assume(batchParams.VMEmitterAddress != address(0)); // initialize all contracts @@ -267,24 +228,16 @@ contract TestCoreRelayer is CoreRelayer, Test { gasOracle.updatePrice(SOURCE_CHAIN_ID, gasParams.sourceGasPrice, gasParams.sourceNativePrice); // estimate the cost based on the intialized values - uint256 gasEstimate = estimateCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); + uint256 gasEstimate = estimateEvmCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); uint256 wormholeFee = IWormhole(address(wormhole)).messageFee(); // the balance of this contract is the max Uint96 vm.assume(gasEstimate < MAX_UINT96_VALUE - wormholeFee); - // generate a random list of VAAIds for the batch - VAAId[] memory deliveryList = new VAAId[](batchParams.deliveryListCount); - for (uint8 i = 0; i < batchParams.deliveryListCount; i++) { - deliveryList[i] = - VAAId({emitterAddress: bytes32(uint256(uint160(batchParams.VMEmitterAddress))), sequence: uint64(i)}); - } - // format the relayParameters bytes memory relayParameters = abi.encodePacked( uint8(1), // version gasParams.targetGasLimit, - uint8(batchParams.deliveryListCount), // no other VAAs for this test gasEstimate ); @@ -292,10 +245,7 @@ contract TestCoreRelayer is CoreRelayer, Test { DeliveryParameters memory deliveryParams = DeliveryParameters({ targetChain: TARGET_CHAIN_ID, targetAddress: bytes32(uint256(uint160(batchParams.targetAddress))), - payload: relayPayload, - deliveryList: deliveryList, relayParameters: relayParameters, - chainPayload: chainPayload, nonce: batchParams.nonce, consistencyLevel: batchParams.consistencyLevel }); @@ -323,12 +273,7 @@ contract TestCoreRelayer is CoreRelayer, Test { // This tests confirms that the DeliveryInstructions are deserialized correctly // when calling `deliver` on the target chain. - function testDeliveryInstructionDeserialization( - GasParameters memory gasParams, - VMParams memory batchParams, - bytes memory chainPayload, - bytes memory relayPayload - ) + function testDeliveryInstructionDeserialization(GasParameters memory gasParams, VMParams memory batchParams) public { uint128 halfMaxUint128 = 2 ** (128 / 2) - 1; @@ -341,8 +286,6 @@ contract TestCoreRelayer is CoreRelayer, Test { vm.assume(batchParams.targetAddress != address(0)); vm.assume(batchParams.nonce > 0); vm.assume(batchParams.consistencyLevel > 0); - vm.assume(relayPayload.length < MAX_UINT16_VALUE); - vm.assume(chainPayload.length < MAX_UINT16_VALUE); vm.assume(batchParams.VMEmitterAddress != address(0)); // initialize all contracts @@ -353,24 +296,16 @@ contract TestCoreRelayer is CoreRelayer, Test { gasOracle.updatePrice(SOURCE_CHAIN_ID, gasParams.sourceGasPrice, gasParams.sourceNativePrice); // estimate the cost based on the intialized values - uint256 gasEstimate = estimateCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); + uint256 gasEstimate = estimateEvmCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); uint256 wormholeFee = IWormhole(address(wormhole)).messageFee(); // the balance of this contract is the max Uint96 vm.assume(gasEstimate < MAX_UINT96_VALUE - wormholeFee); - // generate a random list of VAAIds for the batch - VAAId[] memory deliveryList = new VAAId[](batchParams.deliveryListCount); - for (uint8 i = 0; i < batchParams.deliveryListCount; i++) { - deliveryList[i] = - VAAId({emitterAddress: bytes32(uint256(uint160(batchParams.VMEmitterAddress))), sequence: uint64(i)}); - } - // format the relayParameters bytes memory relayParameters = abi.encodePacked( uint8(1), // version gasParams.targetGasLimit, - uint8(batchParams.deliveryListCount), // no other VAAs for this test gasEstimate ); @@ -378,10 +313,7 @@ contract TestCoreRelayer is CoreRelayer, Test { DeliveryParameters memory deliveryParams = DeliveryParameters({ targetChain: TARGET_CHAIN_ID, targetAddress: bytes32(uint256(uint160(batchParams.targetAddress))), - payload: relayPayload, - deliveryList: deliveryList, relayParameters: relayParameters, - chainPayload: chainPayload, nonce: batchParams.nonce, consistencyLevel: batchParams.consistencyLevel }); @@ -398,15 +330,7 @@ contract TestCoreRelayer is CoreRelayer, Test { assertEq(SOURCE_CHAIN_ID, instructions.fromChain); assertEq(deliveryParams.targetAddress, instructions.targetAddress); assertEq(TARGET_CHAIN_ID, instructions.targetChain); - assertEq(deliveryParams.payload, instructions.payload); - assertEq(deliveryParams.chainPayload, instructions.chainPayload); assertEq(deliveryParams.relayParameters, instructions.relayParameters); - - // check the values in the delivery list - for (uint8 i = 0; i < batchParams.deliveryListCount; i++) { - assertEq(deliveryParams.deliveryList[i].emitterAddress, instructions.deliveryList[i].emitterAddress); - assertEq(deliveryParams.deliveryList[i].sequence, instructions.deliveryList[i].sequence); - } } // This tests confirms that the DeliveryInstructions are deserialized correctly @@ -429,24 +353,16 @@ contract TestCoreRelayer is CoreRelayer, Test { gasOracle.updatePrice(SOURCE_CHAIN_ID, gasParams.sourceGasPrice, gasParams.sourceNativePrice); // estimate the cost based on the intialized values - uint256 gasEstimate = estimateCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); + uint256 gasEstimate = estimateEvmCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); uint256 wormholeFee = IWormhole(address(wormhole)).messageFee(); // the balance of this contract is the max Uint96 vm.assume(gasEstimate < MAX_UINT96_VALUE - wormholeFee); - // generate a random list of VAAIds for the batch - VAAId[] memory deliveryList = new VAAId[](batchParams.deliveryListCount); - for (uint8 i = 0; i < batchParams.deliveryListCount; i++) { - deliveryList[i] = - VAAId({emitterAddress: bytes32(uint256(uint160(batchParams.VMEmitterAddress))), sequence: uint64(i)}); - } - // format the relayParameters bytes memory encodedRelayParameters = abi.encodePacked( uint8(1), // version gasParams.targetGasLimit, - uint8(batchParams.deliveryListCount), // no other VAAs for this test gasEstimate ); @@ -456,7 +372,6 @@ contract TestCoreRelayer is CoreRelayer, Test { // confirm the values were parsed correctly assertEq(uint8(1), decodedRelayParams.version); assertEq(gasParams.targetGasLimit, decodedRelayParams.deliveryGasLimit); - assertEq(uint8(batchParams.deliveryListCount), decodedRelayParams.maximumBatchSize); assertEq(gasEstimate, decodedRelayParams.nativePayment); } @@ -480,24 +395,16 @@ contract TestCoreRelayer is CoreRelayer, Test { gasOracle.updatePrice(SOURCE_CHAIN_ID, gasParams.sourceGasPrice, gasParams.sourceNativePrice); // estimate the cost based on the intialized values - uint256 gasEstimate = estimateCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); + uint256 gasEstimate = estimateEvmCost(TARGET_CHAIN_ID, gasParams.targetGasLimit); uint256 wormholeFee = IWormhole(address(wormhole)).messageFee(); // the balance of this contract is the max Uint96 vm.assume(gasEstimate < MAX_UINT96_VALUE - wormholeFee); - // generate a random list of VAAIds for the batch - VAAId[] memory deliveryList = new VAAId[](batchParams.deliveryListCount); - for (uint8 i = 0; i < batchParams.deliveryListCount; i++) { - deliveryList[i] = - VAAId({emitterAddress: bytes32(uint256(uint160(batchParams.VMEmitterAddress))), sequence: uint64(i)}); - } - // format the relayParameters (add random bytes to the relayerParams) bytes memory encodedRelayParameters = abi.encodePacked( uint8(1), // version gasParams.targetGasLimit, - uint8(batchParams.deliveryListCount), // no other VAAs for this test gasEstimate, gasEstimate ); diff --git a/ethereum/ts-test/2_core_relayer.ts b/ethereum/ts-test/2_core_relayer.ts index ad941bb..747bce9 100644 --- a/ethereum/ts-test/2_core_relayer.ts +++ b/ethereum/ts-test/2_core_relayer.ts @@ -1,7 +1,7 @@ -import { expect } from "chai"; -import { ethers } from "ethers"; -import { TargetDeliveryParameters, TestResults } from "./helpers/structs"; -import { ChainId, tryNativeToHexString } from "@certusone/wormhole-sdk"; +import {expect} from "chai"; +import {ethers} from "ethers"; +import {TargetDeliveryParameters, TestResults} from "./helpers/structs"; +import {ChainId, tryNativeToHexString} from "@certusone/wormhole-sdk"; import { CHAIN_ID_ETH, CORE_RELAYER_ADDRESS, @@ -9,11 +9,10 @@ import { RELAYER_DEPLOYER_PRIVATE_KEY, MOCK_RELAYER_INTEGRATION_ADDRESS, } from "./helpers/consts"; -import { makeContract } from "./helpers/io"; +import {makeContract} from "./helpers/io"; import { getSignedBatchVaaFromReceiptOnEth, getSignedVaaFromReceiptOnEth, - removeObservationFromBatch, verifyDeliveryStatusPayload, } from "./helpers/utils"; @@ -72,20 +71,6 @@ describe("Core Relayer Integration Test", () => { expect(actualRegisteredRelayer).to.equal(expectedRegisteredRelayer); }); - it("Register trusted senders in the mock integration contract", async () => { - // create hex address for the mock contract - const targetMockContractAddressBytes = "0x" + tryNativeToHexString(mockContract.address, TARGET_CHAIN_ID); - - // register the trusted sender with the mock integration contract - await mockContract - .registerTrustedSender(TARGET_CHAIN_ID, targetMockContractAddressBytes) - .then((tx: ethers.ContractTransaction) => tx.wait()); - - // query the mock integration contract to confirm the trusted sender registration worked - const trustedSender = await mockContract.trustedSender(TARGET_CHAIN_ID); - expect(trustedSender).to.equal(targetMockContractAddressBytes); - }); - it("Should update EVM deliver gas overhead", async () => { // the new evmGasOverhead value const newEvmGasOverhead = 500000; @@ -104,7 +89,7 @@ describe("Core Relayer Integration Test", () => { it("Should create a batch VAA with a DeliveryInstructions VAA", async () => { // estimate the cost of submitting the batch on the target chain - fullBatchTest.targetChainGasEstimate = await coreRelayer.estimateCost(TARGET_CHAIN_ID, TARGET_GAS_LIMIT); + fullBatchTest.targetChainGasEstimate = await coreRelayer.estimateEvmCost(TARGET_CHAIN_ID, TARGET_GAS_LIMIT); // relayer args fullBatchTest.relayerArgs = { @@ -113,7 +98,6 @@ describe("Core Relayer Integration Test", () => { targetAddress: TARGET_CONTRACT_ADDRESS, targetGasLimit: TARGET_GAS_LIMIT, consistencyLevel: deliveryVAAConsistencyLevel, - deliveryListIndices: [] as number[], }; // call the mock integration contract to create a batch @@ -133,19 +117,28 @@ describe("Core Relayer Integration Test", () => { it("Should deserialize and validate the full batch DeliveryInstructions VAA values", async () => { // parse the batchVM and verify the values - const parsedBatchVM = await mockContract.parseBatchVM(fullBatchTest.signedBatchVM); + const parsedBatchVM = await mockContract.parseWormholeBatch(fullBatchTest.signedBatchVM); // validate the individual messages - const batchLen = parsedBatchVM.indexedObservations.length; - for (let i = 0; i < batchLen - 1; i++) { - const parsedVM = await parsedBatchVM.indexedObservations[i].vm3; + const observations = parsedBatchVM.observations; + const batchLen = parsedBatchVM.observations.length; + for (let i = 0; i < batchLen - 2; ++i) { + const parsedVM = await mockContract.parseWormholeObservation(observations[i]); expect(parsedVM.nonce).to.equal(batchNonce); expect(parsedVM.consistencyLevel).to.equal(batchVAAConsistencyLevels[i]); expect(parsedVM.payload).to.equal(batchVAAPayloads[i]); } + // validate the mock integration instructions + const integratorMessage = await mockContract.parseWormholeObservation(observations[batchLen - 2]); + expect(integratorMessage.nonce).to.equal(batchNonce); + expect(integratorMessage.consistencyLevel).to.equal(1); + const integratorMessagePayload = Buffer.from(ethers.utils.arrayify(integratorMessage.payload)); + expect(integratorMessagePayload.readUInt16BE(0)).to.equal(2); + expect(integratorMessagePayload.readUInt8(2)).to.equal(batchLen - 2); + // validate the delivery instructions VAA - const deliveryVM = parsedBatchVM.indexedObservations[batchLen - 1].vm3; + const deliveryVM = await mockContract.parseWormholeObservation(observations[batchLen - 1]); expect(deliveryVM.nonce).to.equal(batchNonce); expect(deliveryVM.consistencyLevel).to.equal(fullBatchTest.relayerArgs.consistencyLevel); @@ -160,15 +153,11 @@ describe("Core Relayer Integration Test", () => { "0x" + tryNativeToHexString(TARGET_CONTRACT_ADDRESS, CHAIN_ID_ETH) ); expect(deliveryInstructions.targetChain).to.equal(TARGET_CHAIN_ID); - expect(deliveryInstructions.payload).to.equal("0x"); - expect(deliveryInstructions.chainPayload).to.equal("0x"); - expect(deliveryInstructions.deliveryList.length).to.equal(0); // deserialize the deliveryParameters and confirm the values const relayParameters = await coreRelayer.decodeRelayParameters(deliveryInstructions.relayParameters); expect(relayParameters.version).to.equal(1); expect(relayParameters.deliveryGasLimit).to.equal(TARGET_GAS_LIMIT); - expect(relayParameters.maximumBatchSize).to.equal(batchVAAPayloads.length); expect(relayParameters.nativePayment.toString()).to.equal(fullBatchTest.targetChainGasEstimate.toString()); }); @@ -176,7 +165,7 @@ describe("Core Relayer Integration Test", () => { // create the TargetDeliveryParameters const targetDeliveryParams: TargetDeliveryParameters = { encodedVM: fullBatchTest.signedBatchVM, - deliveryIndex: batchVAAPayloads.length, + deliveryIndex: batchVAAPayloads.length + 1, targetCallGasOverride: ethers.BigNumber.from(TARGET_GAS_LIMIT), }; @@ -186,10 +175,12 @@ describe("Core Relayer Integration Test", () => { .then((tx: ethers.ContractTransaction) => tx.wait()); // confirm that the batch VAA payloads were stored in a map in the mock contract - const parsedBatchVM = await mockContract.parseBatchVM(fullBatchTest.signedBatchVM); - const batchLen = parsedBatchVM.indexedObservations.length; - for (let i = 0; i < batchLen - 1; i++) { - const parsedVM = parsedBatchVM.indexedObservations[i].vm3; + const parsedBatchVM = await mockContract.parseWormholeBatch(fullBatchTest.signedBatchVM); + + const observations = parsedBatchVM.observations; + const batchLen = observations.length; + for (let i = 0; i < batchLen - 1; ++i) { + const parsedVM = await mockContract.parseWormholeObservation(observations[i]); // query the contract for the saved payload const verifiedPayload = await mockContract.getPayload(parsedVM.hash); @@ -213,15 +204,14 @@ describe("Core Relayer Integration Test", () => { it("Should correctly emit a DeliveryStatus message upon full batch delivery", async () => { // parse the delivery status VAA payload - const parsedDeliveryStatus = await mockContract.parseVM(fullBatchTest.deliveryStatusVM); + const parsedDeliveryStatus = await mockContract.parseWormholeObservation(fullBatchTest.deliveryStatusVM); const deliveryStatusPayload = parsedDeliveryStatus.payload; // parse the batch VAA (need to use the batch hash) - const parsedBatchVM = await mockContract.parseBatchVM(fullBatchTest.signedBatchVM); + const parsedBatchVM = await mockContract.parseWormholeBatch(fullBatchTest.signedBatchVM); // grab the deliveryVM index, which is the last VM in the batch - const deliveryVMIndex = parsedBatchVM.indexedObservations.length - 1; - const deliveryVM = parsedBatchVM.indexedObservations[deliveryVMIndex].vm3; + const deliveryVM = await mockContract.parseWormholeObservation(parsedBatchVM.observations.at(-1)!); // expected values in the DeliveryStatus payload const expectedDeliveryAttempts = 1; @@ -243,198 +233,5 @@ describe("Core Relayer Integration Test", () => { const queriedRelayerFees = await coreRelayer.relayerRewards(wallet.address, TARGET_CHAIN_ID); expect(queriedRelayerFees.toString()).to.equal(fullBatchTest.targetChainGasEstimate.toString()); }); - - it("Should create a batch VAA with a DeliveryInstructions VAA (with a VAAId deliveryList)", async () => { - // estimate the gas of submitting the partial batch on the target chain - partialBatchTest.targetChainGasEstimate = await coreRelayer.estimateCost(TARGET_CHAIN_ID, TARGET_GAS_LIMIT); - - // randomly select four indices to put in the delivery list (not including the delivery VAA) - let deliveryListIndices: number[] = []; - for (let i = 0; i < batchVAAPayloads.length; i++) { - deliveryListIndices.push(i); - } - deliveryListIndices = deliveryListIndices.sort(() => 0.5 - Math.random()).slice(4); - - // relayer args - partialBatchTest.relayerArgs = { - nonce: batchNonce, - targetChainId: TARGET_CHAIN_ID, - targetAddress: TARGET_CONTRACT_ADDRESS, - targetGasLimit: TARGET_GAS_LIMIT, - consistencyLevel: deliveryVAAConsistencyLevel, - deliveryListIndices: deliveryListIndices, - }; - - // call the mock integration contract to create a batch - const sendReceipt: ethers.ContractReceipt = await mockContract - .sendBatchToTargetChain(batchVAAPayloads, batchVAAConsistencyLevels, partialBatchTest.relayerArgs, { - value: partialBatchTest.targetChainGasEstimate, - }) - .then((tx: ethers.ContractTransaction) => tx.wait()); - - // fetch the signedBatchVAA - partialBatchTest.signedBatchVM = await getSignedBatchVaaFromReceiptOnEth( - sendReceipt, - SOURCE_CHAIN_ID as ChainId, - 0 // guardianSetIndex - ); - }); - - it("Should deserialize and validate the partial batch DeliveryInstructions VAA values", async () => { - // parse the batchVM and verify the values - const parsedBatchVM = await mockContract.parseBatchVM(partialBatchTest.signedBatchVM); - - // validate the individual messages - const batchLen = parsedBatchVM.indexedObservations.length; - for (let i = 0; i < batchLen - 1; i++) { - const parsedVM = await parsedBatchVM.indexedObservations[i].vm3; - expect(parsedVM.nonce).to.equal(batchNonce); - expect(parsedVM.consistencyLevel).to.equal(batchVAAConsistencyLevels[i]); - expect(parsedVM.payload).to.equal(batchVAAPayloads[i]); - } - - // validate the delivery instructions VAA - const deliveryVM = parsedBatchVM.indexedObservations[batchLen - 1].vm3; - expect(deliveryVM.nonce).to.equal(batchNonce); - expect(deliveryVM.consistencyLevel).to.equal(partialBatchTest.relayerArgs.consistencyLevel); - - // deserialize the delivery instruction payload and validate the values - const deliveryInstructions = await coreRelayer.decodeDeliveryInstructions(deliveryVM.payload); - expect(deliveryInstructions.payloadID).to.equal(1); - expect(deliveryInstructions.fromAddress).to.equal( - "0x" + tryNativeToHexString(SOURCE_CONTRACT_ADDRESS, CHAIN_ID_ETH) - ); - expect(deliveryInstructions.fromChain).to.equal(SOURCE_CHAIN_ID); - expect(deliveryInstructions.targetAddress).to.equal( - "0x" + tryNativeToHexString(TARGET_CONTRACT_ADDRESS, CHAIN_ID_ETH) - ); - expect(deliveryInstructions.targetChain).to.equal(TARGET_CHAIN_ID); - expect(deliveryInstructions.payload).to.equal("0x"); - expect(deliveryInstructions.chainPayload).to.equal("0x"); - expect(deliveryInstructions.deliveryList.length).to.equal(4); - - // deserialize the deliveryParameters and confirm the values - const relayParameters = await coreRelayer.decodeRelayParameters(deliveryInstructions.relayParameters); - expect(relayParameters.version).to.equal(1); - expect(relayParameters.deliveryGasLimit).to.equal(TARGET_GAS_LIMIT); - expect(relayParameters.maximumBatchSize).to.equal(batchVAAPayloads.length); - expect(relayParameters.nativePayment.toString()).to.equal(partialBatchTest.targetChainGasEstimate.toString()); - }); - - it("Should create a partial batch based on the deliveryList in the DeliveryInstructions VAA", async () => { - // parse the batchVM and deserialize the DeliveryInstructions - const parsedBatchVM = await mockContract.parseBatchVM(partialBatchTest.signedBatchVM); - - // Delivery VAA starting index (before pruning the batch). It should be the - // last VAA in the batch. - const deliveryVAAIndex: number = batchVAAPayloads.length; - - // The delivery VAA is the last message in the batch. Relayers will not know this, - // and will have to iterate through the batch to find the VAAId. - const deliveryInstructionsPayload = await coreRelayer.decodeDeliveryInstructions( - parsedBatchVM.indexedObservations[deliveryVAAIndex].vm3.payload - ); - - // Loop through the deliveryList in the DeliveryInstructions and find the indices to deliver. Store - // the delivery index to make sure that it is not removed from the batch. - let indicesToKeep: number[] = [deliveryVAAIndex]; - for (const deliveryId of deliveryInstructionsPayload.deliveryList) { - for (const indexedObservations of parsedBatchVM.indexedObservations) { - let vm3 = indexedObservations.vm3; - if ( - vm3.emitterAddress == deliveryId.emitterAddress && - vm3.sequence.toString() == deliveryId.sequence.toString() - ) { - indicesToKeep.push(indexedObservations.index); - } - } - } - - // prune the batch - for (const indexedObservations of parsedBatchVM.indexedObservations) { - const index = indexedObservations.index; - if (!indicesToKeep.includes(index)) { - // prune the batch - partialBatchTest.signedBatchVM = removeObservationFromBatch(index, partialBatchTest.signedBatchVM); - } - } - - // confirm that the indices that we care about are still in the VAA - const prunedBatchVM = await mockContract.parseBatchVM(partialBatchTest.signedBatchVM); - for (const indexedObservations of prunedBatchVM.indexedObservations) { - expect(indicesToKeep.includes(indexedObservations.index)).to.be.true; - } - }); - - it("Should deliver the partial batch VAA and call the wormholeReceiver endpoint on the mock contract", async () => { - // The delivery VAA index has changed since the batch was pruned, find the new delivery VAA index. - // It should still be the last VAA in the batch. - const prunedBatchVM = await mockContract.parseBatchVM(partialBatchTest.signedBatchVM); - const deliveryVAAIndex = prunedBatchVM.indexedObservations.length - 1; - expect(prunedBatchVM.indexedObservations[deliveryVAAIndex].vm3.emitterAddress).to.equal(RELAYER_EMITTER_ADDRESS); - - // create the TargetDeliveryParameters - const targetDeliveryParams: TargetDeliveryParameters = { - encodedVM: partialBatchTest.signedBatchVM, - deliveryIndex: deliveryVAAIndex, - targetCallGasOverride: ethers.BigNumber.from(TARGET_GAS_LIMIT), - }; - - // call the deliver method on the relayer contract - const deliveryReceipt: ethers.ContractReceipt = await coreRelayer - .deliver(targetDeliveryParams) - .then((tx: ethers.ContractTransaction) => tx.wait()); - - // confirm that the batch VM payloads were stored in a map in the mock contract - const batchLen = prunedBatchVM.indexedObservations.length; - for (let i = 0; i < batchLen - 1; i++) { - const parsedVM = prunedBatchVM.indexedObservations[i].vm3; - - // query the contract for the saved payload - const verifiedPayload = await mockContract.getPayload(parsedVM.hash); - expect(verifiedPayload).to.equal(parsedVM.payload); - - // clear the payload from storage for future tests - await mockContract.clearPayload(parsedVM.hash).then((tx: ethers.ContractTransaction) => tx.wait()); - - // confirm that the payload was cleared - const emptyPayload = await mockContract.getPayload(parsedVM.hash); - expect(emptyPayload).to.equal("0x"); - } - - // fetch and save the delivery status VAA - partialBatchTest.deliveryStatusVM = await getSignedVaaFromReceiptOnEth( - deliveryReceipt, - TARGET_CHAIN_ID, - 0 // guardianSetIndex - ); - }); - - it("Should correctly emit a DeliveryStatus message upon partial batch delivery", async () => { - // parse the VM payload - const parsedDeliveryStatus = await mockContract.parseVM(partialBatchTest.deliveryStatusVM); - const deliveryStatusPayload = parsedDeliveryStatus.payload; - - // parse the batch VAA (need to use the batch hash) - const parsedBatchVM = await mockContract.parseBatchVM(partialBatchTest.signedBatchVM); - - // grab the deliveryVM based, which is the last VM in the batch - const deliveryVMIndex = parsedBatchVM.indexedObservations.length - 1; - const deliveryVM = parsedBatchVM.indexedObservations[deliveryVMIndex].vm3; - - // expected values in the DeliveryStatus payload - const expectedDeliveryAttempts = 1; - const expectedSuccessBoolean = 1; - - const success = verifyDeliveryStatusPayload( - deliveryStatusPayload, - parsedBatchVM.hash, - RELAYER_EMITTER_ADDRESS, - deliveryVM.sequence, - expectedDeliveryAttempts, - expectedSuccessBoolean - ); - expect(success).to.be.true; - }); }); }); diff --git a/ethereum/ts-test/helpers/structs.ts b/ethereum/ts-test/helpers/structs.ts index 0254742..c8c5b12 100644 --- a/ethereum/ts-test/helpers/structs.ts +++ b/ethereum/ts-test/helpers/structs.ts @@ -6,7 +6,6 @@ export interface RelayerArgs { targetAddress: string; targetGasLimit: number; consistencyLevel: number; - deliveryListIndices: number[]; } export interface TargetDeliveryParameters { diff --git a/ethereum/ts-test/helpers/utils.ts b/ethereum/ts-test/helpers/utils.ts index f16e5ce..953497a 100644 --- a/ethereum/ts-test/helpers/utils.ts +++ b/ethereum/ts-test/helpers/utils.ts @@ -1,6 +1,6 @@ -import {ethers} from "ethers"; -import {ChainId, tryNativeToHexString} from "@certusone/wormhole-sdk"; -import {WORMHOLE_MESSAGE_EVENT_ABI, GUARDIAN_PRIVATE_KEY} from "./consts"; +import { ethers } from "ethers"; +import { ChainId, tryNativeToHexString } from "@certusone/wormhole-sdk"; +import { WORMHOLE_MESSAGE_EVENT_ABI, GUARDIAN_PRIVATE_KEY } from "./consts"; const elliptic = require("elliptic"); export async function parseWormholeEventsFromReceipt( @@ -84,7 +84,7 @@ export async function getSignedBatchVaaFromReceiptOnEth( // sign the batchHash const ec = new elliptic.ec("secp256k1"); const key = ec.keyFromPrivate(GUARDIAN_PRIVATE_KEY); - const signature = key.sign(batchHash.substring(2), {canonical: true}); + const signature = key.sign(batchHash.substring(2), { canonical: true }); // create the signature const packSig = [ @@ -153,7 +153,7 @@ export async function getSignedVaaFromReceiptOnEth( // sign the batchHash const ec = new elliptic.ec("secp256k1"); const key = ec.keyFromPrivate(GUARDIAN_PRIVATE_KEY); - const signature = key.sign(hash.substring(2), {canonical: true}); + const signature = key.sign(hash.substring(2), { canonical: true }); // create the signature const packSig = [ @@ -275,10 +275,10 @@ export function verifyDeliveryStatusPayload( console.log("Invalid batch hash"); return false; } else if (emitterAddress != relayerAddress) { - console.log("Invalid emitter address in delivery VAAId"); + console.log("Invalid emitter address in delivery AllowedEmitterSequenceedEmitterSequence"); return false; } else if (sequence != deliverySequence) { - console.log("Invalid emitter address in delivery VAAId"); + console.log("Invalid emitter address in delivery AllowedEmitterSequenceedEmitterSequence"); return false; } else if (deliveryCount != deliveryAttempts) { console.log("Invalid number of delivery attempts"); diff --git a/offchain-relayer/.gitignore b/offchain-relayer/.gitignore new file mode 100644 index 0000000..12137a3 --- /dev/null +++ b/offchain-relayer/.gitignore @@ -0,0 +1,2 @@ +.relayer.yaml +relay/ethereum/core_relayer/abi.go diff --git a/offchain-relayer/get-addresses.sh b/offchain-relayer/get-addresses.sh index d74273a..1a15f52 100755 --- a/offchain-relayer/get-addresses.sh +++ b/offchain-relayer/get-addresses.sh @@ -1,6 +1,7 @@ #!/usr/bin/env bash set -exuo pipefail +cat relayer.tilt.yaml > .relayer.yaml # function for updating or inserting a KEY: value pair in a file. function upsert_env_file { diff --git a/offchain-relayer/regenerate-abi.sh b/offchain-relayer/regenerate-abi.sh new file mode 100755 index 0000000..b3c8dd2 --- /dev/null +++ b/offchain-relayer/regenerate-abi.sh @@ -0,0 +1,5 @@ +#!/usr/bin/env bash +set -exuo pipefail + +cd $(dirname $0)/.. +jq '.abi' ./ethereum/build/CoreRelayer.sol/CoreRelayer.json | docker run -i --rm -v $(pwd):/root -u $(id -u):$(id -g) ethereum/client-go:alltools-stable abigen --abi - --pkg core_relayer --type CoreRelayer --out /root/offchain-relayer/relay/ethereum/core_relayer/abi.go \ No newline at end of file diff --git a/offchain-relayer/relay/ethereum/core_relayer/abi.go b/offchain-relayer/relay/ethereum/core_relayer/abi.go deleted file mode 100644 index 679fe01..0000000 --- a/offchain-relayer/relay/ethereum/core_relayer/abi.go +++ /dev/null @@ -1,2040 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package core_relayer - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription -) - -// CoreRelayerStructsDeliveryInstructions is an auto generated low-level Go binding around an user-defined struct. -type CoreRelayerStructsDeliveryInstructions struct { - PayloadID uint8 - FromAddress [32]byte - FromChain uint16 - TargetAddress [32]byte - TargetChain uint16 - Payload []byte - ChainPayload []byte - DeliveryList []CoreRelayerStructsVAAId - RelayParameters []byte -} - -// CoreRelayerStructsDeliveryParameters is an auto generated low-level Go binding around an user-defined struct. -type CoreRelayerStructsDeliveryParameters struct { - TargetChain uint16 - TargetAddress [32]byte - Payload []byte - DeliveryList []CoreRelayerStructsVAAId - RelayParameters []byte - ChainPayload []byte - Nonce uint32 - ConsistencyLevel uint8 -} - -// CoreRelayerStructsRelayParameters is an auto generated low-level Go binding around an user-defined struct. -type CoreRelayerStructsRelayParameters struct { - Version uint8 - DeliveryGasLimit uint32 - MaximumBatchSize uint8 - NativePayment *big.Int -} - -// CoreRelayerStructsTargetDeliveryParameters is an auto generated low-level Go binding around an user-defined struct. -type CoreRelayerStructsTargetDeliveryParameters struct { - EncodedVM []byte - DeliveryIndex uint8 - TargetCallGasOverride uint32 -} - -// CoreRelayerStructsVAAId is an auto generated low-level Go binding around an user-defined struct. -type CoreRelayerStructsVAAId struct { - EmitterAddress [32]byte - Sequence uint64 -} - -// CoreRelayerMetaData contains all meta data concerning the CoreRelayer contract. -var CoreRelayerMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldContract\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newContract\",\"type\":\"address\"}],\"name\":\"ContractUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"oldOverhead\",\"type\":\"uint32\"},{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"newOverhead\",\"type\":\"uint32\"}],\"name\":\"EVMGasOverheadUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldOracle\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOracle\",\"type\":\"address\"}],\"name\":\"GasOracleUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransfered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"deliveryHash\",\"type\":\"bytes32\"}],\"name\":\"attemptedDeliveryCount\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"chainId\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"confirmOwnershipTransferRequest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"consistencyLevel\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encoded\",\"type\":\"bytes\"}],\"name\":\"decodeDeliveryInstructions\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"payloadID\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"fromAddress\",\"type\":\"bytes32\"},{\"internalType\":\"uint16\",\"name\":\"fromChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"targetAddress\",\"type\":\"bytes32\"},{\"internalType\":\"uint16\",\"name\":\"targetChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"chainPayload\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"emitterAddress\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"internalType\":\"structCoreRelayerStructs.VAAId[]\",\"name\":\"deliveryList\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes\",\"name\":\"relayParameters\",\"type\":\"bytes\"}],\"internalType\":\"structCoreRelayerStructs.DeliveryInstructions\",\"name\":\"instructions\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encoded\",\"type\":\"bytes\"}],\"name\":\"decodeRelayParameters\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"deliveryGasLimit\",\"type\":\"uint32\"},{\"internalType\":\"uint8\",\"name\":\"maximumBatchSize\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"nativePayment\",\"type\":\"uint256\"}],\"internalType\":\"structCoreRelayerStructs.RelayParameters\",\"name\":\"relayParams\",\"type\":\"tuple\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"encodedVM\",\"type\":\"bytes\"},{\"internalType\":\"uint8\",\"name\":\"deliveryIndex\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"targetCallGasOverride\",\"type\":\"uint32\"}],\"internalType\":\"structCoreRelayerStructs.TargetDeliveryParameters\",\"name\":\"targetParams\",\"type\":\"tuple\"}],\"name\":\"deliver\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"chainId\",\"type\":\"uint16\"},{\"internalType\":\"uint32\",\"name\":\"gasLimit\",\"type\":\"uint32\"}],\"name\":\"estimateCost\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gasEstimate\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encodedVm\",\"type\":\"bytes\"}],\"name\":\"finaliseRewardPayout\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gasOracle\",\"outputs\":[{\"internalType\":\"contractIGasOracle\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gasOracleAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getEvmGasOverhead\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"deliveryHash\",\"type\":\"bytes32\"}],\"name\":\"isDeliveryCompleted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"impl\",\"type\":\"address\"}],\"name\":\"isInitialized\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"encodedVM\",\"type\":\"bytes\"},{\"internalType\":\"uint8\",\"name\":\"deliveryIndex\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"targetCallGasOverride\",\"type\":\"uint32\"}],\"internalType\":\"structCoreRelayerStructs.TargetDeliveryParameters\",\"name\":\"targetParams\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"encodedRedeliveryVm\",\"type\":\"bytes\"}],\"name\":\"reDeliver\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"encodedVm\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"newRelayerParams\",\"type\":\"bytes\"}],\"name\":\"reSend\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"deliveryHash\",\"type\":\"bytes32\"}],\"name\":\"redeliveryAttemptCount\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"relayerChainId\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"relayerAddress\",\"type\":\"bytes32\"}],\"name\":\"registerChain\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"chain\",\"type\":\"uint16\"}],\"name\":\"registeredRelayer\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"relayer\",\"type\":\"address\"},{\"internalType\":\"uint16\",\"name\":\"rewardChain\",\"type\":\"uint16\"}],\"name\":\"relayerRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"rewardChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"receiver\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"}],\"name\":\"rewardPayout\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"uint16\",\"name\":\"targetChain\",\"type\":\"uint16\"},{\"internalType\":\"bytes32\",\"name\":\"targetAddress\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"emitterAddress\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"internalType\":\"structCoreRelayerStructs.VAAId[]\",\"name\":\"deliveryList\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes\",\"name\":\"relayParameters\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"chainPayload\",\"type\":\"bytes\"},{\"internalType\":\"uint32\",\"name\":\"nonce\",\"type\":\"uint32\"},{\"internalType\":\"uint8\",\"name\":\"consistencyLevel\",\"type\":\"uint8\"}],\"internalType\":\"structCoreRelayerStructs.DeliveryParameters\",\"name\":\"deliveryParams\",\"type\":\"tuple\"}],\"name\":\"send\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"sequence\",\"type\":\"uint64\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"thisRelayerChainId\",\"type\":\"uint16\"},{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"submitOwnershipTransferRequest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"thisRelayerChainId\",\"type\":\"uint16\"},{\"internalType\":\"uint32\",\"name\":\"newGasOverhead\",\"type\":\"uint32\"}],\"name\":\"updateEvmGasOverhead\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"thisRelayerChainId\",\"type\":\"uint16\"},{\"internalType\":\"address\",\"name\":\"newGasOracleAddress\",\"type\":\"address\"}],\"name\":\"updateGasOracleContract\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"thisRelayerChainId\",\"type\":\"uint16\"},{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgrade\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wormhole\",\"outputs\":[{\"internalType\":\"contractIWormhole\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", -} - -// CoreRelayerABI is the input ABI used to generate the binding from. -// Deprecated: Use CoreRelayerMetaData.ABI instead. -var CoreRelayerABI = CoreRelayerMetaData.ABI - -// CoreRelayer is an auto generated Go binding around an Ethereum contract. -type CoreRelayer struct { - CoreRelayerCaller // Read-only binding to the contract - CoreRelayerTransactor // Write-only binding to the contract - CoreRelayerFilterer // Log filterer for contract events -} - -// CoreRelayerCaller is an auto generated read-only Go binding around an Ethereum contract. -type CoreRelayerCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// CoreRelayerTransactor is an auto generated write-only Go binding around an Ethereum contract. -type CoreRelayerTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// CoreRelayerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type CoreRelayerFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// CoreRelayerSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type CoreRelayerSession struct { - Contract *CoreRelayer // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// CoreRelayerCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type CoreRelayerCallerSession struct { - Contract *CoreRelayerCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// CoreRelayerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type CoreRelayerTransactorSession struct { - Contract *CoreRelayerTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// CoreRelayerRaw is an auto generated low-level Go binding around an Ethereum contract. -type CoreRelayerRaw struct { - Contract *CoreRelayer // Generic contract binding to access the raw methods on -} - -// CoreRelayerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type CoreRelayerCallerRaw struct { - Contract *CoreRelayerCaller // Generic read-only contract binding to access the raw methods on -} - -// CoreRelayerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type CoreRelayerTransactorRaw struct { - Contract *CoreRelayerTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewCoreRelayer creates a new instance of CoreRelayer, bound to a specific deployed contract. -func NewCoreRelayer(address common.Address, backend bind.ContractBackend) (*CoreRelayer, error) { - contract, err := bindCoreRelayer(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &CoreRelayer{CoreRelayerCaller: CoreRelayerCaller{contract: contract}, CoreRelayerTransactor: CoreRelayerTransactor{contract: contract}, CoreRelayerFilterer: CoreRelayerFilterer{contract: contract}}, nil -} - -// NewCoreRelayerCaller creates a new read-only instance of CoreRelayer, bound to a specific deployed contract. -func NewCoreRelayerCaller(address common.Address, caller bind.ContractCaller) (*CoreRelayerCaller, error) { - contract, err := bindCoreRelayer(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &CoreRelayerCaller{contract: contract}, nil -} - -// NewCoreRelayerTransactor creates a new write-only instance of CoreRelayer, bound to a specific deployed contract. -func NewCoreRelayerTransactor(address common.Address, transactor bind.ContractTransactor) (*CoreRelayerTransactor, error) { - contract, err := bindCoreRelayer(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &CoreRelayerTransactor{contract: contract}, nil -} - -// NewCoreRelayerFilterer creates a new log filterer instance of CoreRelayer, bound to a specific deployed contract. -func NewCoreRelayerFilterer(address common.Address, filterer bind.ContractFilterer) (*CoreRelayerFilterer, error) { - contract, err := bindCoreRelayer(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &CoreRelayerFilterer{contract: contract}, nil -} - -// bindCoreRelayer binds a generic wrapper to an already deployed contract. -func bindCoreRelayer(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := abi.JSON(strings.NewReader(CoreRelayerABI)) - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_CoreRelayer *CoreRelayerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _CoreRelayer.Contract.CoreRelayerCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_CoreRelayer *CoreRelayerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CoreRelayer.Contract.CoreRelayerTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_CoreRelayer *CoreRelayerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _CoreRelayer.Contract.CoreRelayerTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_CoreRelayer *CoreRelayerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _CoreRelayer.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_CoreRelayer *CoreRelayerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CoreRelayer.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_CoreRelayer *CoreRelayerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _CoreRelayer.Contract.contract.Transact(opts, method, params...) -} - -// AttemptedDeliveryCount is a free data retrieval call binding the contract method 0x696262fc. -// -// Solidity: function attemptedDeliveryCount(bytes32 deliveryHash) view returns(uint16) -func (_CoreRelayer *CoreRelayerCaller) AttemptedDeliveryCount(opts *bind.CallOpts, deliveryHash [32]byte) (uint16, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "attemptedDeliveryCount", deliveryHash) - - if err != nil { - return *new(uint16), err - } - - out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16) - - return out0, err - -} - -// AttemptedDeliveryCount is a free data retrieval call binding the contract method 0x696262fc. -// -// Solidity: function attemptedDeliveryCount(bytes32 deliveryHash) view returns(uint16) -func (_CoreRelayer *CoreRelayerSession) AttemptedDeliveryCount(deliveryHash [32]byte) (uint16, error) { - return _CoreRelayer.Contract.AttemptedDeliveryCount(&_CoreRelayer.CallOpts, deliveryHash) -} - -// AttemptedDeliveryCount is a free data retrieval call binding the contract method 0x696262fc. -// -// Solidity: function attemptedDeliveryCount(bytes32 deliveryHash) view returns(uint16) -func (_CoreRelayer *CoreRelayerCallerSession) AttemptedDeliveryCount(deliveryHash [32]byte) (uint16, error) { - return _CoreRelayer.Contract.AttemptedDeliveryCount(&_CoreRelayer.CallOpts, deliveryHash) -} - -// ChainId is a free data retrieval call binding the contract method 0x9a8a0592. -// -// Solidity: function chainId() view returns(uint16) -func (_CoreRelayer *CoreRelayerCaller) ChainId(opts *bind.CallOpts) (uint16, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "chainId") - - if err != nil { - return *new(uint16), err - } - - out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16) - - return out0, err - -} - -// ChainId is a free data retrieval call binding the contract method 0x9a8a0592. -// -// Solidity: function chainId() view returns(uint16) -func (_CoreRelayer *CoreRelayerSession) ChainId() (uint16, error) { - return _CoreRelayer.Contract.ChainId(&_CoreRelayer.CallOpts) -} - -// ChainId is a free data retrieval call binding the contract method 0x9a8a0592. -// -// Solidity: function chainId() view returns(uint16) -func (_CoreRelayer *CoreRelayerCallerSession) ChainId() (uint16, error) { - return _CoreRelayer.Contract.ChainId(&_CoreRelayer.CallOpts) -} - -// ConsistencyLevel is a free data retrieval call binding the contract method 0xe8dfd508. -// -// Solidity: function consistencyLevel() view returns(uint8) -func (_CoreRelayer *CoreRelayerCaller) ConsistencyLevel(opts *bind.CallOpts) (uint8, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "consistencyLevel") - - if err != nil { - return *new(uint8), err - } - - out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) - - return out0, err - -} - -// ConsistencyLevel is a free data retrieval call binding the contract method 0xe8dfd508. -// -// Solidity: function consistencyLevel() view returns(uint8) -func (_CoreRelayer *CoreRelayerSession) ConsistencyLevel() (uint8, error) { - return _CoreRelayer.Contract.ConsistencyLevel(&_CoreRelayer.CallOpts) -} - -// ConsistencyLevel is a free data retrieval call binding the contract method 0xe8dfd508. -// -// Solidity: function consistencyLevel() view returns(uint8) -func (_CoreRelayer *CoreRelayerCallerSession) ConsistencyLevel() (uint8, error) { - return _CoreRelayer.Contract.ConsistencyLevel(&_CoreRelayer.CallOpts) -} - -// DecodeDeliveryInstructions is a free data retrieval call binding the contract method 0x4d92d3c9. -// -// Solidity: function decodeDeliveryInstructions(bytes encoded) pure returns((uint8,bytes32,uint16,bytes32,uint16,bytes,bytes,(bytes32,uint64)[],bytes) instructions) -func (_CoreRelayer *CoreRelayerCaller) DecodeDeliveryInstructions(opts *bind.CallOpts, encoded []byte) (CoreRelayerStructsDeliveryInstructions, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "decodeDeliveryInstructions", encoded) - - if err != nil { - return *new(CoreRelayerStructsDeliveryInstructions), err - } - - out0 := *abi.ConvertType(out[0], new(CoreRelayerStructsDeliveryInstructions)).(*CoreRelayerStructsDeliveryInstructions) - - return out0, err - -} - -// DecodeDeliveryInstructions is a free data retrieval call binding the contract method 0x4d92d3c9. -// -// Solidity: function decodeDeliveryInstructions(bytes encoded) pure returns((uint8,bytes32,uint16,bytes32,uint16,bytes,bytes,(bytes32,uint64)[],bytes) instructions) -func (_CoreRelayer *CoreRelayerSession) DecodeDeliveryInstructions(encoded []byte) (CoreRelayerStructsDeliveryInstructions, error) { - return _CoreRelayer.Contract.DecodeDeliveryInstructions(&_CoreRelayer.CallOpts, encoded) -} - -// DecodeDeliveryInstructions is a free data retrieval call binding the contract method 0x4d92d3c9. -// -// Solidity: function decodeDeliveryInstructions(bytes encoded) pure returns((uint8,bytes32,uint16,bytes32,uint16,bytes,bytes,(bytes32,uint64)[],bytes) instructions) -func (_CoreRelayer *CoreRelayerCallerSession) DecodeDeliveryInstructions(encoded []byte) (CoreRelayerStructsDeliveryInstructions, error) { - return _CoreRelayer.Contract.DecodeDeliveryInstructions(&_CoreRelayer.CallOpts, encoded) -} - -// DecodeRelayParameters is a free data retrieval call binding the contract method 0x18f6df06. -// -// Solidity: function decodeRelayParameters(bytes encoded) pure returns((uint8,uint32,uint8,uint256) relayParams) -func (_CoreRelayer *CoreRelayerCaller) DecodeRelayParameters(opts *bind.CallOpts, encoded []byte) (CoreRelayerStructsRelayParameters, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "decodeRelayParameters", encoded) - - if err != nil { - return *new(CoreRelayerStructsRelayParameters), err - } - - out0 := *abi.ConvertType(out[0], new(CoreRelayerStructsRelayParameters)).(*CoreRelayerStructsRelayParameters) - - return out0, err - -} - -// DecodeRelayParameters is a free data retrieval call binding the contract method 0x18f6df06. -// -// Solidity: function decodeRelayParameters(bytes encoded) pure returns((uint8,uint32,uint8,uint256) relayParams) -func (_CoreRelayer *CoreRelayerSession) DecodeRelayParameters(encoded []byte) (CoreRelayerStructsRelayParameters, error) { - return _CoreRelayer.Contract.DecodeRelayParameters(&_CoreRelayer.CallOpts, encoded) -} - -// DecodeRelayParameters is a free data retrieval call binding the contract method 0x18f6df06. -// -// Solidity: function decodeRelayParameters(bytes encoded) pure returns((uint8,uint32,uint8,uint256) relayParams) -func (_CoreRelayer *CoreRelayerCallerSession) DecodeRelayParameters(encoded []byte) (CoreRelayerStructsRelayParameters, error) { - return _CoreRelayer.Contract.DecodeRelayParameters(&_CoreRelayer.CallOpts, encoded) -} - -// EstimateCost is a free data retrieval call binding the contract method 0xc1f74e50. -// -// Solidity: function estimateCost(uint16 chainId, uint32 gasLimit) view returns(uint256 gasEstimate) -func (_CoreRelayer *CoreRelayerCaller) EstimateCost(opts *bind.CallOpts, chainId uint16, gasLimit uint32) (*big.Int, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "estimateCost", chainId, gasLimit) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// EstimateCost is a free data retrieval call binding the contract method 0xc1f74e50. -// -// Solidity: function estimateCost(uint16 chainId, uint32 gasLimit) view returns(uint256 gasEstimate) -func (_CoreRelayer *CoreRelayerSession) EstimateCost(chainId uint16, gasLimit uint32) (*big.Int, error) { - return _CoreRelayer.Contract.EstimateCost(&_CoreRelayer.CallOpts, chainId, gasLimit) -} - -// EstimateCost is a free data retrieval call binding the contract method 0xc1f74e50. -// -// Solidity: function estimateCost(uint16 chainId, uint32 gasLimit) view returns(uint256 gasEstimate) -func (_CoreRelayer *CoreRelayerCallerSession) EstimateCost(chainId uint16, gasLimit uint32) (*big.Int, error) { - return _CoreRelayer.Contract.EstimateCost(&_CoreRelayer.CallOpts, chainId, gasLimit) -} - -// GasOracle is a free data retrieval call binding the contract method 0x5d62a8dd. -// -// Solidity: function gasOracle() view returns(address) -func (_CoreRelayer *CoreRelayerCaller) GasOracle(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "gasOracle") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GasOracle is a free data retrieval call binding the contract method 0x5d62a8dd. -// -// Solidity: function gasOracle() view returns(address) -func (_CoreRelayer *CoreRelayerSession) GasOracle() (common.Address, error) { - return _CoreRelayer.Contract.GasOracle(&_CoreRelayer.CallOpts) -} - -// GasOracle is a free data retrieval call binding the contract method 0x5d62a8dd. -// -// Solidity: function gasOracle() view returns(address) -func (_CoreRelayer *CoreRelayerCallerSession) GasOracle() (common.Address, error) { - return _CoreRelayer.Contract.GasOracle(&_CoreRelayer.CallOpts) -} - -// GasOracleAddress is a free data retrieval call binding the contract method 0x786a8f58. -// -// Solidity: function gasOracleAddress() view returns(address) -func (_CoreRelayer *CoreRelayerCaller) GasOracleAddress(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "gasOracleAddress") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GasOracleAddress is a free data retrieval call binding the contract method 0x786a8f58. -// -// Solidity: function gasOracleAddress() view returns(address) -func (_CoreRelayer *CoreRelayerSession) GasOracleAddress() (common.Address, error) { - return _CoreRelayer.Contract.GasOracleAddress(&_CoreRelayer.CallOpts) -} - -// GasOracleAddress is a free data retrieval call binding the contract method 0x786a8f58. -// -// Solidity: function gasOracleAddress() view returns(address) -func (_CoreRelayer *CoreRelayerCallerSession) GasOracleAddress() (common.Address, error) { - return _CoreRelayer.Contract.GasOracleAddress(&_CoreRelayer.CallOpts) -} - -// GetEvmGasOverhead is a free data retrieval call binding the contract method 0x11bca1f4. -// -// Solidity: function getEvmGasOverhead() view returns(uint32) -func (_CoreRelayer *CoreRelayerCaller) GetEvmGasOverhead(opts *bind.CallOpts) (uint32, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "getEvmGasOverhead") - - if err != nil { - return *new(uint32), err - } - - out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) - - return out0, err - -} - -// GetEvmGasOverhead is a free data retrieval call binding the contract method 0x11bca1f4. -// -// Solidity: function getEvmGasOverhead() view returns(uint32) -func (_CoreRelayer *CoreRelayerSession) GetEvmGasOverhead() (uint32, error) { - return _CoreRelayer.Contract.GetEvmGasOverhead(&_CoreRelayer.CallOpts) -} - -// GetEvmGasOverhead is a free data retrieval call binding the contract method 0x11bca1f4. -// -// Solidity: function getEvmGasOverhead() view returns(uint32) -func (_CoreRelayer *CoreRelayerCallerSession) GetEvmGasOverhead() (uint32, error) { - return _CoreRelayer.Contract.GetEvmGasOverhead(&_CoreRelayer.CallOpts) -} - -// IsDeliveryCompleted is a free data retrieval call binding the contract method 0x1dd5f138. -// -// Solidity: function isDeliveryCompleted(bytes32 deliveryHash) view returns(bool) -func (_CoreRelayer *CoreRelayerCaller) IsDeliveryCompleted(opts *bind.CallOpts, deliveryHash [32]byte) (bool, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "isDeliveryCompleted", deliveryHash) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsDeliveryCompleted is a free data retrieval call binding the contract method 0x1dd5f138. -// -// Solidity: function isDeliveryCompleted(bytes32 deliveryHash) view returns(bool) -func (_CoreRelayer *CoreRelayerSession) IsDeliveryCompleted(deliveryHash [32]byte) (bool, error) { - return _CoreRelayer.Contract.IsDeliveryCompleted(&_CoreRelayer.CallOpts, deliveryHash) -} - -// IsDeliveryCompleted is a free data retrieval call binding the contract method 0x1dd5f138. -// -// Solidity: function isDeliveryCompleted(bytes32 deliveryHash) view returns(bool) -func (_CoreRelayer *CoreRelayerCallerSession) IsDeliveryCompleted(deliveryHash [32]byte) (bool, error) { - return _CoreRelayer.Contract.IsDeliveryCompleted(&_CoreRelayer.CallOpts, deliveryHash) -} - -// IsInitialized is a free data retrieval call binding the contract method 0xd60b347f. -// -// Solidity: function isInitialized(address impl) view returns(bool) -func (_CoreRelayer *CoreRelayerCaller) IsInitialized(opts *bind.CallOpts, impl common.Address) (bool, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "isInitialized", impl) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsInitialized is a free data retrieval call binding the contract method 0xd60b347f. -// -// Solidity: function isInitialized(address impl) view returns(bool) -func (_CoreRelayer *CoreRelayerSession) IsInitialized(impl common.Address) (bool, error) { - return _CoreRelayer.Contract.IsInitialized(&_CoreRelayer.CallOpts, impl) -} - -// IsInitialized is a free data retrieval call binding the contract method 0xd60b347f. -// -// Solidity: function isInitialized(address impl) view returns(bool) -func (_CoreRelayer *CoreRelayerCallerSession) IsInitialized(impl common.Address) (bool, error) { - return _CoreRelayer.Contract.IsInitialized(&_CoreRelayer.CallOpts, impl) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_CoreRelayer *CoreRelayerCaller) Owner(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "owner") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_CoreRelayer *CoreRelayerSession) Owner() (common.Address, error) { - return _CoreRelayer.Contract.Owner(&_CoreRelayer.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_CoreRelayer *CoreRelayerCallerSession) Owner() (common.Address, error) { - return _CoreRelayer.Contract.Owner(&_CoreRelayer.CallOpts) -} - -// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978. -// -// Solidity: function pendingOwner() view returns(address) -func (_CoreRelayer *CoreRelayerCaller) PendingOwner(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "pendingOwner") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978. -// -// Solidity: function pendingOwner() view returns(address) -func (_CoreRelayer *CoreRelayerSession) PendingOwner() (common.Address, error) { - return _CoreRelayer.Contract.PendingOwner(&_CoreRelayer.CallOpts) -} - -// PendingOwner is a free data retrieval call binding the contract method 0xe30c3978. -// -// Solidity: function pendingOwner() view returns(address) -func (_CoreRelayer *CoreRelayerCallerSession) PendingOwner() (common.Address, error) { - return _CoreRelayer.Contract.PendingOwner(&_CoreRelayer.CallOpts) -} - -// RedeliveryAttemptCount is a free data retrieval call binding the contract method 0x59fbacbf. -// -// Solidity: function redeliveryAttemptCount(bytes32 deliveryHash) view returns(uint16) -func (_CoreRelayer *CoreRelayerCaller) RedeliveryAttemptCount(opts *bind.CallOpts, deliveryHash [32]byte) (uint16, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "redeliveryAttemptCount", deliveryHash) - - if err != nil { - return *new(uint16), err - } - - out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16) - - return out0, err - -} - -// RedeliveryAttemptCount is a free data retrieval call binding the contract method 0x59fbacbf. -// -// Solidity: function redeliveryAttemptCount(bytes32 deliveryHash) view returns(uint16) -func (_CoreRelayer *CoreRelayerSession) RedeliveryAttemptCount(deliveryHash [32]byte) (uint16, error) { - return _CoreRelayer.Contract.RedeliveryAttemptCount(&_CoreRelayer.CallOpts, deliveryHash) -} - -// RedeliveryAttemptCount is a free data retrieval call binding the contract method 0x59fbacbf. -// -// Solidity: function redeliveryAttemptCount(bytes32 deliveryHash) view returns(uint16) -func (_CoreRelayer *CoreRelayerCallerSession) RedeliveryAttemptCount(deliveryHash [32]byte) (uint16, error) { - return _CoreRelayer.Contract.RedeliveryAttemptCount(&_CoreRelayer.CallOpts, deliveryHash) -} - -// RegisteredRelayer is a free data retrieval call binding the contract method 0x9d9dfdf7. -// -// Solidity: function registeredRelayer(uint16 chain) view returns(bytes32) -func (_CoreRelayer *CoreRelayerCaller) RegisteredRelayer(opts *bind.CallOpts, chain uint16) ([32]byte, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "registeredRelayer", chain) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// RegisteredRelayer is a free data retrieval call binding the contract method 0x9d9dfdf7. -// -// Solidity: function registeredRelayer(uint16 chain) view returns(bytes32) -func (_CoreRelayer *CoreRelayerSession) RegisteredRelayer(chain uint16) ([32]byte, error) { - return _CoreRelayer.Contract.RegisteredRelayer(&_CoreRelayer.CallOpts, chain) -} - -// RegisteredRelayer is a free data retrieval call binding the contract method 0x9d9dfdf7. -// -// Solidity: function registeredRelayer(uint16 chain) view returns(bytes32) -func (_CoreRelayer *CoreRelayerCallerSession) RegisteredRelayer(chain uint16) ([32]byte, error) { - return _CoreRelayer.Contract.RegisteredRelayer(&_CoreRelayer.CallOpts, chain) -} - -// RelayerRewards is a free data retrieval call binding the contract method 0xde142814. -// -// Solidity: function relayerRewards(address relayer, uint16 rewardChain) view returns(uint256) -func (_CoreRelayer *CoreRelayerCaller) RelayerRewards(opts *bind.CallOpts, relayer common.Address, rewardChain uint16) (*big.Int, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "relayerRewards", relayer, rewardChain) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// RelayerRewards is a free data retrieval call binding the contract method 0xde142814. -// -// Solidity: function relayerRewards(address relayer, uint16 rewardChain) view returns(uint256) -func (_CoreRelayer *CoreRelayerSession) RelayerRewards(relayer common.Address, rewardChain uint16) (*big.Int, error) { - return _CoreRelayer.Contract.RelayerRewards(&_CoreRelayer.CallOpts, relayer, rewardChain) -} - -// RelayerRewards is a free data retrieval call binding the contract method 0xde142814. -// -// Solidity: function relayerRewards(address relayer, uint16 rewardChain) view returns(uint256) -func (_CoreRelayer *CoreRelayerCallerSession) RelayerRewards(relayer common.Address, rewardChain uint16) (*big.Int, error) { - return _CoreRelayer.Contract.RelayerRewards(&_CoreRelayer.CallOpts, relayer, rewardChain) -} - -// Wormhole is a free data retrieval call binding the contract method 0x84acd1bb. -// -// Solidity: function wormhole() view returns(address) -func (_CoreRelayer *CoreRelayerCaller) Wormhole(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _CoreRelayer.contract.Call(opts, &out, "wormhole") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Wormhole is a free data retrieval call binding the contract method 0x84acd1bb. -// -// Solidity: function wormhole() view returns(address) -func (_CoreRelayer *CoreRelayerSession) Wormhole() (common.Address, error) { - return _CoreRelayer.Contract.Wormhole(&_CoreRelayer.CallOpts) -} - -// Wormhole is a free data retrieval call binding the contract method 0x84acd1bb. -// -// Solidity: function wormhole() view returns(address) -func (_CoreRelayer *CoreRelayerCallerSession) Wormhole() (common.Address, error) { - return _CoreRelayer.Contract.Wormhole(&_CoreRelayer.CallOpts) -} - -// ConfirmOwnershipTransferRequest is a paid mutator transaction binding the contract method 0x038c0b66. -// -// Solidity: function confirmOwnershipTransferRequest() returns() -func (_CoreRelayer *CoreRelayerTransactor) ConfirmOwnershipTransferRequest(opts *bind.TransactOpts) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "confirmOwnershipTransferRequest") -} - -// ConfirmOwnershipTransferRequest is a paid mutator transaction binding the contract method 0x038c0b66. -// -// Solidity: function confirmOwnershipTransferRequest() returns() -func (_CoreRelayer *CoreRelayerSession) ConfirmOwnershipTransferRequest() (*types.Transaction, error) { - return _CoreRelayer.Contract.ConfirmOwnershipTransferRequest(&_CoreRelayer.TransactOpts) -} - -// ConfirmOwnershipTransferRequest is a paid mutator transaction binding the contract method 0x038c0b66. -// -// Solidity: function confirmOwnershipTransferRequest() returns() -func (_CoreRelayer *CoreRelayerTransactorSession) ConfirmOwnershipTransferRequest() (*types.Transaction, error) { - return _CoreRelayer.Contract.ConfirmOwnershipTransferRequest(&_CoreRelayer.TransactOpts) -} - -// Deliver is a paid mutator transaction binding the contract method 0x428f7d13. -// -// Solidity: function deliver((bytes,uint8,uint32) targetParams) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactor) Deliver(opts *bind.TransactOpts, targetParams CoreRelayerStructsTargetDeliveryParameters) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "deliver", targetParams) -} - -// Deliver is a paid mutator transaction binding the contract method 0x428f7d13. -// -// Solidity: function deliver((bytes,uint8,uint32) targetParams) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerSession) Deliver(targetParams CoreRelayerStructsTargetDeliveryParameters) (*types.Transaction, error) { - return _CoreRelayer.Contract.Deliver(&_CoreRelayer.TransactOpts, targetParams) -} - -// Deliver is a paid mutator transaction binding the contract method 0x428f7d13. -// -// Solidity: function deliver((bytes,uint8,uint32) targetParams) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactorSession) Deliver(targetParams CoreRelayerStructsTargetDeliveryParameters) (*types.Transaction, error) { - return _CoreRelayer.Contract.Deliver(&_CoreRelayer.TransactOpts, targetParams) -} - -// FinaliseRewardPayout is a paid mutator transaction binding the contract method 0x205668cd. -// -// Solidity: function finaliseRewardPayout(bytes encodedVm) returns() -func (_CoreRelayer *CoreRelayerTransactor) FinaliseRewardPayout(opts *bind.TransactOpts, encodedVm []byte) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "finaliseRewardPayout", encodedVm) -} - -// FinaliseRewardPayout is a paid mutator transaction binding the contract method 0x205668cd. -// -// Solidity: function finaliseRewardPayout(bytes encodedVm) returns() -func (_CoreRelayer *CoreRelayerSession) FinaliseRewardPayout(encodedVm []byte) (*types.Transaction, error) { - return _CoreRelayer.Contract.FinaliseRewardPayout(&_CoreRelayer.TransactOpts, encodedVm) -} - -// FinaliseRewardPayout is a paid mutator transaction binding the contract method 0x205668cd. -// -// Solidity: function finaliseRewardPayout(bytes encodedVm) returns() -func (_CoreRelayer *CoreRelayerTransactorSession) FinaliseRewardPayout(encodedVm []byte) (*types.Transaction, error) { - return _CoreRelayer.Contract.FinaliseRewardPayout(&_CoreRelayer.TransactOpts, encodedVm) -} - -// ReDeliver is a paid mutator transaction binding the contract method 0x24217508. -// -// Solidity: function reDeliver((bytes,uint8,uint32) targetParams, bytes encodedRedeliveryVm) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactor) ReDeliver(opts *bind.TransactOpts, targetParams CoreRelayerStructsTargetDeliveryParameters, encodedRedeliveryVm []byte) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "reDeliver", targetParams, encodedRedeliveryVm) -} - -// ReDeliver is a paid mutator transaction binding the contract method 0x24217508. -// -// Solidity: function reDeliver((bytes,uint8,uint32) targetParams, bytes encodedRedeliveryVm) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerSession) ReDeliver(targetParams CoreRelayerStructsTargetDeliveryParameters, encodedRedeliveryVm []byte) (*types.Transaction, error) { - return _CoreRelayer.Contract.ReDeliver(&_CoreRelayer.TransactOpts, targetParams, encodedRedeliveryVm) -} - -// ReDeliver is a paid mutator transaction binding the contract method 0x24217508. -// -// Solidity: function reDeliver((bytes,uint8,uint32) targetParams, bytes encodedRedeliveryVm) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactorSession) ReDeliver(targetParams CoreRelayerStructsTargetDeliveryParameters, encodedRedeliveryVm []byte) (*types.Transaction, error) { - return _CoreRelayer.Contract.ReDeliver(&_CoreRelayer.TransactOpts, targetParams, encodedRedeliveryVm) -} - -// ReSend is a paid mutator transaction binding the contract method 0xd21f4f50. -// -// Solidity: function reSend(bytes encodedVm, bytes newRelayerParams) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactor) ReSend(opts *bind.TransactOpts, encodedVm []byte, newRelayerParams []byte) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "reSend", encodedVm, newRelayerParams) -} - -// ReSend is a paid mutator transaction binding the contract method 0xd21f4f50. -// -// Solidity: function reSend(bytes encodedVm, bytes newRelayerParams) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerSession) ReSend(encodedVm []byte, newRelayerParams []byte) (*types.Transaction, error) { - return _CoreRelayer.Contract.ReSend(&_CoreRelayer.TransactOpts, encodedVm, newRelayerParams) -} - -// ReSend is a paid mutator transaction binding the contract method 0xd21f4f50. -// -// Solidity: function reSend(bytes encodedVm, bytes newRelayerParams) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactorSession) ReSend(encodedVm []byte, newRelayerParams []byte) (*types.Transaction, error) { - return _CoreRelayer.Contract.ReSend(&_CoreRelayer.TransactOpts, encodedVm, newRelayerParams) -} - -// RegisterChain is a paid mutator transaction binding the contract method 0x65bb3ea7. -// -// Solidity: function registerChain(uint16 relayerChainId, bytes32 relayerAddress) returns() -func (_CoreRelayer *CoreRelayerTransactor) RegisterChain(opts *bind.TransactOpts, relayerChainId uint16, relayerAddress [32]byte) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "registerChain", relayerChainId, relayerAddress) -} - -// RegisterChain is a paid mutator transaction binding the contract method 0x65bb3ea7. -// -// Solidity: function registerChain(uint16 relayerChainId, bytes32 relayerAddress) returns() -func (_CoreRelayer *CoreRelayerSession) RegisterChain(relayerChainId uint16, relayerAddress [32]byte) (*types.Transaction, error) { - return _CoreRelayer.Contract.RegisterChain(&_CoreRelayer.TransactOpts, relayerChainId, relayerAddress) -} - -// RegisterChain is a paid mutator transaction binding the contract method 0x65bb3ea7. -// -// Solidity: function registerChain(uint16 relayerChainId, bytes32 relayerAddress) returns() -func (_CoreRelayer *CoreRelayerTransactorSession) RegisterChain(relayerChainId uint16, relayerAddress [32]byte) (*types.Transaction, error) { - return _CoreRelayer.Contract.RegisterChain(&_CoreRelayer.TransactOpts, relayerChainId, relayerAddress) -} - -// RewardPayout is a paid mutator transaction binding the contract method 0x710cdd3c. -// -// Solidity: function rewardPayout(uint16 rewardChain, bytes32 receiver, uint32 nonce) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactor) RewardPayout(opts *bind.TransactOpts, rewardChain uint16, receiver [32]byte, nonce uint32) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "rewardPayout", rewardChain, receiver, nonce) -} - -// RewardPayout is a paid mutator transaction binding the contract method 0x710cdd3c. -// -// Solidity: function rewardPayout(uint16 rewardChain, bytes32 receiver, uint32 nonce) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerSession) RewardPayout(rewardChain uint16, receiver [32]byte, nonce uint32) (*types.Transaction, error) { - return _CoreRelayer.Contract.RewardPayout(&_CoreRelayer.TransactOpts, rewardChain, receiver, nonce) -} - -// RewardPayout is a paid mutator transaction binding the contract method 0x710cdd3c. -// -// Solidity: function rewardPayout(uint16 rewardChain, bytes32 receiver, uint32 nonce) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactorSession) RewardPayout(rewardChain uint16, receiver [32]byte, nonce uint32) (*types.Transaction, error) { - return _CoreRelayer.Contract.RewardPayout(&_CoreRelayer.TransactOpts, rewardChain, receiver, nonce) -} - -// Send is a paid mutator transaction binding the contract method 0x1e2a68a5. -// -// Solidity: function send((uint16,bytes32,bytes,(bytes32,uint64)[],bytes,bytes,uint32,uint8) deliveryParams) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactor) Send(opts *bind.TransactOpts, deliveryParams CoreRelayerStructsDeliveryParameters) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "send", deliveryParams) -} - -// Send is a paid mutator transaction binding the contract method 0x1e2a68a5. -// -// Solidity: function send((uint16,bytes32,bytes,(bytes32,uint64)[],bytes,bytes,uint32,uint8) deliveryParams) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerSession) Send(deliveryParams CoreRelayerStructsDeliveryParameters) (*types.Transaction, error) { - return _CoreRelayer.Contract.Send(&_CoreRelayer.TransactOpts, deliveryParams) -} - -// Send is a paid mutator transaction binding the contract method 0x1e2a68a5. -// -// Solidity: function send((uint16,bytes32,bytes,(bytes32,uint64)[],bytes,bytes,uint32,uint8) deliveryParams) payable returns(uint64 sequence) -func (_CoreRelayer *CoreRelayerTransactorSession) Send(deliveryParams CoreRelayerStructsDeliveryParameters) (*types.Transaction, error) { - return _CoreRelayer.Contract.Send(&_CoreRelayer.TransactOpts, deliveryParams) -} - -// SubmitOwnershipTransferRequest is a paid mutator transaction binding the contract method 0x94cc743d. -// -// Solidity: function submitOwnershipTransferRequest(uint16 thisRelayerChainId, address newOwner) returns() -func (_CoreRelayer *CoreRelayerTransactor) SubmitOwnershipTransferRequest(opts *bind.TransactOpts, thisRelayerChainId uint16, newOwner common.Address) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "submitOwnershipTransferRequest", thisRelayerChainId, newOwner) -} - -// SubmitOwnershipTransferRequest is a paid mutator transaction binding the contract method 0x94cc743d. -// -// Solidity: function submitOwnershipTransferRequest(uint16 thisRelayerChainId, address newOwner) returns() -func (_CoreRelayer *CoreRelayerSession) SubmitOwnershipTransferRequest(thisRelayerChainId uint16, newOwner common.Address) (*types.Transaction, error) { - return _CoreRelayer.Contract.SubmitOwnershipTransferRequest(&_CoreRelayer.TransactOpts, thisRelayerChainId, newOwner) -} - -// SubmitOwnershipTransferRequest is a paid mutator transaction binding the contract method 0x94cc743d. -// -// Solidity: function submitOwnershipTransferRequest(uint16 thisRelayerChainId, address newOwner) returns() -func (_CoreRelayer *CoreRelayerTransactorSession) SubmitOwnershipTransferRequest(thisRelayerChainId uint16, newOwner common.Address) (*types.Transaction, error) { - return _CoreRelayer.Contract.SubmitOwnershipTransferRequest(&_CoreRelayer.TransactOpts, thisRelayerChainId, newOwner) -} - -// UpdateEvmGasOverhead is a paid mutator transaction binding the contract method 0x00de5ec4. -// -// Solidity: function updateEvmGasOverhead(uint16 thisRelayerChainId, uint32 newGasOverhead) returns() -func (_CoreRelayer *CoreRelayerTransactor) UpdateEvmGasOverhead(opts *bind.TransactOpts, thisRelayerChainId uint16, newGasOverhead uint32) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "updateEvmGasOverhead", thisRelayerChainId, newGasOverhead) -} - -// UpdateEvmGasOverhead is a paid mutator transaction binding the contract method 0x00de5ec4. -// -// Solidity: function updateEvmGasOverhead(uint16 thisRelayerChainId, uint32 newGasOverhead) returns() -func (_CoreRelayer *CoreRelayerSession) UpdateEvmGasOverhead(thisRelayerChainId uint16, newGasOverhead uint32) (*types.Transaction, error) { - return _CoreRelayer.Contract.UpdateEvmGasOverhead(&_CoreRelayer.TransactOpts, thisRelayerChainId, newGasOverhead) -} - -// UpdateEvmGasOverhead is a paid mutator transaction binding the contract method 0x00de5ec4. -// -// Solidity: function updateEvmGasOverhead(uint16 thisRelayerChainId, uint32 newGasOverhead) returns() -func (_CoreRelayer *CoreRelayerTransactorSession) UpdateEvmGasOverhead(thisRelayerChainId uint16, newGasOverhead uint32) (*types.Transaction, error) { - return _CoreRelayer.Contract.UpdateEvmGasOverhead(&_CoreRelayer.TransactOpts, thisRelayerChainId, newGasOverhead) -} - -// UpdateGasOracleContract is a paid mutator transaction binding the contract method 0x3c07f767. -// -// Solidity: function updateGasOracleContract(uint16 thisRelayerChainId, address newGasOracleAddress) returns() -func (_CoreRelayer *CoreRelayerTransactor) UpdateGasOracleContract(opts *bind.TransactOpts, thisRelayerChainId uint16, newGasOracleAddress common.Address) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "updateGasOracleContract", thisRelayerChainId, newGasOracleAddress) -} - -// UpdateGasOracleContract is a paid mutator transaction binding the contract method 0x3c07f767. -// -// Solidity: function updateGasOracleContract(uint16 thisRelayerChainId, address newGasOracleAddress) returns() -func (_CoreRelayer *CoreRelayerSession) UpdateGasOracleContract(thisRelayerChainId uint16, newGasOracleAddress common.Address) (*types.Transaction, error) { - return _CoreRelayer.Contract.UpdateGasOracleContract(&_CoreRelayer.TransactOpts, thisRelayerChainId, newGasOracleAddress) -} - -// UpdateGasOracleContract is a paid mutator transaction binding the contract method 0x3c07f767. -// -// Solidity: function updateGasOracleContract(uint16 thisRelayerChainId, address newGasOracleAddress) returns() -func (_CoreRelayer *CoreRelayerTransactorSession) UpdateGasOracleContract(thisRelayerChainId uint16, newGasOracleAddress common.Address) (*types.Transaction, error) { - return _CoreRelayer.Contract.UpdateGasOracleContract(&_CoreRelayer.TransactOpts, thisRelayerChainId, newGasOracleAddress) -} - -// Upgrade is a paid mutator transaction binding the contract method 0x3522be7d. -// -// Solidity: function upgrade(uint16 thisRelayerChainId, address newImplementation) returns() -func (_CoreRelayer *CoreRelayerTransactor) Upgrade(opts *bind.TransactOpts, thisRelayerChainId uint16, newImplementation common.Address) (*types.Transaction, error) { - return _CoreRelayer.contract.Transact(opts, "upgrade", thisRelayerChainId, newImplementation) -} - -// Upgrade is a paid mutator transaction binding the contract method 0x3522be7d. -// -// Solidity: function upgrade(uint16 thisRelayerChainId, address newImplementation) returns() -func (_CoreRelayer *CoreRelayerSession) Upgrade(thisRelayerChainId uint16, newImplementation common.Address) (*types.Transaction, error) { - return _CoreRelayer.Contract.Upgrade(&_CoreRelayer.TransactOpts, thisRelayerChainId, newImplementation) -} - -// Upgrade is a paid mutator transaction binding the contract method 0x3522be7d. -// -// Solidity: function upgrade(uint16 thisRelayerChainId, address newImplementation) returns() -func (_CoreRelayer *CoreRelayerTransactorSession) Upgrade(thisRelayerChainId uint16, newImplementation common.Address) (*types.Transaction, error) { - return _CoreRelayer.Contract.Upgrade(&_CoreRelayer.TransactOpts, thisRelayerChainId, newImplementation) -} - -// CoreRelayerAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the CoreRelayer contract. -type CoreRelayerAdminChangedIterator struct { - Event *CoreRelayerAdminChanged // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CoreRelayerAdminChangedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CoreRelayerAdminChanged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CoreRelayerAdminChanged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CoreRelayerAdminChangedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CoreRelayerAdminChangedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CoreRelayerAdminChanged represents a AdminChanged event raised by the CoreRelayer contract. -type CoreRelayerAdminChanged struct { - PreviousAdmin common.Address - NewAdmin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_CoreRelayer *CoreRelayerFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*CoreRelayerAdminChangedIterator, error) { - - logs, sub, err := _CoreRelayer.contract.FilterLogs(opts, "AdminChanged") - if err != nil { - return nil, err - } - return &CoreRelayerAdminChangedIterator{contract: _CoreRelayer.contract, event: "AdminChanged", logs: logs, sub: sub}, nil -} - -// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_CoreRelayer *CoreRelayerFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *CoreRelayerAdminChanged) (event.Subscription, error) { - - logs, sub, err := _CoreRelayer.contract.WatchLogs(opts, "AdminChanged") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CoreRelayerAdminChanged) - if err := _CoreRelayer.contract.UnpackLog(event, "AdminChanged", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_CoreRelayer *CoreRelayerFilterer) ParseAdminChanged(log types.Log) (*CoreRelayerAdminChanged, error) { - event := new(CoreRelayerAdminChanged) - if err := _CoreRelayer.contract.UnpackLog(event, "AdminChanged", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CoreRelayerBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the CoreRelayer contract. -type CoreRelayerBeaconUpgradedIterator struct { - Event *CoreRelayerBeaconUpgraded // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CoreRelayerBeaconUpgradedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CoreRelayerBeaconUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CoreRelayerBeaconUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CoreRelayerBeaconUpgradedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CoreRelayerBeaconUpgradedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CoreRelayerBeaconUpgraded represents a BeaconUpgraded event raised by the CoreRelayer contract. -type CoreRelayerBeaconUpgraded struct { - Beacon common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_CoreRelayer *CoreRelayerFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*CoreRelayerBeaconUpgradedIterator, error) { - - var beaconRule []interface{} - for _, beaconItem := range beacon { - beaconRule = append(beaconRule, beaconItem) - } - - logs, sub, err := _CoreRelayer.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) - if err != nil { - return nil, err - } - return &CoreRelayerBeaconUpgradedIterator{contract: _CoreRelayer.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil -} - -// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_CoreRelayer *CoreRelayerFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *CoreRelayerBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { - - var beaconRule []interface{} - for _, beaconItem := range beacon { - beaconRule = append(beaconRule, beaconItem) - } - - logs, sub, err := _CoreRelayer.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CoreRelayerBeaconUpgraded) - if err := _CoreRelayer.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_CoreRelayer *CoreRelayerFilterer) ParseBeaconUpgraded(log types.Log) (*CoreRelayerBeaconUpgraded, error) { - event := new(CoreRelayerBeaconUpgraded) - if err := _CoreRelayer.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CoreRelayerContractUpgradedIterator is returned from FilterContractUpgraded and is used to iterate over the raw logs and unpacked data for ContractUpgraded events raised by the CoreRelayer contract. -type CoreRelayerContractUpgradedIterator struct { - Event *CoreRelayerContractUpgraded // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CoreRelayerContractUpgradedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CoreRelayerContractUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CoreRelayerContractUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CoreRelayerContractUpgradedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CoreRelayerContractUpgradedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CoreRelayerContractUpgraded represents a ContractUpgraded event raised by the CoreRelayer contract. -type CoreRelayerContractUpgraded struct { - OldContract common.Address - NewContract common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterContractUpgraded is a free log retrieval operation binding the contract event 0x2e4cc16c100f0b55e2df82ab0b1a7e294aa9cbd01b48fbaf622683fbc0507a49. -// -// Solidity: event ContractUpgraded(address indexed oldContract, address indexed newContract) -func (_CoreRelayer *CoreRelayerFilterer) FilterContractUpgraded(opts *bind.FilterOpts, oldContract []common.Address, newContract []common.Address) (*CoreRelayerContractUpgradedIterator, error) { - - var oldContractRule []interface{} - for _, oldContractItem := range oldContract { - oldContractRule = append(oldContractRule, oldContractItem) - } - var newContractRule []interface{} - for _, newContractItem := range newContract { - newContractRule = append(newContractRule, newContractItem) - } - - logs, sub, err := _CoreRelayer.contract.FilterLogs(opts, "ContractUpgraded", oldContractRule, newContractRule) - if err != nil { - return nil, err - } - return &CoreRelayerContractUpgradedIterator{contract: _CoreRelayer.contract, event: "ContractUpgraded", logs: logs, sub: sub}, nil -} - -// WatchContractUpgraded is a free log subscription operation binding the contract event 0x2e4cc16c100f0b55e2df82ab0b1a7e294aa9cbd01b48fbaf622683fbc0507a49. -// -// Solidity: event ContractUpgraded(address indexed oldContract, address indexed newContract) -func (_CoreRelayer *CoreRelayerFilterer) WatchContractUpgraded(opts *bind.WatchOpts, sink chan<- *CoreRelayerContractUpgraded, oldContract []common.Address, newContract []common.Address) (event.Subscription, error) { - - var oldContractRule []interface{} - for _, oldContractItem := range oldContract { - oldContractRule = append(oldContractRule, oldContractItem) - } - var newContractRule []interface{} - for _, newContractItem := range newContract { - newContractRule = append(newContractRule, newContractItem) - } - - logs, sub, err := _CoreRelayer.contract.WatchLogs(opts, "ContractUpgraded", oldContractRule, newContractRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CoreRelayerContractUpgraded) - if err := _CoreRelayer.contract.UnpackLog(event, "ContractUpgraded", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseContractUpgraded is a log parse operation binding the contract event 0x2e4cc16c100f0b55e2df82ab0b1a7e294aa9cbd01b48fbaf622683fbc0507a49. -// -// Solidity: event ContractUpgraded(address indexed oldContract, address indexed newContract) -func (_CoreRelayer *CoreRelayerFilterer) ParseContractUpgraded(log types.Log) (*CoreRelayerContractUpgraded, error) { - event := new(CoreRelayerContractUpgraded) - if err := _CoreRelayer.contract.UnpackLog(event, "ContractUpgraded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CoreRelayerEVMGasOverheadUpdatedIterator is returned from FilterEVMGasOverheadUpdated and is used to iterate over the raw logs and unpacked data for EVMGasOverheadUpdated events raised by the CoreRelayer contract. -type CoreRelayerEVMGasOverheadUpdatedIterator struct { - Event *CoreRelayerEVMGasOverheadUpdated // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CoreRelayerEVMGasOverheadUpdatedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CoreRelayerEVMGasOverheadUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CoreRelayerEVMGasOverheadUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CoreRelayerEVMGasOverheadUpdatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CoreRelayerEVMGasOverheadUpdatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CoreRelayerEVMGasOverheadUpdated represents a EVMGasOverheadUpdated event raised by the CoreRelayer contract. -type CoreRelayerEVMGasOverheadUpdated struct { - OldOverhead uint32 - NewOverhead uint32 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterEVMGasOverheadUpdated is a free log retrieval operation binding the contract event 0x39b49e3d7d01371a25a01c8cfd3e6daafc69f017c13b0f9fcb633d97d16c87b9. -// -// Solidity: event EVMGasOverheadUpdated(uint32 indexed oldOverhead, uint32 indexed newOverhead) -func (_CoreRelayer *CoreRelayerFilterer) FilterEVMGasOverheadUpdated(opts *bind.FilterOpts, oldOverhead []uint32, newOverhead []uint32) (*CoreRelayerEVMGasOverheadUpdatedIterator, error) { - - var oldOverheadRule []interface{} - for _, oldOverheadItem := range oldOverhead { - oldOverheadRule = append(oldOverheadRule, oldOverheadItem) - } - var newOverheadRule []interface{} - for _, newOverheadItem := range newOverhead { - newOverheadRule = append(newOverheadRule, newOverheadItem) - } - - logs, sub, err := _CoreRelayer.contract.FilterLogs(opts, "EVMGasOverheadUpdated", oldOverheadRule, newOverheadRule) - if err != nil { - return nil, err - } - return &CoreRelayerEVMGasOverheadUpdatedIterator{contract: _CoreRelayer.contract, event: "EVMGasOverheadUpdated", logs: logs, sub: sub}, nil -} - -// WatchEVMGasOverheadUpdated is a free log subscription operation binding the contract event 0x39b49e3d7d01371a25a01c8cfd3e6daafc69f017c13b0f9fcb633d97d16c87b9. -// -// Solidity: event EVMGasOverheadUpdated(uint32 indexed oldOverhead, uint32 indexed newOverhead) -func (_CoreRelayer *CoreRelayerFilterer) WatchEVMGasOverheadUpdated(opts *bind.WatchOpts, sink chan<- *CoreRelayerEVMGasOverheadUpdated, oldOverhead []uint32, newOverhead []uint32) (event.Subscription, error) { - - var oldOverheadRule []interface{} - for _, oldOverheadItem := range oldOverhead { - oldOverheadRule = append(oldOverheadRule, oldOverheadItem) - } - var newOverheadRule []interface{} - for _, newOverheadItem := range newOverhead { - newOverheadRule = append(newOverheadRule, newOverheadItem) - } - - logs, sub, err := _CoreRelayer.contract.WatchLogs(opts, "EVMGasOverheadUpdated", oldOverheadRule, newOverheadRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CoreRelayerEVMGasOverheadUpdated) - if err := _CoreRelayer.contract.UnpackLog(event, "EVMGasOverheadUpdated", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseEVMGasOverheadUpdated is a log parse operation binding the contract event 0x39b49e3d7d01371a25a01c8cfd3e6daafc69f017c13b0f9fcb633d97d16c87b9. -// -// Solidity: event EVMGasOverheadUpdated(uint32 indexed oldOverhead, uint32 indexed newOverhead) -func (_CoreRelayer *CoreRelayerFilterer) ParseEVMGasOverheadUpdated(log types.Log) (*CoreRelayerEVMGasOverheadUpdated, error) { - event := new(CoreRelayerEVMGasOverheadUpdated) - if err := _CoreRelayer.contract.UnpackLog(event, "EVMGasOverheadUpdated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CoreRelayerGasOracleUpdatedIterator is returned from FilterGasOracleUpdated and is used to iterate over the raw logs and unpacked data for GasOracleUpdated events raised by the CoreRelayer contract. -type CoreRelayerGasOracleUpdatedIterator struct { - Event *CoreRelayerGasOracleUpdated // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CoreRelayerGasOracleUpdatedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CoreRelayerGasOracleUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CoreRelayerGasOracleUpdated) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CoreRelayerGasOracleUpdatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CoreRelayerGasOracleUpdatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CoreRelayerGasOracleUpdated represents a GasOracleUpdated event raised by the CoreRelayer contract. -type CoreRelayerGasOracleUpdated struct { - OldOracle common.Address - NewOracle common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterGasOracleUpdated is a free log retrieval operation binding the contract event 0x73832aa215e2812d2f0c40bd0cf9df82495d3a46da4be338a17d63fb20e108f9. -// -// Solidity: event GasOracleUpdated(address indexed oldOracle, address indexed newOracle) -func (_CoreRelayer *CoreRelayerFilterer) FilterGasOracleUpdated(opts *bind.FilterOpts, oldOracle []common.Address, newOracle []common.Address) (*CoreRelayerGasOracleUpdatedIterator, error) { - - var oldOracleRule []interface{} - for _, oldOracleItem := range oldOracle { - oldOracleRule = append(oldOracleRule, oldOracleItem) - } - var newOracleRule []interface{} - for _, newOracleItem := range newOracle { - newOracleRule = append(newOracleRule, newOracleItem) - } - - logs, sub, err := _CoreRelayer.contract.FilterLogs(opts, "GasOracleUpdated", oldOracleRule, newOracleRule) - if err != nil { - return nil, err - } - return &CoreRelayerGasOracleUpdatedIterator{contract: _CoreRelayer.contract, event: "GasOracleUpdated", logs: logs, sub: sub}, nil -} - -// WatchGasOracleUpdated is a free log subscription operation binding the contract event 0x73832aa215e2812d2f0c40bd0cf9df82495d3a46da4be338a17d63fb20e108f9. -// -// Solidity: event GasOracleUpdated(address indexed oldOracle, address indexed newOracle) -func (_CoreRelayer *CoreRelayerFilterer) WatchGasOracleUpdated(opts *bind.WatchOpts, sink chan<- *CoreRelayerGasOracleUpdated, oldOracle []common.Address, newOracle []common.Address) (event.Subscription, error) { - - var oldOracleRule []interface{} - for _, oldOracleItem := range oldOracle { - oldOracleRule = append(oldOracleRule, oldOracleItem) - } - var newOracleRule []interface{} - for _, newOracleItem := range newOracle { - newOracleRule = append(newOracleRule, newOracleItem) - } - - logs, sub, err := _CoreRelayer.contract.WatchLogs(opts, "GasOracleUpdated", oldOracleRule, newOracleRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CoreRelayerGasOracleUpdated) - if err := _CoreRelayer.contract.UnpackLog(event, "GasOracleUpdated", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseGasOracleUpdated is a log parse operation binding the contract event 0x73832aa215e2812d2f0c40bd0cf9df82495d3a46da4be338a17d63fb20e108f9. -// -// Solidity: event GasOracleUpdated(address indexed oldOracle, address indexed newOracle) -func (_CoreRelayer *CoreRelayerFilterer) ParseGasOracleUpdated(log types.Log) (*CoreRelayerGasOracleUpdated, error) { - event := new(CoreRelayerGasOracleUpdated) - if err := _CoreRelayer.contract.UnpackLog(event, "GasOracleUpdated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CoreRelayerOwnershipTransferedIterator is returned from FilterOwnershipTransfered and is used to iterate over the raw logs and unpacked data for OwnershipTransfered events raised by the CoreRelayer contract. -type CoreRelayerOwnershipTransferedIterator struct { - Event *CoreRelayerOwnershipTransfered // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CoreRelayerOwnershipTransferedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CoreRelayerOwnershipTransfered) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CoreRelayerOwnershipTransfered) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CoreRelayerOwnershipTransferedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CoreRelayerOwnershipTransferedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CoreRelayerOwnershipTransfered represents a OwnershipTransfered event raised by the CoreRelayer contract. -type CoreRelayerOwnershipTransfered struct { - OldOwner common.Address - NewOwner common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOwnershipTransfered is a free log retrieval operation binding the contract event 0x0d18b5fd22306e373229b9439188228edca81207d1667f604daf6cef8aa3ee67. -// -// Solidity: event OwnershipTransfered(address indexed oldOwner, address indexed newOwner) -func (_CoreRelayer *CoreRelayerFilterer) FilterOwnershipTransfered(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*CoreRelayerOwnershipTransferedIterator, error) { - - var oldOwnerRule []interface{} - for _, oldOwnerItem := range oldOwner { - oldOwnerRule = append(oldOwnerRule, oldOwnerItem) - } - var newOwnerRule []interface{} - for _, newOwnerItem := range newOwner { - newOwnerRule = append(newOwnerRule, newOwnerItem) - } - - logs, sub, err := _CoreRelayer.contract.FilterLogs(opts, "OwnershipTransfered", oldOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return &CoreRelayerOwnershipTransferedIterator{contract: _CoreRelayer.contract, event: "OwnershipTransfered", logs: logs, sub: sub}, nil -} - -// WatchOwnershipTransfered is a free log subscription operation binding the contract event 0x0d18b5fd22306e373229b9439188228edca81207d1667f604daf6cef8aa3ee67. -// -// Solidity: event OwnershipTransfered(address indexed oldOwner, address indexed newOwner) -func (_CoreRelayer *CoreRelayerFilterer) WatchOwnershipTransfered(opts *bind.WatchOpts, sink chan<- *CoreRelayerOwnershipTransfered, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { - - var oldOwnerRule []interface{} - for _, oldOwnerItem := range oldOwner { - oldOwnerRule = append(oldOwnerRule, oldOwnerItem) - } - var newOwnerRule []interface{} - for _, newOwnerItem := range newOwner { - newOwnerRule = append(newOwnerRule, newOwnerItem) - } - - logs, sub, err := _CoreRelayer.contract.WatchLogs(opts, "OwnershipTransfered", oldOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CoreRelayerOwnershipTransfered) - if err := _CoreRelayer.contract.UnpackLog(event, "OwnershipTransfered", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOwnershipTransfered is a log parse operation binding the contract event 0x0d18b5fd22306e373229b9439188228edca81207d1667f604daf6cef8aa3ee67. -// -// Solidity: event OwnershipTransfered(address indexed oldOwner, address indexed newOwner) -func (_CoreRelayer *CoreRelayerFilterer) ParseOwnershipTransfered(log types.Log) (*CoreRelayerOwnershipTransfered, error) { - event := new(CoreRelayerOwnershipTransfered) - if err := _CoreRelayer.contract.UnpackLog(event, "OwnershipTransfered", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// CoreRelayerUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the CoreRelayer contract. -type CoreRelayerUpgradedIterator struct { - Event *CoreRelayerUpgraded // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *CoreRelayerUpgradedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(CoreRelayerUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(CoreRelayerUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *CoreRelayerUpgradedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *CoreRelayerUpgradedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// CoreRelayerUpgraded represents a Upgraded event raised by the CoreRelayer contract. -type CoreRelayerUpgraded struct { - Implementation common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_CoreRelayer *CoreRelayerFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*CoreRelayerUpgradedIterator, error) { - - var implementationRule []interface{} - for _, implementationItem := range implementation { - implementationRule = append(implementationRule, implementationItem) - } - - logs, sub, err := _CoreRelayer.contract.FilterLogs(opts, "Upgraded", implementationRule) - if err != nil { - return nil, err - } - return &CoreRelayerUpgradedIterator{contract: _CoreRelayer.contract, event: "Upgraded", logs: logs, sub: sub}, nil -} - -// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_CoreRelayer *CoreRelayerFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *CoreRelayerUpgraded, implementation []common.Address) (event.Subscription, error) { - - var implementationRule []interface{} - for _, implementationItem := range implementation { - implementationRule = append(implementationRule, implementationItem) - } - - logs, sub, err := _CoreRelayer.contract.WatchLogs(opts, "Upgraded", implementationRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(CoreRelayerUpgraded) - if err := _CoreRelayer.contract.UnpackLog(event, "Upgraded", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_CoreRelayer *CoreRelayerFilterer) ParseUpgraded(log types.Log) (*CoreRelayerUpgraded, error) { - event := new(CoreRelayerUpgraded) - if err := _CoreRelayer.contract.UnpackLog(event, "Upgraded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/offchain-relayer/.relayer.yaml b/offchain-relayer/relayer.tilt.yaml similarity index 75% rename from offchain-relayer/.relayer.yaml rename to offchain-relayer/relayer.tilt.yaml index e99c7f2..968e67a 100644 --- a/offchain-relayer/.relayer.yaml +++ b/offchain-relayer/relayer.tilt.yaml @@ -1,10 +1,10 @@ evmRPC: ws://localhost:8545 -evmContract: 0x2f3efA6bbDC5fAf4dC1a600765c7B7829e47bE10 +evmContract: 0xdeadbeef evmWormholeChainID: 2 evmNetworkID: 1 evm2RPC: ws://localhost:8546 -evm2Contract: 0x2f3efA6bbDC5fAf4dC1a600765c7B7829e47bE10 +evm2Contract: 0xdeadbeef evm2WormholeChainID: 4 evm2NetworkID: 56 diff --git a/sdk/src/__tests__/eth-integration.ts b/sdk/src/__tests__/eth-integration.ts index 5540031..05dfe4a 100644 --- a/sdk/src/__tests__/eth-integration.ts +++ b/sdk/src/__tests__/eth-integration.ts @@ -10,19 +10,19 @@ import { ZERO_ADDRESS_BYTES, TARGET_GAS_LIMIT, } from "./helpers/consts"; -import {RelayerArgs } from "./helpers/structs"; +import { RelayerArgs } from "./helpers/structs"; import { makeCoreRelayerFromForgeBroadcast, makeGasOracleFromForgeBroadcast, makeMockRelayerIntegrationFromForgeBroadcast, - resolvePath + resolvePath, } from "./helpers/utils"; import { CHAIN_ID_BSC, CHAIN_ID_ETH, getSignedBatchVAAWithRetry, tryNativeToUint8Array, - tryNativeToHexString + tryNativeToHexString, } from "@certusone/wormhole-sdk"; import { NodeHttpTransport } from "@improbable-eng/grpc-web-node-http-transport"; @@ -113,24 +113,6 @@ describe("ETH <> BSC Generic Relayer Integration Test", () => { .registerChain(CHAIN_ID_BSC, tryNativeToUint8Array(bscCoreRelayer.address, CHAIN_ID_BSC)) .then((tx) => tx.wait()); } - - // Query the mock relayer integration contracts to see if trusted mock relayer - // integration contracts have been registered. - const trustedSenderOnBsc = await bscRelayerIntegrator.trustedSender(CHAIN_ID_ETH); - const trustedSenderOnEth = await ethRelayerIntegrator.trustedSender(CHAIN_ID_BSC); - - // register the trusted mock relayer integration contracts - if (trustedSenderOnBsc == ZERO_ADDRESS_BYTES) { - await bscRelayerIntegrator - .registerTrustedSender(CHAIN_ID_ETH, tryNativeToUint8Array(ethRelayerIntegrator.address, CHAIN_ID_ETH)) - .then((tx) => tx.wait()); - } - - if (trustedSenderOnEth == ZERO_ADDRESS_BYTES) { - await ethRelayerIntegrator - .registerTrustedSender(CHAIN_ID_BSC, tryNativeToUint8Array(bscRelayerIntegrator.address, CHAIN_ID_BSC)) - .then((tx) => tx.wait()); - } }); describe("Send from Ethereum and Deliver to BSC", () => { @@ -178,7 +160,6 @@ describe("ETH <> BSC Generic Relayer Integration Test", () => { targetAddress: bscRelayerIntegrator.address, targetGasLimit: TARGET_GAS_LIMIT, consistencyLevel: batchVaaConsistencyLevels[0], - deliveryListIndices: [] as number[], // no indices specified for full batch delivery }; // call the mock integration contract and send the batch VAA @@ -204,12 +185,12 @@ describe("ETH <> BSC Generic Relayer Integration Test", () => { it("Wait for off-chain relayer to deliver the batch VAA to BSC", async () => { // parse the batch VAA - const parsedBatch = await ethRelayerIntegrator.parseBatchVM(batchVaaFromEth); + const parsedBatch = await ethRelayerIntegrator.parseWormholeBatch(batchVaaFromEth); // Check to see if the batch VAA was delivered by querying the contract // for the first payload sent in the batch. let isBatchDelivered: boolean = false; - const targetVm3 = parsedBatch.indexedObservations[0].vm3; + const targetVm3 = await ethRelayerIntegrator.parseWormholeObservation(parsedBatch.observations[0]); while (!isBatchDelivered) { // query the contract to see if the batch was delivered const storedPayload = await bscRelayerIntegrator.getPayload(targetVm3.hash); @@ -219,11 +200,11 @@ describe("ETH <> BSC Generic Relayer Integration Test", () => { } // confirm that the remaining payloads are stored in the contract - for (const indexedObservation of parsedBatch.indexedObservations) { - const vm3 = indexedObservation.vm3; + for (const observation of parsedBatch.observations) { + const vm3 = await bscRelayerIntegrator.parseWormholeObservation(observation); // skip delivery instructions VM - if (vm3.emitterAddress == "0x"+tryNativeToHexString(ethCoreRelayer.address, CHAIN_ID_ETH)) { + if (vm3.emitterAddress == "0x" + tryNativeToHexString(ethCoreRelayer.address, CHAIN_ID_ETH)) { continue; } diff --git a/sdk/src/__tests__/helpers/structs.ts b/sdk/src/__tests__/helpers/structs.ts index 8a86836..12eac6d 100644 --- a/sdk/src/__tests__/helpers/structs.ts +++ b/sdk/src/__tests__/helpers/structs.ts @@ -1,4 +1,4 @@ -import {ethers} from "ethers"; +import { ethers } from "ethers"; export interface RelayerArgs { nonce: number; @@ -6,7 +6,6 @@ export interface RelayerArgs { targetAddress: string; targetGasLimit: number; consistencyLevel: number; - deliveryListIndices: number[]; } export interface TargetDeliveryParameters {