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

effort to rename to WormholeRelayer

This commit is contained in:
derpy-duck 2023-02-27 19:53:09 +00:00
parent f7de3d649d
commit 960eabb069
38 changed files with 246 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -29,7 +29,7 @@ Fundamentally, the relayer service should require no additional trust assumption
Generic relayers consist of three components:
1. `CoreRelayer` contract lives on all chains that integrators interact with to request for a generic relayer to deliver a cross-chain message.
1. `WormholeRelayer` contract lives on all chains that integrators interact with to request for a generic relayer to deliver a cross-chain message.
2. `GasOracle` contract lives on all chains that provides an estimate to the gas costs associated with a particular cross-chain message. This is a critical function to ensure that users/applications are appropriately covering the costs that relayers face when submitting a transaction on the destination chain.
3. Off-chain Relayer that listens for VAAs that it is assigned to, redeems the VAA from the Guardian Network, and submits the VAA on the destination chain.

4
ethereum/contracts/mock/AttackForwardIntegration.sol
View File

@ -22,10 +22,10 @@ contract AttackForwardIntegration is IWormholeReceiver {
// This just needs to be enough to pay for the call to the destination address.
uint32 SAFE_DELIVERY_GAS_CAPTURE = 30000;
constructor(IWormhole initWormhole, IWormholeRelayer initCoreRelayer, uint16 chainId, address initAttackerReward) {
constructor(IWormhole initWormhole, IWormholeRelayer initWormholeRelayer, uint16 chainId, address initAttackerReward) {
attackerReward = initAttackerReward;
wormhole = initWormhole;
core_relayer = initCoreRelayer;
core_relayer = initWormholeRelayer;
targetChainId = chainId;
}

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

@ -26,13 +26,13 @@ abstract contract RelayProviderGovernance is RelayProviderGetters, RelayProvider
event RewardAddressUpdated(address indexed newAddress);
event DeliveryAddressUpdated(uint16 indexed targetChainId, bytes32 indexed newAddress);
event DeliverGasOverheadUpdated(uint32 indexed oldGasOverhead, uint32 indexed newGasOverhead);
event CoreRelayerUpdated(address coreRelayer);
event WormholeRelayerUpdated(address coreRelayer);
event ApprovedSenderUpdated(address sender, bool approved);
event AssetConversionBufferUpdated(uint16 targetChain, uint16 buffer, uint16 bufferDenominator);
function updateCoreRelayer(address payable newAddress) public onlyOwner {
setCoreRelayer(newAddress);
emit CoreRelayerUpdated(newAddress);
function updateWormholeRelayer(address payable newAddress) public onlyOwner {
setWormholeRelayer(newAddress);
emit WormholeRelayerUpdated(newAddress);
}
function updateApprovedSender(address sender, bool approved) public onlyOwner {

2
ethereum/contracts/relayProvider/RelayProviderSetters.sol
View File

@ -24,7 +24,7 @@ contract RelayProviderSetters is Context, RelayProviderState {
_state.chainId = thisChain;
}
function setCoreRelayer(address payable coreRelayer) internal {
function setWormholeRelayer(address payable coreRelayer) internal {
_state.coreRelayer = coreRelayer;
}

2
ethereum/contracts/relayProvider/RelayProviderState.sol
View File

@ -41,7 +41,7 @@ contract RelayProviderStorage {
mapping(uint16 => uint16) assetConversionBuffer;
// Dictionary of wormhole chain id -> assetConversionBufferDenominator
mapping(uint16 => uint16) assetConversionBufferDenominator;
// Reward address for the relayer. The CoreRelayer contract transfers the reward for relaying messages here.
// Reward address for the relayer. The WormholeRelayer contract transfers the reward for relaying messages here.
address payable rewardAddress;
}
}

8
ethereum/contracts/coreRelayer/CoreRelayer.sol → ethereum/contracts/wormholeRelayer/WormholeRelayer.sol
View File

@ -6,10 +6,10 @@ pragma solidity ^0.8.0;
import "../interfaces/IWormholeRelayer.sol";
import "../interfaces/IWormholeReceiver.sol";
import "../interfaces/IDelivery.sol";
import "./CoreRelayerGovernance.sol";
import "./CoreRelayerStructs.sol";
import "./WormholeRelayerGovernance.sol";
import "./WormholeRelayerStructs.sol";
contract CoreRelayer is CoreRelayerGovernance {
contract WormholeRelayer is WormholeRelayerGovernance {
enum DeliveryStatus {
SUCCESS,
RECEIVER_FAILURE,
@ -280,7 +280,7 @@ contract CoreRelayer is CoreRelayerGovernance {
}
function verifyRelayerVM(IWormhole.VM memory vm) internal view returns (bool) {
return registeredCoreRelayerContract(vm.emitterChainId) == vm.emitterAddress;
return registeredWormholeRelayerContract(vm.emitterChainId) == vm.emitterAddress;
}
function getDefaultRelayProvider() public view returns (IRelayProvider) {

12
ethereum/contracts/coreRelayer/CoreRelayerGetters.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerGetters.sol
View File

@ -5,12 +5,12 @@ pragma solidity ^0.8.0;
import "../interfaces/IWormhole.sol";
import "../interfaces/IRelayProvider.sol";
import "./CoreRelayerStructs.sol";
import "./WormholeRelayerStructs.sol";
import "./CoreRelayerState.sol";
import "./WormholeRelayerState.sol";
import "../libraries/external/BytesLib.sol";
contract CoreRelayerGetters is CoreRelayerState {
contract WormholeRelayerGetters is WormholeRelayerState {
using BytesLib for bytes;
function governanceActionIsConsumed(bytes32 hash) public view returns (bool) {
@ -49,15 +49,15 @@ contract CoreRelayerGetters is CoreRelayerState {
return evmChainId() != block.chainid;
}
function registeredCoreRelayerContract(uint16 chain) public view returns (bytes32) {
return _state.registeredCoreRelayerContract[chain];
function registeredWormholeRelayerContract(uint16 chain) public view returns (bytes32) {
return _state.registeredWormholeRelayerContract[chain];
}
function defaultRelayProvider() internal view returns (IRelayProvider) {
return IRelayProvider(_state.defaultRelayProvider);
}
function getForwardInstruction() internal view returns (CoreRelayerStructs.ForwardInstruction memory) {
function getForwardInstruction() internal view returns (WormholeRelayerStructs.ForwardInstruction memory) {
return _state.forwardInstruction;
}

32
ethereum/contracts/coreRelayer/CoreRelayerGovernance.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerGovernance.sol
View File

@ -7,18 +7,18 @@ import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol";
import "../libraries/external/BytesLib.sol";
import "./CoreRelayerGetters.sol";
import "./CoreRelayerSetters.sol";
import "./CoreRelayerStructs.sol";
import "./CoreRelayerMessages.sol";
import "./WormholeRelayerGetters.sol";
import "./WormholeRelayerSetters.sol";
import "./WormholeRelayerStructs.sol";
import "./WormholeRelayerMessages.sol";
import "../interfaces/IWormhole.sol";
import "./CoreRelayerLibrary.sol";
import "./WormholeRelayerLibrary.sol";
abstract contract CoreRelayerGovernance is
CoreRelayerGetters,
CoreRelayerSetters,
CoreRelayerMessages,
abstract contract WormholeRelayerGovernance is
WormholeRelayerGetters,
WormholeRelayerSetters,
WormholeRelayerMessages,
ERC1967Upgrade
{
using BytesLib for bytes;
@ -31,7 +31,7 @@ abstract contract CoreRelayerGovernance is
event ContractUpgraded(address indexed oldContract, address indexed newContract);
// "CoreRelayer" (left padded)
// "WormholeRelayer" (left padded)
bytes32 constant module = 0x000000000000000000000000000000000000000000436f726552656c61796572;
function submitContractUpgrade(bytes memory _vm) public {
@ -46,7 +46,7 @@ abstract contract CoreRelayerGovernance is
setConsumedGovernanceAction(vm.hash);
CoreRelayerLibrary.ContractUpgrade memory contractUpgrade = CoreRelayerLibrary.parseUpgrade(vm.payload, module);
WormholeRelayerLibrary.ContractUpgrade memory contractUpgrade = WormholeRelayerLibrary.parseUpgrade(vm.payload, module);
if (contractUpgrade.chain != chainId()) {
revert WrongChainId(contractUpgrade.chain);
}
@ -54,7 +54,7 @@ abstract contract CoreRelayerGovernance is
upgradeImplementation(contractUpgrade.newContract);
}
function registerCoreRelayerContract(bytes memory vaa) public {
function registerWormholeRelayerContract(bytes memory vaa) public {
(IWormhole.VM memory vm, bool valid, string memory reason) = verifyGovernanceVM(vaa);
if (!valid) {
revert InvalidGovernanceVM(string(reason));
@ -62,13 +62,13 @@ abstract contract CoreRelayerGovernance is
setConsumedGovernanceAction(vm.hash);
CoreRelayerLibrary.RegisterChain memory rc = CoreRelayerLibrary.parseRegisterChain(vm.payload, module);
WormholeRelayerLibrary.RegisterChain memory rc = WormholeRelayerLibrary.parseRegisterChain(vm.payload, module);
if ((rc.chain != chainId() || isFork()) && rc.chain != 0) {
revert InvalidChainId(rc.chain);
}
setRegisteredCoreRelayerContract(rc.emitterChain, rc.emitterAddress);
setRegisteredWormholeRelayerContract(rc.emitterChain, rc.emitterAddress);
}
function setDefaultRelayProvider(bytes memory vaa) public {
@ -79,8 +79,8 @@ abstract contract CoreRelayerGovernance is
setConsumedGovernanceAction(vm.hash);
CoreRelayerLibrary.UpdateDefaultProvider memory provider =
CoreRelayerLibrary.parseUpdateDefaultProvider(vm.payload, module);
WormholeRelayerLibrary.UpdateDefaultProvider memory provider =
WormholeRelayerLibrary.parseUpdateDefaultProvider(vm.payload, module);
if ((provider.chain != chainId() || isFork()) && provider.chain != 0) {
revert InvalidChainId(provider.chain);

4
ethereum/contracts/coreRelayer/CoreRelayerImplementation.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerImplementation.sol
View File

@ -5,9 +5,9 @@ pragma solidity ^0.8.0;
import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol";
import "./CoreRelayer.sol";
import "./WormholeRelayer.sol";
contract CoreRelayerImplementation is CoreRelayer {
contract WormholeRelayerImplementation is WormholeRelayer {
error ImplementationAlreadyInitialized();
function initialize() public virtual initializer {

2
ethereum/contracts/coreRelayer/CoreRelayerLibrary.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerLibrary.sol
View File

@ -3,7 +3,7 @@ pragma solidity ^0.8.0;
import "../libraries/external/BytesLib.sol";
library CoreRelayerLibrary {
library WormholeRelayerLibrary {
using BytesLib for bytes;
error WrongModule(bytes32 module);

6
ethereum/contracts/coreRelayer/CoreRelayerMessages.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerMessages.sol
View File

@ -5,11 +5,11 @@ pragma solidity ^0.8.0;
import "../libraries/external/BytesLib.sol";
import "./CoreRelayerGetters.sol";
import "./CoreRelayerStructs.sol";
import "./WormholeRelayerGetters.sol";
import "./WormholeRelayerStructs.sol";
import "../interfaces/IWormholeRelayer.sol";
contract CoreRelayerMessages is CoreRelayerStructs, CoreRelayerGetters {
contract WormholeRelayerMessages is WormholeRelayerStructs, WormholeRelayerGetters {
using BytesLib for bytes;
error InvalidPayloadId(uint8 payloadId);

2
ethereum/contracts/coreRelayer/CoreRelayerProxy.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerProxy.sol
View File

@ -5,6 +5,6 @@ pragma solidity ^0.8.0;
import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
contract CoreRelayerProxy is ERC1967Proxy {
contract WormholeRelayerProxy is ERC1967Proxy {
constructor(address implementation, bytes memory initData) ERC1967Proxy(implementation, initData) {}
}

12
ethereum/contracts/coreRelayer/CoreRelayerSetters.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerSetters.sol
View File

@ -3,12 +3,12 @@
pragma solidity ^0.8.0;
import "./CoreRelayerState.sol";
import "./WormholeRelayerState.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "./CoreRelayerStructs.sol";
import "./WormholeRelayerStructs.sol";
import {IWormhole} from "../interfaces/IWormhole.sol";
contract CoreRelayerSetters is CoreRelayerState, Context {
contract WormholeRelayerSetters is WormholeRelayerState, Context {
error InvalidEvmChainId();
function setInitialized(address implementation) internal {
@ -43,11 +43,11 @@ contract CoreRelayerSetters is CoreRelayerState, Context {
_state.defaultRelayProvider = defaultRelayProvider;
}
function setRegisteredCoreRelayerContract(uint16 chainId, bytes32 relayerAddress) internal {
_state.registeredCoreRelayerContract[chainId] = relayerAddress;
function setRegisteredWormholeRelayerContract(uint16 chainId, bytes32 relayerAddress) internal {
_state.registeredWormholeRelayerContract[chainId] = relayerAddress;
}
function setForwardInstruction(CoreRelayerStructs.ForwardInstruction memory request) internal {
function setForwardInstruction(WormholeRelayerStructs.ForwardInstruction memory request) internal {
_state.forwardInstruction = request;
}

4
ethereum/contracts/coreRelayer/CoreRelayerSetup.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerSetup.sol
View File

@ -3,11 +3,11 @@
pragma solidity ^0.8.0;
import "./CoreRelayerGovernance.sol";
import "./WormholeRelayerGovernance.sol";
import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol";
contract CoreRelayerSetup is CoreRelayerSetters, ERC1967Upgrade {
contract WormholeRelayerSetup is WormholeRelayerSetters, ERC1967Upgrade {
error ImplementationAddressIsZero();
error WormholeAddressIsZero();
error DefaultRelayProviderAddressIsZero();

12
ethereum/contracts/coreRelayer/CoreRelayerState.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerState.sol
View File

@ -3,9 +3,9 @@
pragma solidity ^0.8.0;
import "./CoreRelayerStructs.sol";
import "./WormholeRelayerStructs.sol";
contract CoreRelayerStorage {
contract WormholeRelayerStorage {
struct Provider {
uint16 chainId;
address payable wormhole;
@ -27,16 +27,16 @@ contract CoreRelayerStorage {
// address of the default relay provider on this chain
address defaultRelayProvider;
// Request which will be forwarded from the current delivery.
CoreRelayerStructs.ForwardInstruction forwardInstruction;
WormholeRelayerStructs.ForwardInstruction forwardInstruction;
// mapping of initialized implementations
mapping(address => bool) initializedImplementations;
// mapping of relayer contracts on other chains
mapping(uint16 => bytes32) registeredCoreRelayerContract;
mapping(uint16 => bytes32) registeredWormholeRelayerContract;
// storage gap to reduce risk of storage collisions
uint256[50] ______gap;
}
}
contract CoreRelayerState {
CoreRelayerStorage.State _state;
contract WormholeRelayerState {
WormholeRelayerStorage.State _state;
}

2
ethereum/contracts/coreRelayer/CoreRelayerStructs.sol → ethereum/contracts/wormholeRelayer/WormholeRelayerStructs.sol
View File

@ -5,7 +5,7 @@ pragma solidity ^0.8.0;
import "../interfaces/IWormholeRelayer.sol";
abstract contract CoreRelayerStructs {
abstract contract WormholeRelayerStructs {
struct DeliveryInstructionsContainer {
uint8 payloadId; //1
bool sufficientlyFunded;

42
ethereum/forge-scripts/deploy_contracts.sol
View File

@ -10,10 +10,10 @@ import {RelayProvider} from "contracts/relayProvider/RelayProvider.sol";
import {RelayProviderSetup} from "contracts/relayProvider/RelayProviderSetup.sol";
import {RelayProviderImplementation} from "contracts/relayProvider/RelayProviderImplementation.sol";
import {RelayProviderProxy} from "contracts/relayProvider/RelayProviderProxy.sol";
import {CoreRelayer} from "contracts/coreRelayer/CoreRelayer.sol";
import {CoreRelayerSetup} from "contracts/coreRelayer/CoreRelayerSetup.sol";
import {CoreRelayerImplementation} from "contracts/coreRelayer/CoreRelayerImplementation.sol";
import {CoreRelayerProxy} from "contracts/coreRelayer/CoreRelayerProxy.sol";
import {WormholeRelayer} from "contracts/coreRelayer/WormholeRelayer.sol";
import {WormholeRelayerSetup} from "contracts/coreRelayer/WormholeRelayerSetup.sol";
import {WormholeRelayerImplementation} from "contracts/coreRelayer/WormholeRelayerImplementation.sol";
import {WormholeRelayerProxy} from "contracts/coreRelayer/WormholeRelayerProxy.sol";
import {MockRelayerIntegration} from "contracts/mock/MockRelayerIntegration.sol";
import "forge-std/console.sol";
@ -28,7 +28,7 @@ import "forge-std/console.sol";
// Call setup
// Set Reward Address, set delivery address, set delivergasoverhead, set price table, set maximum budget
//Step 2: Deploy CoreRelayer
//Step 2: Deploy WormholeRelayer
// Deploy Contracts
// Call setup
// later: register all core relayers with eachother
@ -46,11 +46,11 @@ contract ContractScript is Script {
RelayProviderImplementation relayProviderImplementation;
RelayProviderProxy relayProviderProxy;
// CoreRelayer
CoreRelayerSetup coreRelayerSetup;
CoreRelayerImplementation coreRelayerImplementation;
CoreRelayerProxy coreRelayerProxy;
CoreRelayer coreRelayer;
// WormholeRelayer
WormholeRelayerSetup coreRelayerSetup;
WormholeRelayerImplementation coreRelayerImplementation;
WormholeRelayerProxy coreRelayerProxy;
WormholeRelayer coreRelayer;
// MockRelayerIntegration
MockRelayerIntegration mockRelayerIntegration;
@ -86,15 +86,15 @@ contract ContractScript is Script {
}
}
function deployCoreRelayer() public {
function deployWormholeRelayer() public {
// first Setup
coreRelayerSetup = new CoreRelayerSetup();
coreRelayerSetup = new WormholeRelayerSetup();
// next Implementation
coreRelayerImplementation = new CoreRelayerImplementation();
coreRelayerImplementation = new WormholeRelayerImplementation();
// setup Proxy using Implementation
coreRelayerProxy = new CoreRelayerProxy(
coreRelayerProxy = new WormholeRelayerProxy(
address(coreRelayerSetup),
abi.encodeWithSelector(
bytes4(keccak256("setup(address,uint16,address,address)")),
@ -110,13 +110,13 @@ contract ContractScript is Script {
migrations.setCompleted(69);
}
coreRelayer = CoreRelayer(address(coreRelayerProxy));
coreRelayer = WormholeRelayer(address(coreRelayerProxy));
}
function configureRelayProvider() public {
address currentAddress = address(this);
RelayProvider provider = RelayProvider(address(relayProviderProxy));
CoreRelayer core_relayer = CoreRelayer(address(coreRelayerProxy));
WormholeRelayer core_relayer = WormholeRelayer(address(coreRelayerProxy));
//Set Reward Address,
provider.updateRewardAddress(currentAddress);
@ -150,11 +150,11 @@ contract ContractScript is Script {
}
}
function configureCoreRelayer() public {
function configureWormholeRelayer() public {
//Only thing to do here is register all the chains together
// contract already registers itself in the setup
// CoreRelayer core_relayer = CoreRelayer(address(coreRelayerProxy));
// core_relayer.registerCoreRelayerContract(chainId, core_relayer.toWormholeFormat(address(core_relayer)));
// WormholeRelayer core_relayer = WormholeRelayer(address(coreRelayerProxy));
// core_relayer.registerWormholeRelayerContract(chainId, core_relayer.toWormholeFormat(address(core_relayer)));
}
// function deployMockRelayerIntegration() public {
@ -191,10 +191,10 @@ contract ContractScript is Script {
vm.startBroadcast();
deployRelayProvider();
deployCoreRelayer();
deployWormholeRelayer();
configureRelayProvider();
configureCoreRelayer();
configureWormholeRelayer();
vm.roll(block.number + 1);

52
ethereum/forge-test/CoreRelayer.t.sol → ethereum/forge-test/WormholeRelayer.t.sol
View File

@ -11,13 +11,13 @@ import {RelayProviderMessages} from "../contracts/relayProvider/RelayProviderMes
import {RelayProviderStructs} from "../contracts/relayProvider/RelayProviderStructs.sol";
import {IWormholeRelayer} from "../contracts/interfaces/IWormholeRelayer.sol";
import {IDelivery} from "../contracts/interfaces/IDelivery.sol";
import {CoreRelayer} from "../contracts/coreRelayer/CoreRelayer.sol";
import {CoreRelayerStructs} from "../contracts/coreRelayer/CoreRelayerStructs.sol";
import {CoreRelayerSetup} from "../contracts/coreRelayer/CoreRelayerSetup.sol";
import {CoreRelayerImplementation} from "../contracts/coreRelayer/CoreRelayerImplementation.sol";
import {CoreRelayerProxy} from "../contracts/coreRelayer/CoreRelayerProxy.sol";
import {CoreRelayerMessages} from "../contracts/coreRelayer/CoreRelayerMessages.sol";
import {CoreRelayerStructs} from "../contracts/coreRelayer/CoreRelayerStructs.sol";
import {WormholeRelayer} from "../contracts/coreRelayer/WormholeRelayer.sol";
import {WormholeRelayerStructs} from "../contracts/coreRelayer/WormholeRelayerStructs.sol";
import {WormholeRelayerSetup} from "../contracts/coreRelayer/WormholeRelayerSetup.sol";
import {WormholeRelayerImplementation} from "../contracts/coreRelayer/WormholeRelayerImplementation.sol";
import {WormholeRelayerProxy} from "../contracts/coreRelayer/WormholeRelayerProxy.sol";
import {WormholeRelayerMessages} from "../contracts/coreRelayer/WormholeRelayerMessages.sol";
import {WormholeRelayerStructs} from "../contracts/coreRelayer/WormholeRelayerStructs.sol";
import {MockWormhole} from "../contracts/mock/MockWormhole.sol";
import {IWormhole} from "../contracts/interfaces/IWormhole.sol";
import {WormholeSimulator, FakeWormholeSimulator} from "./WormholeSimulator.sol";
@ -29,7 +29,7 @@ import "../contracts/libraries/external/BytesLib.sol";
import "forge-std/Test.sol";
import "forge-std/console.sol";
contract TestCoreRelayer is Test {
contract TestWormholeRelayer is Test {
using BytesLib for bytes;
uint16 MAX_UINT16_VALUE = 65535;
@ -103,16 +103,16 @@ contract TestCoreRelayer is Test {
relayProvider = RelayProvider(address(myRelayProvider));
}
function setUpCoreRelayer(uint16 chainId, IWormhole wormhole, address defaultRelayProvider)
function setUpWormholeRelayer(uint16 chainId, IWormhole wormhole, address defaultRelayProvider)
internal
returns (IWormholeRelayer coreRelayer)
{
CoreRelayerSetup coreRelayerSetup = new CoreRelayerSetup();
CoreRelayerImplementation coreRelayerImplementation = new CoreRelayerImplementation();
CoreRelayerProxy myCoreRelayer = new CoreRelayerProxy(
WormholeRelayerSetup coreRelayerSetup = new WormholeRelayerSetup();
WormholeRelayerImplementation coreRelayerImplementation = new WormholeRelayerImplementation();
WormholeRelayerProxy myWormholeRelayer = new WormholeRelayerProxy(
address(coreRelayerSetup),
abi.encodeCall(
CoreRelayerSetup.setup,
WormholeRelayerSetup.setup,
(
address(coreRelayerImplementation),
chainId,
@ -124,7 +124,7 @@ contract TestCoreRelayer is Test {
)
)
);
coreRelayer = IWormholeRelayer(address(myCoreRelayer));
coreRelayer = IWormholeRelayer(address(myWormholeRelayer));
}
struct StandardSetupTwoChains {
@ -218,7 +218,7 @@ contract TestCoreRelayer is Test {
WormholeSimulator wormholeSimulator;
RelayProvider relayProvider;
IWormholeRelayer coreRelayer;
CoreRelayer coreRelayerFull;
WormholeRelayer coreRelayerFull;
MockRelayerIntegration integration;
address relayer;
address payable rewardAddress;
@ -233,8 +233,8 @@ contract TestCoreRelayer is Test {
Contracts memory mapEntry;
(mapEntry.wormhole, mapEntry.wormholeSimulator) = setUpWormhole(i);
mapEntry.relayProvider = setUpRelayProvider(i);
mapEntry.coreRelayer = setUpCoreRelayer(i, mapEntry.wormhole, address(mapEntry.relayProvider));
mapEntry.coreRelayerFull = CoreRelayer(address(mapEntry.coreRelayer));
mapEntry.coreRelayer = setUpWormholeRelayer(i, mapEntry.wormhole, address(mapEntry.relayProvider));
mapEntry.coreRelayerFull = WormholeRelayer(address(mapEntry.coreRelayer));
mapEntry.integration = new MockRelayerIntegration(address(mapEntry.wormhole), address(mapEntry.coreRelayer));
mapEntry.relayer = address(uint160(uint256(keccak256(abi.encodePacked(bytes("relayer"), i)))));
mapEntry.refundAddress =
@ -250,7 +250,7 @@ contract TestCoreRelayer is Test {
map[i].relayProvider.updateDeliveryAddress(j, bytes32(uint256(uint160(map[j].relayer))));
map[i].relayProvider.updateAssetConversionBuffer(j, 500, 10000);
map[i].relayProvider.updateRewardAddress(map[i].rewardAddress);
registerCoreRelayerContract(
registerWormholeRelayerContract(
map[i].coreRelayerFull, i, j, bytes32(uint256(uint160(address(map[j].coreRelayer))))
);
map[i].relayProvider.updateMaximumBudget(j, maxBudget);
@ -259,8 +259,8 @@ contract TestCoreRelayer is Test {
}
}
function registerCoreRelayerContract(
CoreRelayer governance,
function registerWormholeRelayerContract(
WormholeRelayer governance,
uint16 currentChainId,
uint16 chainId,
bytes32 coreRelayerContractAddress
@ -283,7 +283,7 @@ contract TestCoreRelayer is Test {
});
bytes memory signed = relayerWormholeSimulator.encodeAndSignMessage(preSignedMessage);
governance.registerCoreRelayerContract(signed);
governance.registerWormholeRelayerContract(signed);
}
function within(uint256 a, uint256 b, uint256 c) internal view returns (bool) {
@ -462,7 +462,7 @@ contract TestCoreRelayer is Test {
// 3. The delivery of the message triggers a refund to the malicious integration contract.
// 4. During the refund, the integration contract activates the forwarding mechanism.
// This is allowed due to the integration contract also being the target of the delivery.
// 5. The forward request is left as is in the `CoreRelayer` state.
// 5. The forward request is left as is in the `WormholeRelayer` state.
// 6. The next message (i.e. the victim's message) delivery on `target` chain, from any relayer, using any `RelayProvider` and any integration contract,
// will see the forward request placed by the malicious integration contract and act on it.
// Caveat: the delivery of the victim's message must not invoke the forwarding mechanism for the attack test to be meaningful.
@ -780,7 +780,7 @@ contract TestCoreRelayer is Test {
IWormholeRelayer.ResendByTx redeliveryRequest;
IDelivery.TargetDeliveryParametersSingle originalDelivery;
IDelivery.TargetRedeliveryByTxHashParamsSingle package;
CoreRelayer.RedeliveryByTxHashInstruction instruction;
WormholeRelayer.RedeliveryByTxHashInstruction instruction;
}
function invalidateVM(bytes memory message, WormholeSimulator simulator) internal {
@ -1068,7 +1068,7 @@ contract TestCoreRelayer is Test {
IWormhole.VM parsed;
uint256 budget;
IDelivery.TargetDeliveryParametersSingle package;
CoreRelayer.DeliveryInstruction instruction;
WormholeRelayer.DeliveryInstruction instruction;
}
function testRevertDeliveryErrors(
@ -1407,7 +1407,7 @@ contract TestCoreRelayer is Test {
) internal {
uint8 payloadId = parsedInstruction.payload.toUint8(0);
if (payloadId == 1) {
CoreRelayer.DeliveryInstructionsContainer memory container =
WormholeRelayer.DeliveryInstructionsContainer memory container =
contracts.coreRelayerFull.decodeDeliveryInstructionsContainer(parsedInstruction.payload);
for (uint8 k = 0; k < container.instructions.length; k++) {
uint256 budget =
@ -1425,7 +1425,7 @@ contract TestCoreRelayer is Test {
pastDeliveries[keccak256(abi.encodePacked(parsedInstruction.hash, k))] = package;
}
} else if (payloadId == 2) {
CoreRelayer.RedeliveryByTxHashInstruction memory instruction =
WormholeRelayer.RedeliveryByTxHashInstruction memory instruction =
contracts.coreRelayerFull.decodeRedeliveryInstruction(parsedInstruction.payload);
IDelivery.TargetDeliveryParametersSingle memory originalDelivery =
pastDeliveries[keccak256(abi.encodePacked(instruction.sourceTxHash, instruction.multisendIndex))];

2
ethereum/ts-scripts/README.md
View File

@ -36,4 +36,4 @@ ENV=tilt ts-node ./ts-scripts/relayProvider/upgradeRelayProvider.ts && ts-node .
The ./shell directory contains shell scripts which combine commonly chained actions together.
For example, ./shell/deployConfigureTest.sh will deploy the RelayProvider, CoreRelayer, and MockIntegration contracts. Configure them all to point at eachother, and then run messageTest to test that everything worked. Note: useLastRun in contracts.json needs to be set to "true" in order for this script to work.
For example, ./shell/deployConfigureTest.sh will deploy the RelayProvider, WormholeRelayer, and MockIntegration contracts. Configure them all to point at eachother, and then run messageTest to test that everything worked. Note: useLastRun in contracts.json needs to be set to "true" in order for this script to work.

4
ethereum/ts-scripts/config/syncContractsJson.ts
View File

@ -1,6 +1,6 @@
import { readFileSync, writeFileSync } from "fs"
import {
getCoreRelayer,
getWormholeRelayer,
getMockIntegration,
getRelayProvider,
init,
@ -33,7 +33,7 @@ async function main() {
})
update(contracts.coreRelayers, {
chainId: chain.chainId,
address: getCoreRelayer(chain).address,
address: getWormholeRelayer(chain).address,
})
update(contracts.mockIntegrations, {
chainId: chain.chainId,

48
ethereum/ts-scripts/helpers/deployments.ts
View File

@ -2,10 +2,10 @@ import { RelayProviderProxy__factory } from "../../../sdk/src/ethers-contracts/f
import { RelayProviderSetup__factory } from "../../../sdk/src/ethers-contracts/factories/RelayProviderSetup__factory"
import { RelayProviderImplementation__factory } from "../../../sdk/src/ethers-contracts/factories/RelayProviderImplementation__factory"
import { MockRelayerIntegration__factory } from "../../../sdk/src"
import { CoreRelayerProxy__factory } from "../../../sdk/src/ethers-contracts/factories/CoreRelayerProxy__factory"
import { CoreRelayerSetup__factory } from "../../../sdk/src/ethers-contracts/factories/CoreRelayerSetup__factory"
import { CoreRelayerImplementation__factory } from "../../../sdk/src/ethers-contracts/factories/CoreRelayerImplementation__factory"
import { CoreRelayerLibrary__factory } from "../../../sdk/src/ethers-contracts/factories/CoreRelayerLibrary__factory"
import { WormholeRelayerProxy__factory } from "../../../sdk/src/ethers-contracts/factories/WormholeRelayerProxy__factory"
import { WormholeRelayerSetup__factory } from "../../../sdk/src/ethers-contracts/factories/WormholeRelayerSetup__factory"
import { WormholeRelayerImplementation__factory } from "../../../sdk/src/ethers-contracts/factories/WormholeRelayerImplementation__factory"
import { WormholeRelayerLibrary__factory } from "../../../sdk/src/ethers-contracts/factories/WormholeRelayerLibrary__factory"
import {
init,
@ -15,7 +15,7 @@ import {
ChainInfo,
Deployment,
getSigner,
getCoreRelayerAddress,
getWormholeRelayerAddress,
} from "./env"
import { ethers } from "ethers"
@ -82,19 +82,19 @@ export async function deployMockIntegration(chain: ChainInfo): Promise<Deploymen
const factory = new ethers.ContractFactory(contractInterface, bytecode, signer)
const contract = await factory.deploy(
chain.wormholeAddress,
getCoreRelayerAddress(chain)
getWormholeRelayerAddress(chain)
)
const result = await contract.deployed()
console.log("Successfully deployed contract at " + result.address)
return { address: result.address, chainId: chain.chainId }
}
export async function deployCoreRelayerLibrary(chain: ChainInfo): Promise<Deployment> {
console.log("deployCoreRelayerLibrary " + chain.chainId)
export async function deployWormholeRelayerLibrary(chain: ChainInfo): Promise<Deployment> {
console.log("deployWormholeRelayerLibrary " + chain.chainId)
let signer = getSigner(chain)
const contractInterface = CoreRelayerLibrary__factory.createInterface()
const bytecode = CoreRelayerLibrary__factory.bytecode
const contractInterface = WormholeRelayerLibrary__factory.createInterface()
const bytecode = WormholeRelayerLibrary__factory.bytecode
const factory = new ethers.ContractFactory(contractInterface, bytecode, signer)
const contract = await factory.deploy()
const result = await contract.deployed()
@ -102,24 +102,24 @@ export async function deployCoreRelayerLibrary(chain: ChainInfo): Promise<Deploy
return { address: result.address, chainId: chain.chainId }
}
export async function deployCoreRelayerImplementation(
export async function deployWormholeRelayerImplementation(
chain: ChainInfo,
coreRelayerLibraryAddress: string
): Promise<Deployment> {
console.log("deployCoreRelayerImplementation " + chain.chainId)
console.log("deployWormholeRelayerImplementation " + chain.chainId)
const signer = getSigner(chain)
const contractInterface = CoreRelayerImplementation__factory.createInterface()
const bytecode: string = CoreRelayerImplementation__factory.bytecode
const contractInterface = WormholeRelayerImplementation__factory.createInterface()
const bytecode: string = WormholeRelayerImplementation__factory.bytecode
/*
Linked libraries in EVM are contained in the bytecode and linked at compile time.
However, the linked address of the CoreRelayerLibrary is not known until deployment time,
However, the linked address of the WormholeRelayerLibrary is not known until deployment time,
So, rather that recompiling the contracts with a static link, we modify the bytecode directly
once we have the CoreRelayLibraryAddress.
*/
const bytecodeWithLibraryLink = link(
bytecode,
"CoreRelayerLibrary",
"WormholeRelayerLibrary",
coreRelayerLibraryAddress
)
@ -134,11 +134,11 @@ export async function deployCoreRelayerImplementation(
console.log("Successfully deployed contract at " + result.address)
return { address: result.address, chainId: chain.chainId }
}
export async function deployCoreRelayerSetup(chain: ChainInfo): Promise<Deployment> {
console.log("deployCoreRelayerSetup " + chain.chainId)
export async function deployWormholeRelayerSetup(chain: ChainInfo): Promise<Deployment> {
console.log("deployWormholeRelayerSetup " + chain.chainId)
const signer = getSigner(chain)
const contractInterface = CoreRelayerSetup__factory.createInterface()
const bytecode = CoreRelayerSetup__factory.bytecode
const contractInterface = WormholeRelayerSetup__factory.createInterface()
const bytecode = WormholeRelayerSetup__factory.bytecode
//@ts-ignore
const factory = new ethers.ContractFactory(contractInterface, bytecode, signer)
const contract = await factory.deploy()
@ -146,17 +146,17 @@ export async function deployCoreRelayerSetup(chain: ChainInfo): Promise<Deployme
console.log("Successfully deployed contract at " + result.address)
return { address: result.address, chainId: chain.chainId }
}
export async function deployCoreRelayerProxy(
export async function deployWormholeRelayerProxy(
chain: ChainInfo,
coreRelayerSetupAddress: string,
coreRelayerImplementationAddress: string,
wormholeAddress: string,
relayProviderProxyAddress: string
): Promise<Deployment> {
console.log("deployCoreRelayerProxy " + chain.chainId)
console.log("deployWormholeRelayerProxy " + chain.chainId)
const signer = getSigner(chain)
const contractInterface = CoreRelayerProxy__factory.createInterface()
const bytecode = CoreRelayerProxy__factory.bytecode
const contractInterface = WormholeRelayerProxy__factory.createInterface()
const bytecode = WormholeRelayerProxy__factory.bytecode
//@ts-ignore
const factory = new ethers.ContractFactory(contractInterface, bytecode, signer)

22
ethereum/ts-scripts/helpers/env.ts
View File

@ -2,10 +2,10 @@ import { ChainId } from "@certusone/wormhole-sdk"
import { ethers, Signer } from "ethers"
import fs from "fs"
import {
CoreRelayer,
WormholeRelayer,
RelayProvider,
RelayProvider__factory,
CoreRelayer__factory,
WormholeRelayer__factory,
MockRelayerIntegration,
MockRelayerIntegration__factory,
} from "../../../sdk/src"
@ -115,7 +115,7 @@ export function loadRelayProviders(): Deployment[] {
}
}
export function loadCoreRelayers(): Deployment[] {
export function loadWormholeRelayers(): Deployment[] {
const contractsFile = fs.readFileSync(`./ts-scripts/config/${env}/contracts.json`)
if (!contractsFile) {
throw Error("Failed to find contracts file for this process!")
@ -123,7 +123,7 @@ export function loadCoreRelayers(): Deployment[] {
const contracts = JSON.parse(contractsFile.toString())
if (contracts.useLastRun || lastRunOverride) {
const lastRunFile = fs.readFileSync(
`./ts-scripts/output/${env}/deployCoreRelayer/lastrun.json`
`./ts-scripts/output/${env}/deployWormholeRelayer/lastrun.json`
)
if (!lastRunFile) {
throw Error("Failed to find last run file for the Core Relayer process!")
@ -217,24 +217,24 @@ export function getRelayProvider(
return contract
}
export function getCoreRelayerAddress(chain: ChainInfo): string {
const thisChainsRelayer = loadCoreRelayers().find(
export function getWormholeRelayerAddress(chain: ChainInfo): string {
const thisChainsRelayer = loadWormholeRelayers().find(
(x: any) => x.chainId == chain.chainId
)?.address
if (!thisChainsRelayer) {
throw new Error(
"Failed to find a CoreRelayer contract address on chain " + chain.chainId
"Failed to find a WormholeRelayer contract address on chain " + chain.chainId
)
}
return thisChainsRelayer
}
export function getCoreRelayer(
export function getWormholeRelayer(
chain: ChainInfo,
provider?: ethers.providers.StaticJsonRpcProvider
): CoreRelayer {
const thisChainsRelayer = getCoreRelayerAddress(chain)
const contract = CoreRelayer__factory.connect(
): WormholeRelayer {
const thisChainsRelayer = getWormholeRelayerAddress(chain)
const contract = WormholeRelayer__factory.connect(
thisChainsRelayer,
provider || getSigner(chain)
)

6
ethereum/ts-scripts/helpers/vaa.ts
View File

@ -2,7 +2,7 @@ import { BigNumber, ethers } from "ethers"
import { ChainId, tryNativeToHexString } from "@certusone/wormhole-sdk"
import {
ChainInfo,
getCoreRelayerAddress,
getWormholeRelayerAddress,
getRelayProviderAddress,
loadGuardianKey,
loadGuardianSetIndex,
@ -16,7 +16,7 @@ const governanceContract =
const coreRelayerModule =
"0x000000000000000000000000000000000000000000436f726552656c61796572"
export function createCoreRelayerUpgradeVAA(chain: ChainInfo, newAddress: string) {
export function createWormholeRelayerUpgradeVAA(chain: ChainInfo, newAddress: string) {
/*
bytes32 module;
uint8 action;
@ -59,7 +59,7 @@ export function createDefaultRelayProviderVAA(chain: ChainInfo) {
}
export function createRegisterChainVAA(chain: ChainInfo): string {
const coreRelayerAddress = getCoreRelayerAddress(chain)
const coreRelayerAddress = getWormholeRelayerAddress(chain)
// bytes32 module;
// uint8 action;

10
ethereum/ts-scripts/mockIntegration/messageTest.ts
View File

@ -3,8 +3,8 @@ import { Implementation__factory } from "@certusone/wormhole-sdk/lib/cjs/ethers-
import { LogMessagePublishedEvent } from "../../../sdk/src"
import {
ChainInfo,
getCoreRelayer,
getCoreRelayerAddress,
getWormholeRelayer,
getWormholeRelayerAddress,
getMockIntegration,
getMockIntegrationAddress,
getRelayProviderAddress,
@ -26,15 +26,15 @@ async function sendMessage(
`Sending message from chain ${sourceChain.chainId} to ${targetChain.chainId}...`
)
const sourceRelayer = getCoreRelayer(sourceChain)
const sourceRelayer = getWormholeRelayer(sourceChain)
// todo: remove
const registeredChain = await sourceRelayer.registeredCoreRelayerContract(
const registeredChain = await sourceRelayer.registeredWormholeRelayerContract(
sourceChain.chainId
)
console.log("The source chain should be registered to itself")
console.log(registeredChain)
console.log(getCoreRelayerAddress(sourceChain))
console.log(getWormholeRelayerAddress(sourceChain))
console.log("")
const defaultRelayerProvider = await sourceRelayer.getDefaultRelayProvider()

6
ethereum/ts-scripts/mockIntegration/redeliveryTest.ts
View File

@ -7,8 +7,8 @@ import { getSignatureSetData } from "@certusone/wormhole-sdk/lib/cjs/solana/worm
import { LogMessagePublishedEvent } from "../../../sdk/src"
import {
ChainInfo,
getCoreRelayer,
getCoreRelayerAddress,
getWormholeRelayer,
getWormholeRelayerAddress,
getMockIntegration,
getMockIntegrationAddress,
getRelayProvider,
@ -29,7 +29,7 @@ async function run(
nonce: number,
sourceTxHash: string
) {
const coreRelayer = getCoreRelayer(sourceChain)
const coreRelayer = getWormholeRelayer(sourceChain)
const relayProvider = await coreRelayer.getDefaultRelayProvider()
const relayQuote = await (

2
ethereum/ts-scripts/relayProvider/readRelayProviderContractState.ts
View File

@ -5,7 +5,7 @@ import {
init,
loadChains,
ChainInfo,
getCoreRelayerAddress,
getWormholeRelayerAddress,
getRelayProvider,
getRelayProviderAddress,
getProvider,

6
ethereum/ts-scripts/relayProvider/registerChainsRelayProvider.ts
View File

@ -4,7 +4,7 @@ import {
init,
loadChains,
ChainInfo,
getCoreRelayerAddress,
getWormholeRelayerAddress,
getRelayProvider,
getRelayProviderAddress,
} from "../helpers/env"
@ -26,9 +26,9 @@ async function registerChainsRelayProvider(chain: ChainInfo) {
console.log("about to perform registrations for chain " + chain.chainId)
const relayProvider = getRelayProvider(chain)
const coreRelayerAddress = getCoreRelayerAddress(chain)
const coreRelayerAddress = getWormholeRelayerAddress(chain)
await relayProvider.updateCoreRelayer(coreRelayerAddress).then(wait)
await relayProvider.updateWormholeRelayer(coreRelayerAddress).then(wait)
for (let i = 0; i < chains.length; i++) {
console.log(`Cross registering with chain ${chains[i].chainId}...`)

4
ethereum/ts-scripts/shell/deployConfigureTest.sh
View File

@ -1,8 +1,8 @@
ts-node ./ts-scripts/config/checkNetworks.ts \
&& ts-node ./ts-scripts/relayProvider/deployRelayProvider.ts \
&& ts-node ./ts-scripts/coreRelayer/deployCoreRelayer.ts \
&& ts-node ./ts-scripts/coreRelayer/deployWormholeRelayer.ts \
&& ts-node ./ts-scripts/relayProvider/registerChainsRelayProvider.ts \
&& ts-node ./ts-scripts/coreRelayer/registerChainsCoreRelayerSelfSign.ts \
&& ts-node ./ts-scripts/coreRelayer/registerChainsWormholeRelayerSelfSign.ts \
&& ts-node ./ts-scripts/relayProvider/configureRelayProvider.ts \
&& ts-node ./ts-scripts/mockIntegration/deployMockIntegration.ts \
&& ts-node ./ts-scripts/mockIntegration/messageTest.ts \

18
ethereum/ts-scripts/coreRelayer/deployCoreRelayer.ts → ethereum/ts-scripts/wormholeRelayer/deployWormholeRelayer.ts
View File

@ -1,8 +1,8 @@
import {
deployCoreRelayerImplementation,
deployCoreRelayerLibrary,
deployCoreRelayerProxy,
deployCoreRelayerSetup,
deployWormholeRelayerImplementation,
deployWormholeRelayerLibrary,
deployWormholeRelayerProxy,
deployWormholeRelayerSetup,
} from "../helpers/deployments"
import {
init,
@ -11,7 +11,7 @@ import {
getRelayProviderAddress,
} from "../helpers/env"
const processName = "deployCoreRelayer"
const processName = "deployWormholeRelayer"
init()
const chains = loadChains()
@ -27,13 +27,13 @@ async function run() {
for (let i = 0; i < chains.length; i++) {
console.log(`Deploying for chain ${chains[i].chainId}...`)
const coreRelayerLibrary = await deployCoreRelayerLibrary(chains[i])
const coreRelayerImplementation = await deployCoreRelayerImplementation(
const coreRelayerLibrary = await deployWormholeRelayerLibrary(chains[i])
const coreRelayerImplementation = await deployWormholeRelayerImplementation(
chains[i],
coreRelayerLibrary.address
)
const coreRelayerSetup = await deployCoreRelayerSetup(chains[i])
const coreRelayerProxy = await deployCoreRelayerProxy(
const coreRelayerSetup = await deployWormholeRelayerSetup(chains[i])
const coreRelayerProxy = await deployWormholeRelayerProxy(
chains[i],
coreRelayerSetup.address,
coreRelayerImplementation.address,

10
ethereum/ts-scripts/coreRelayer/deployCoreRelayerImpl.ts → ethereum/ts-scripts/wormholeRelayer/deployWormholeRelayerImpl.ts
View File

@ -1,10 +1,10 @@
import {
deployCoreRelayerImplementation,
deployCoreRelayerLibrary,
deployWormholeRelayerImplementation,
deployWormholeRelayerLibrary,
} from "../helpers/deployments"
import { init, loadChains, writeOutputFiles } from "../helpers/env"
const processName = "deployCoreRelayerImpl"
const processName = "deployWormholeRelayerImpl"
init()
const chains = loadChains()
@ -17,8 +17,8 @@ async function run() {
}
for (let i = 0; i < chains.length; i++) {
const coreRelayerLibrary = await deployCoreRelayerLibrary(chains[i])
const coreRelayerImplementation = await deployCoreRelayerImplementation(
const coreRelayerLibrary = await deployWormholeRelayerLibrary(chains[i])
const coreRelayerImplementation = await deployWormholeRelayerImplementation(
chains[i],
coreRelayerLibrary.address
)

20
ethereum/ts-scripts/coreRelayer/readCoreRelayerState.ts → ethereum/ts-scripts/wormholeRelayer/readWormholeRelayerState.ts
View File

@ -5,12 +5,12 @@ import {
init,
loadChains,
ChainInfo,
getCoreRelayerAddress,
getWormholeRelayerAddress,
getRelayProvider,
getRelayProviderAddress,
getProvider,
writeOutputFiles,
getCoreRelayer,
getWormholeRelayer,
} from "../helpers/env"
import { wait } from "../helpers/utils"
@ -34,19 +34,19 @@ async function run() {
writeOutputFiles(states, processName)
}
type CoreRelayerContractState = {
type WormholeRelayerContractState = {
chainId: number
contractAddress: string
defaultProvider: string
registeredContracts: { chainId: number; contract: string }[]
}
async function readState(chain: ChainInfo): Promise<CoreRelayerContractState | null> {
async function readState(chain: ChainInfo): Promise<WormholeRelayerContractState | null> {
console.log("Gathering core relayer contract status for chain " + chain.chainId)
try {
const coreRelayer = getCoreRelayer(chain, getProvider(chain))
const contractAddress = getCoreRelayerAddress(chain)
const coreRelayer = getWormholeRelayer(chain, getProvider(chain))
const contractAddress = getWormholeRelayerAddress(chain)
const defaultProvider = await coreRelayer.getDefaultRelayProvider()
const registeredContracts: { chainId: number; contract: string }[] = []
@ -54,7 +54,7 @@ async function readState(chain: ChainInfo): Promise<CoreRelayerContractState | n
registeredContracts.push({
chainId: chainInfo.chainId,
contract: (
await coreRelayer.registeredCoreRelayerContract(chain.chainId)
await coreRelayer.registeredWormholeRelayerContract(chain.chainId)
).toString(),
})
}
@ -73,16 +73,16 @@ async function readState(chain: ChainInfo): Promise<CoreRelayerContractState | n
return null
}
function printState(state: CoreRelayerContractState) {
function printState(state: WormholeRelayerContractState) {
console.log("")
console.log("CoreRelayer: ")
console.log("WormholeRelayer: ")
printFixed("Chain ID: ", state.chainId.toString())
printFixed("Contract Address:", state.contractAddress)
printFixed("Default Provider:", state.defaultProvider)
console.log("")
printFixed("Registered CoreRelayers", "")
printFixed("Registered WormholeRelayers", "")
state.registeredContracts.forEach((x) => {
printFixed(" Chain: " + x.chainId, x.contract)
})

16
ethereum/ts-scripts/coreRelayer/registerChainsCoreRelayerSelfSign.ts → ethereum/ts-scripts/wormholeRelayer/registerChainsWormholeRelayerSelfSign.ts
View File

@ -3,14 +3,14 @@ import {
init,
loadChains,
ChainInfo,
getCoreRelayer,
getWormholeRelayer,
getRelayProviderAddress,
getCoreRelayerAddress,
getWormholeRelayerAddress,
} from "../helpers/env"
import { wait } from "../helpers/utils"
import { createRegisterChainVAA, createDefaultRelayProviderVAA } from "../helpers/vaa"
const processName = "registerChainsCoreRelayer"
const processName = "registerChainsWormholeRelayer"
init()
const chains = loadChains()
@ -18,20 +18,20 @@ async function run() {
console.log("Start! " + processName)
for (let i = 0; i < chains.length; i++) {
await registerChainsCoreRelayer(chains[i])
await registerChainsWormholeRelayer(chains[i])
}
}
async function registerChainsCoreRelayer(chain: ChainInfo) {
console.log("registerChainsCoreRelayer " + chain.chainId)
async function registerChainsWormholeRelayer(chain: ChainInfo) {
console.log("registerChainsWormholeRelayer " + chain.chainId)
const coreRelayer = getCoreRelayer(chain)
const coreRelayer = getWormholeRelayer(chain)
await coreRelayer
.setDefaultRelayProvider(createDefaultRelayProviderVAA(chain))
.then(wait)
for (let i = 0; i < chains.length; i++) {
await coreRelayer
.registerCoreRelayerContract(createRegisterChainVAA(chains[i]))
.registerWormholeRelayerContract(createRegisterChainVAA(chains[i]))
.then(wait);
}

0
ethereum/ts-scripts/coreRelayer/submitCoreRelayerUpgradeVAA.ts → ethereum/ts-scripts/wormholeRelayer/submitWormholeRelayerUpgradeVAA.ts
View File

26
ethereum/ts-scripts/coreRelayer/upgradeCoreRelayerSelfSign.ts → ethereum/ts-scripts/wormholeRelayer/upgradeWormholeRelayerSelfSign.ts
View File

@ -1,24 +1,24 @@
import { tryNativeToHexString } from "@certusone/wormhole-sdk"
import {
deployCoreRelayerImplementation,
deployCoreRelayerLibrary,
deployWormholeRelayerImplementation,
deployWormholeRelayerLibrary,
} from "../helpers/deployments"
import {
init,
loadChains,
ChainInfo,
getCoreRelayer,
getWormholeRelayer,
getRelayProviderAddress,
getCoreRelayerAddress,
getWormholeRelayerAddress,
writeOutputFiles,
} from "../helpers/env"
import {
createRegisterChainVAA,
createDefaultRelayProviderVAA,
createCoreRelayerUpgradeVAA,
createWormholeRelayerUpgradeVAA,
} from "../helpers/vaa"
const processName = "upgradeCoreRelayerSelfSign"
const processName = "upgradeWormholeRelayerSelfSign"
init()
const chains = loadChains()
@ -30,12 +30,12 @@ async function run() {
}
for (let i = 0; i < chains.length; i++) {
const coreRelayerLibrary = await deployCoreRelayerLibrary(chains[i])
const coreRelayerImplementation = await deployCoreRelayerImplementation(
const coreRelayerLibrary = await deployWormholeRelayerLibrary(chains[i])
const coreRelayerImplementation = await deployWormholeRelayerImplementation(
chains[i],
coreRelayerLibrary.address
)
await upgradeCoreRelayer(chains[i], coreRelayerImplementation.address)
await upgradeWormholeRelayer(chains[i], coreRelayerImplementation.address)
output.coreRelayerImplementations.push(coreRelayerImplementation)
output.coreRelayerLibraries.push(coreRelayerLibrary)
@ -44,13 +44,13 @@ async function run() {
writeOutputFiles(output, processName)
}
async function upgradeCoreRelayer(chain: ChainInfo, newImplementationAddress: string) {
console.log("upgradeCoreRelayer " + chain.chainId)
async function upgradeWormholeRelayer(chain: ChainInfo, newImplementationAddress: string) {
console.log("upgradeWormholeRelayer " + chain.chainId)
const coreRelayer = getCoreRelayer(chain)
const coreRelayer = getWormholeRelayer(chain)
await coreRelayer.submitContractUpgrade(
createCoreRelayerUpgradeVAA(chain, newImplementationAddress)
createWormholeRelayerUpgradeVAA(chain, newImplementationAddress)
)
console.log("Successfully upgraded the core relayer contract on " + chain.chainId)

74
ethereum/ts-test/2_core_relayer.ts
View File

@ -4,14 +4,14 @@ import { ChainId, tryNativeToHexString } from "@certusone/wormhole-sdk"
import { ChainInfo, RELAYER_DEPLOYER_PRIVATE_KEY } from "./helpers/consts"
import { generateRandomString } from "./helpers/utils"
import {
CoreRelayer__factory,
WormholeRelayer__factory,
IWormhole__factory,
MockRelayerIntegration__factory,
} from "../../sdk/src"
import {
init,
loadChains,
loadCoreRelayers,
loadWormholeRelayers,
loadMockIntegrations,
} from "../ts-scripts/helpers/env"
import { MockRelayerIntegration, IWormholeRelayer } from "../../sdk/src"
@ -19,7 +19,7 @@ const ETHEREUM_ROOT = `${__dirname}/..`
init()
const chains = loadChains()
const coreRelayers = loadCoreRelayers()
const coreRelayers = loadWormholeRelayers()
const mockIntegrations = loadMockIntegrations()
describe("Core Relayer Integration Test - Two Chains", () => {
@ -34,29 +34,29 @@ describe("Core Relayer Integration Test - Two Chains", () => {
const walletSource = new ethers.Wallet(RELAYER_DEPLOYER_PRIVATE_KEY, providerSource)
const walletTarget = new ethers.Wallet(RELAYER_DEPLOYER_PRIVATE_KEY, providerTarget)
const sourceCoreRelayerAddress = coreRelayers.find(
const sourceWormholeRelayerAddress = coreRelayers.find(
(p) => p.chainId == sourceChain.chainId
)?.address as string
const sourceMockIntegrationAddress = mockIntegrations.find(
(p) => p.chainId == sourceChain.chainId
)?.address as string
const targetCoreRelayerAddress = coreRelayers.find(
const targetWormholeRelayerAddress = coreRelayers.find(
(p) => p.chainId == targetChain.chainId
)?.address as string
const targetMockIntegrationAddress = mockIntegrations.find(
(p) => p.chainId == targetChain.chainId
)?.address as string
const sourceCoreRelayer = CoreRelayer__factory.connect(
sourceCoreRelayerAddress,
const sourceWormholeRelayer = WormholeRelayer__factory.connect(
sourceWormholeRelayerAddress,
walletSource
)
const sourceMockIntegration = MockRelayerIntegration__factory.connect(
sourceMockIntegrationAddress,
walletSource
)
const targetCoreRelayer = CoreRelayer__factory.connect(
targetCoreRelayerAddress,
const targetWormholeRelayer = WormholeRelayer__factory.connect(
targetWormholeRelayerAddress,
walletTarget
)
const targetMockIntegration = MockRelayerIntegration__factory.connect(
@ -69,10 +69,10 @@ describe("Core Relayer Integration Test - Two Chains", () => {
ethers.utils.toUtf8Bytes(generateRandomString(32))
)
console.log(`Sent message: ${arbitraryPayload}`)
const value = await sourceCoreRelayer.quoteGas(
const value = await sourceWormholeRelayer.quoteGas(
targetChain.chainId,
500000,
await sourceCoreRelayer.getDefaultRelayProvider()
await sourceWormholeRelayer.getDefaultRelayProvider()
)
console.log(`Quoted gas delivery fee: ${value}`)
const tx = await sourceMockIntegration.sendMessage(
@ -106,15 +106,15 @@ describe("Core Relayer Integration Test - Two Chains", () => {
ethers.utils.toUtf8Bytes(generateRandomString(32))
)
console.log(`Sent message: ${arbitraryPayload1}`)
const value = await sourceCoreRelayer.quoteGas(
const value = await sourceWormholeRelayer.quoteGas(
targetChain.chainId,
500000,
await sourceCoreRelayer.getDefaultRelayProvider()
await sourceWormholeRelayer.getDefaultRelayProvider()
)
const extraForwardingValue = await targetCoreRelayer.quoteGas(
const extraForwardingValue = await targetWormholeRelayer.quoteGas(
sourceChain.chainId,
500000,
await targetCoreRelayer.getDefaultRelayProvider()
await targetWormholeRelayer.getDefaultRelayProvider()
)
console.log(`Quoted gas delivery fee: ${value.add(extraForwardingValue)}`)
@ -161,15 +161,15 @@ describe("Core Relayer Integration Test - Two Chains", () => {
ethers.utils.toUtf8Bytes(generateRandomString(32))
)
console.log(`Sent message: ${arbitraryPayload1}`)
const value1 = await sourceCoreRelayer.quoteGas(
const value1 = await sourceWormholeRelayer.quoteGas(
sourceChain.chainId,
500000,
await sourceCoreRelayer.getDefaultRelayProvider()
await sourceWormholeRelayer.getDefaultRelayProvider()
)
const value2 = await sourceCoreRelayer.quoteGas(
const value2 = await sourceWormholeRelayer.quoteGas(
targetChain.chainId,
500000,
await sourceCoreRelayer.getDefaultRelayProvider()
await sourceWormholeRelayer.getDefaultRelayProvider()
)
console.log(`Quoted gas delivery fee: ${value1.add(value2)}`)
@ -218,20 +218,20 @@ describe("Core Relayer Integration Test - Two Chains", () => {
ethers.utils.toUtf8Bytes(generateRandomString(32))
)
console.log(`Sent message: ${arbitraryPayload1}`)
const value1 = await sourceCoreRelayer.quoteGas(
const value1 = await sourceWormholeRelayer.quoteGas(
sourceChain.chainId,
500000,
await sourceCoreRelayer.getDefaultRelayProvider()
await sourceWormholeRelayer.getDefaultRelayProvider()
)
const value2 = await targetCoreRelayer.quoteGas(
const value2 = await targetWormholeRelayer.quoteGas(
sourceChain.chainId,
500000,
await targetCoreRelayer.getDefaultRelayProvider()
await targetWormholeRelayer.getDefaultRelayProvider()
)
const value3 = await targetCoreRelayer.quoteGas(
const value3 = await targetWormholeRelayer.quoteGas(
targetChain.chainId,
500000,
await targetCoreRelayer.getDefaultRelayProvider()
await targetWormholeRelayer.getDefaultRelayProvider()
)
console.log(`Quoted gas delivery fee: ${value1.add(value2).add(value3)}`)
@ -280,15 +280,15 @@ describe("Core Relayer Integration Test - Two Chains", () => {
ethers.utils.toUtf8Bytes(generateRandomString(32))
)
console.log(`Sent message: ${arbitraryPayload}`)
const valueNotEnough = await sourceCoreRelayer.quoteGas(
const valueNotEnough = await sourceWormholeRelayer.quoteGas(
targetChain.chainId,
10000,
await sourceCoreRelayer.getDefaultRelayProvider()
await sourceWormholeRelayer.getDefaultRelayProvider()
)
const value = await sourceCoreRelayer.quoteGas(
const value = await sourceWormholeRelayer.quoteGas(
targetChain.chainId,
500000,
await sourceCoreRelayer.getDefaultRelayProvider()
await sourceWormholeRelayer.getDefaultRelayProvider()
)
console.log(`Quoted gas delivery fee (not enough): ${valueNotEnough}`)
const tx = await sourceMockIntegration.sendMessage(
@ -323,9 +323,9 @@ describe("Core Relayer Integration Test - Two Chains", () => {
multisendIndex: 0,
newMaxTransactionFee: value,
newReceiverValue: 0,
newRelayParameters: sourceCoreRelayer.getDefaultRelayParams()
newRelayParameters: sourceWormholeRelayer.getDefaultRelayParams()
};
await sourceCoreRelayer.resend(request, 1, sourceCoreRelayer.getDefaultRelayProvider(), {value: value, gasLimit: 500000}).then((t)=>t.wait);
await sourceWormholeRelayer.resend(request, 1, sourceWormholeRelayer.getDefaultRelayProvider(), {value: value, gasLimit: 500000}).then((t)=>t.wait);
console.log("Message resent");
await new Promise((resolve) => {
@ -350,15 +350,15 @@ describe("Core Relayer Integration Test - Two Chains", () => {
ethers.utils.toUtf8Bytes(generateRandomString(32))
)
console.log(`Sent message: ${arbitraryPayload1}`)
const value = await sourceCoreRelayer.quoteGas(
const value = await sourceWormholeRelayer.quoteGas(
targetChain.chainId,
500000,
await sourceCoreRelayer.getDefaultRelayProvider()
await sourceWormholeRelayer.getDefaultRelayProvider()
)
const extraForwardingValue = await targetCoreRelayer.quoteGas(
const extraForwardingValue = await targetWormholeRelayer.quoteGas(
sourceChain.chainId,
10000,
await targetCoreRelayer.getDefaultRelayProvider()
await targetWormholeRelayer.getDefaultRelayProvider()
)
console.log(`Quoted gas delivery fee: ${value.add(extraForwardingValue)}`)
@ -411,9 +411,9 @@ describe("Core Relayer Integration Test - Two Chains", () => {
multisendIndex: 0,
newMaxTransactionFee: value,
newReceiverValue: 0,
newRelayParameters: sourceCoreRelayer.getDefaultRelayParams()
newRelayParameters: sourceWormholeRelayer.getDefaultRelayParams()
};
await sourceCoreRelayer.resend(request, 1, sourceCoreRelayer.getDefaultRelayProvider(), {value: value, gasLimit: 500000}).then((t)=>t.wait);
await sourceWormholeRelayer.resend(request, 1, sourceWormholeRelayer.getDefaultRelayProvider(), {value: value, gasLimit: 500000}).then((t)=>t.wait);
console.log("Message resent");*/
/*

4
relayer_engine/pkgs/sdk/src/index.ts
View File

@ -1,5 +1,5 @@
export type { CoreRelayer, CoreRelayerStructs } from "./ethers-contracts/CoreRelayer"
export { CoreRelayer__factory } from "./ethers-contracts/factories/CoreRelayer__factory"
export type { WormholeRelayer, WormholeRelayerStructs } from "./ethers-contracts/WormholeRelayer"
export { WormholeRelayer__factory } from "./ethers-contracts/factories/WormholeRelayer__factory"
export type { MockRelayerIntegration } from "./ethers-contracts/MockRelayerIntegration"
export { MockRelayerIntegration__factory } from "./ethers-contracts/factories/MockRelayerIntegration__factory"
export type { IWormhole, LogMessagePublishedEvent } from "./ethers-contracts/IWormhole"

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

@ -499,7 +499,7 @@ export class GenericRelayerPlugin implements Plugin<WorkflowPayload> {
this.logger.debug(vaas)
const deliveryVaaIdx = vaas.findIndex((vaa) => vaa.emitter === emitterAddress)
if (deliveryVaaIdx === -1) {
throw new PluginError("CoreRelayerVaa not found in fetched vaas", {
throw new PluginError("WormholeRelayerVaa not found in fetched vaas", {
vaas,
})
}

4
sdk/src/index.ts
View File

@ -1,5 +1,5 @@
export type { CoreRelayer, CoreRelayerStructs } from "./ethers-contracts/CoreRelayer"
export { CoreRelayer__factory } from "./ethers-contracts/factories/CoreRelayer__factory"
export type { WormholeRelayer, WormholeRelayerStructs } from "./ethers-contracts/WormholeRelayer"
export { WormholeRelayer__factory } from "./ethers-contracts/factories/WormholeRelayer__factory"
export type { MockRelayerIntegration } from "./ethers-contracts/MockRelayerIntegration"
export { MockRelayerIntegration__factory } from "./ethers-contracts/factories/MockRelayerIntegration__factory"
export type { IWormhole, LogMessagePublishedEvent } from "./ethers-contracts/IWormhole"