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

forge fmt

This commit is contained in:
derpy-duck 2023-03-20 13:57:07 +00:00
parent 2eca5e67d0
commit 477611d075
3 changed files with 83 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ethereum/forge-test/TestHelpers.sol
View File

@ -31,8 +31,9 @@ contract TestHelpers {
Vm public constant vm = Vm(VM_ADDRESS);
WormholeSimulator helperWormholeSimulator;
constructor() {
(, helperWormholeSimulator) = setUpWormhole(1);
(, helperWormholeSimulator) = setUpWormhole(1);
}
function registerCoreRelayerContract(
@ -64,7 +65,7 @@ contract TestHelpers {
}
function setUpWormhole(uint16 chainId)
public
public
returns (IWormhole wormholeContract, WormholeSimulator wormholeSimulator)
{
// deploy Wormhole
@ -124,6 +125,4 @@ contract TestHelpers {
);
coreRelayer = IWormholeRelayer(address(myCoreRelayer));
}
}

16
ethereum/forge-test/WormholeRelayer.t.sol
View File

@ -80,7 +80,6 @@ contract WormholeRelayerTests is Test {
setUpChains(5);
//
}
struct StandardSetupTwoChains {
@ -204,17 +203,20 @@ contract WormholeRelayerTests is Test {
mapEntry.chainId = i;
map[i] = mapEntry;
}
uint256 maxBudget = type(uint256).max;
for (uint16 i = 1; i <= numChains; i++) {
for (uint16 j = 1; j <= numChains; j++) {
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);
helpers.registerCoreRelayerContract(
map[i].coreRelayerFull, map[i].wormhole, i, j, bytes32(uint256(uint160(address(map[j].coreRelayer))))
);
helpers.registerCoreRelayerContract(
map[i].coreRelayerFull,
map[i].wormhole,
i,
j,
bytes32(uint256(uint160(address(map[j].coreRelayer))))
);
map[i].relayProvider.updateMaximumBudget(j, maxBudget);
map[i].integration.registerEmitter(j, bytes32(uint256(uint160(address(map[j].integration)))));
Structs.XAddress[] memory addresses = new Structs.XAddress[](1);
@ -224,7 +226,6 @@ contract WormholeRelayerTests is Test {
}
}
function getDeliveryVAAHash() internal returns (bytes32 vaaHash) {
vaaHash = vm.getRecordedLogs()[0].data.toBytes32(0);
}
@ -1851,5 +1852,4 @@ contract WormholeRelayerTests is Test {
assertTrue(map[1].coreRelayer.toWormholeFormat(msg1) == bytes32(uint256(uint160(msg1))));
assertTrue(map[1].coreRelayer.fromWormholeFormat(map[1].coreRelayer.toWormholeFormat(msg1)) == msg1);
}
}

157
ethereum/forge-test/WormholeRelayerGovernance.t.sol
View File

@ -40,59 +40,25 @@ contract WormholeRelayerGovernanceTests is Test {
TestHelpers helpers;
bytes32 relayerModule = 0x000000000000000000000000000000000000000000436F726552656C61796572;
IWormhole wormhole;
IRelayProvider relayProvider;
WormholeSimulator wormholeSimulator;
IWormholeRelayer wormholeRelayer;
function setUp() public {
helpers = new TestHelpers();
(wormhole, wormholeSimulator) = helpers.setUpWormhole(1);
relayProvider = helpers.setUpRelayProvider(1);
wormholeRelayer = helpers.setUpCoreRelayer(1, wormhole, address(relayProvider));
}
struct GovernanceStack {
IRelayProvider relayProvider;
IWormhole wormhole;
WormholeSimulator wormholeSimulator;
IWormholeRelayer wormholeRelayer;
struct GovernanceStack {
bytes message;
IWormhole.VM preSignedMessage;
bytes signed;
}
function fillInGovernanceStack(bytes memory message) internal returns (GovernanceStack memory stack) {
stack.relayProvider = helpers.setUpRelayProvider(1);
(stack.wormhole, stack.wormholeSimulator) = helpers.setUpWormhole(1);
stack.wormholeRelayer = helpers.setUpCoreRelayer(1, stack.wormhole, address(stack.relayProvider));
stack.message = message;
stack.preSignedMessage = IWormhole.VM({
version: 1,
timestamp: uint32(block.timestamp),
nonce: 0,
emitterChainId: stack.wormhole.governanceChainId(),
emitterAddress: stack.wormhole.governanceContract(),
sequence: 0,
consistencyLevel: 200,
payload: message,
guardianSetIndex: 0,
signatures: new IWormhole.Signature[](0),
hash: bytes32("")
});
stack.signed = stack.wormholeSimulator.encodeAndSignMessage(stack.preSignedMessage);
}
function testSetDefaultRelayProvider() public {
IRelayProvider relayProviderA = helpers.setUpRelayProvider(1);
IRelayProvider relayProviderB = helpers.setUpRelayProvider(1);
IRelayProvider relayProviderC = helpers.setUpRelayProvider(1);
(IWormhole wormhole, WormholeSimulator simulator) = helpers.setUpWormhole(1);
IWormholeRelayer wormholeRelayer = helpers.setUpCoreRelayer(1, wormhole, address(relayProviderA));
assertTrue(wormholeRelayer.getDefaultRelayProvider() == address(relayProviderA));
bytes memory message = abi.encodePacked(
relayerModule, uint8(3), uint16(1), wormholeRelayer.toWormholeFormat(address(relayProviderB))
);
function signMessage(bytes memory message) internal returns (bytes memory signed) {
IWormhole.VM memory preSignedMessage = IWormhole.VM({
version: 1,
timestamp: uint32(block.timestamp),
@ -106,18 +72,12 @@ contract WormholeRelayerGovernanceTests is Test {
signatures: new IWormhole.Signature[](0),
hash: bytes32("")
});
signed = wormholeSimulator.encodeAndSignMessage(preSignedMessage);
}
bytes memory signed = simulator.encodeAndSignMessage(preSignedMessage);
CoreRelayerGovernance(address(wormholeRelayer)).setDefaultRelayProvider(signed);
assertTrue(wormholeRelayer.getDefaultRelayProvider() == address(relayProviderB));
message = abi.encodePacked(
relayerModule, uint8(3), uint16(1), wormholeRelayer.toWormholeFormat(address(relayProviderC))
);
preSignedMessage = IWormhole.VM({
function fillInGovernanceStack(bytes memory message) internal returns (GovernanceStack memory stack) {
stack.message = message;
stack.preSignedMessage = IWormhole.VM({
version: 1,
timestamp: uint32(block.timestamp),
nonce: 0,
@ -130,8 +90,24 @@ contract WormholeRelayerGovernanceTests is Test {
signatures: new IWormhole.Signature[](0),
hash: bytes32("")
});
stack.signed = wormholeSimulator.encodeAndSignMessage(stack.preSignedMessage);
}
signed = simulator.encodeAndSignMessage(preSignedMessage);
function testSetDefaultRelayProvider() public {
IRelayProvider relayProviderB = helpers.setUpRelayProvider(1);
IRelayProvider relayProviderC = helpers.setUpRelayProvider(1);
bytes memory signed = signMessage(
abi.encodePacked(relayerModule, uint8(3), uint16(1), bytes32(uint256(uint160(address(relayProviderB)))))
);
CoreRelayerGovernance(address(wormholeRelayer)).setDefaultRelayProvider(signed);
assertTrue(wormholeRelayer.getDefaultRelayProvider() == address(relayProviderB));
signed = signMessage(
abi.encodePacked(relayerModule, uint8(3), uint16(1), bytes32(uint256(uint160(address(relayProviderC)))))
);
CoreRelayerGovernance(address(wormholeRelayer)).setDefaultRelayProvider(signed);
@ -139,20 +115,24 @@ contract WormholeRelayerGovernanceTests is Test {
}
function testRegisterChain() public {
IRelayProvider relayProviderA = helpers.setUpRelayProvider(1);
(IWormhole wormhole,) = helpers.setUpWormhole(1);
IWormholeRelayer wormholeRelayer1 = helpers.setUpCoreRelayer(1, wormhole, address(relayProviderA));
IWormholeRelayer wormholeRelayer2 = helpers.setUpCoreRelayer(1, wormhole, address(relayProviderA));
IWormholeRelayer wormholeRelayer3 = helpers.setUpCoreRelayer(1, wormhole, address(relayProviderA));
IWormholeRelayer wormholeRelayer1 = helpers.setUpCoreRelayer(1, wormhole, address(relayProvider));
IWormholeRelayer wormholeRelayer2 = helpers.setUpCoreRelayer(1, wormhole, address(relayProvider));
IWormholeRelayer wormholeRelayer3 = helpers.setUpCoreRelayer(1, wormhole, address(relayProvider));
helpers.registerCoreRelayerContract(
CoreRelayer(address(wormholeRelayer1)), wormhole, 1, 2, wormholeRelayer1.toWormholeFormat(address(wormholeRelayer2))
CoreRelayer(address(wormholeRelayer1)),
wormhole,
1,
2,
wormholeRelayer.toWormholeFormat(address(wormholeRelayer2))
);
helpers.registerCoreRelayerContract(
CoreRelayer(address(wormholeRelayer1)), wormhole, 1, 3, wormholeRelayer1.toWormholeFormat(address(wormholeRelayer3))
CoreRelayer(address(wormholeRelayer1)),
wormhole,
1,
3,
wormholeRelayer.toWormholeFormat(address(wormholeRelayer3))
);
assertTrue(
@ -166,7 +146,11 @@ contract WormholeRelayerGovernanceTests is Test {
);
helpers.registerCoreRelayerContract(
CoreRelayer(address(wormholeRelayer1)), wormhole, 1, 3, wormholeRelayer1.toWormholeFormat(address(wormholeRelayer2))
CoreRelayer(address(wormholeRelayer1)),
wormhole,
1,
3,
wormholeRelayer.toWormholeFormat(address(wormholeRelayer2))
);
assertTrue(
@ -176,9 +160,6 @@ contract WormholeRelayerGovernanceTests is Test {
}
function testUpgradeContractToItself() public {
IRelayProvider relayProvider = helpers.setUpRelayProvider(1);
(IWormhole wormhole, WormholeSimulator simulator) = helpers.setUpWormhole(1);
CoreRelayerSetup coreRelayerSetup = new CoreRelayerSetup();
CoreRelayerImplementation coreRelayerImplementation = new CoreRelayerImplementation();
CoreRelayerProxy myCoreRelayer = new CoreRelayerProxy(
@ -196,35 +177,41 @@ contract WormholeRelayerGovernanceTests is Test {
)
)
);
CoreRelayer wormholeRelayer = CoreRelayer(address(myCoreRelayer));
for (uint256 i = 0; i < 10; i++) {
CoreRelayerImplementation coreRelayerImplementationNew = new CoreRelayerImplementation();
bytes memory message = abi.encodePacked(
relayerModule,
uint8(1),
uint16(1),
wormholeRelayer.toWormholeFormat(address(coreRelayerImplementationNew))
);
IWormhole.VM memory preSignedMessage = IWormhole.VM({
version: 1,
timestamp: uint32(block.timestamp),
nonce: 0,
emitterChainId: wormhole.governanceChainId(),
emitterAddress: wormhole.governanceContract(),
sequence: 0,
consistencyLevel: 200,
payload: message,
guardianSetIndex: 0,
signatures: new IWormhole.Signature[](0),
hash: bytes32("")
});
bytes memory signed = simulator.encodeAndSignMessage(preSignedMessage);
bytes memory signed = signMessage(message);
CoreRelayerGovernance(address(wormholeRelayer)).submitContractUpgrade(signed);
CoreRelayerGovernance(address(myCoreRelayer)).submitContractUpgrade(signed);
}
}
/*
function testRevertUpgradeFork() {
CoreRelayerSetup coreRelayerSetup = new CoreRelayerSetup();
CoreRelayerImplementation coreRelayerImplementation = new CoreRelayerImplementation();
CoreRelayerProxy myCoreRelayer = new CoreRelayerProxy(
address(coreRelayerSetup),
abi.encodeCall(
CoreRelayerSetup.setup,
(
address(coreRelayerImplementation),
1,
address(wormhole),
address(relayProvider),
wormhole.governanceChainId(),
wormhole.governanceContract(),
block.chainid
)
)
);
}*/
}