524 lines
27 KiB
Solidity
524 lines
27 KiB
Solidity
pragma solidity 0.8.20;
|
|
|
|
import {Test} from "forge-std/Test.sol";
|
|
|
|
import {Gatekeeper} from "../../src/Gatekeeper.sol";
|
|
import {FullMath} from "../../src/libraries/FullMath.sol";
|
|
import {RequestPacking} from "../../src/libraries/Packing.sol";
|
|
import {IStorageHistory} from "../../src/interfaces/IStorageHistory.sol";
|
|
import {StorageHistory} from "../../src/types/StorageHistory.sol";
|
|
import {WETH9} from "../../src/mocks/WETH9.sol";
|
|
|
|
contract MockGovernance is Test {
|
|
address public immutable GATEKEEPER;
|
|
address public immutable DUMMY_ADDRESS;
|
|
|
|
bool public auditCalled;
|
|
|
|
enum STATUS {
|
|
RESERVEDEPOSITOR,
|
|
RESERVETOKEN,
|
|
LIQUIDITYDEPOSITOR,
|
|
LIQUIDITYTOKEN,
|
|
REWARDMANAGER
|
|
}
|
|
|
|
constructor(address gatekeeper, address dummyAddress) {
|
|
GATEKEEPER = gatekeeper;
|
|
DUMMY_ADDRESS = dummyAddress;
|
|
auditCalled = false;
|
|
}
|
|
|
|
function setDistributor(address distributor) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(distributor, DUMMY_ADDRESS);
|
|
}
|
|
|
|
function setWarmupPeriod(uint256 warmupPeriod) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(warmupPeriod, 69);
|
|
}
|
|
|
|
function setBounty(uint256 bounty) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(bounty, 69);
|
|
}
|
|
|
|
function setAdjustment(uint256 rate, uint256 target, bool add) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(rate, 69);
|
|
assertEq(target, 420);
|
|
assertEq(add, true);
|
|
}
|
|
|
|
function updateGatekeeperAddress(address gatekeeper) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(gatekeeper, DUMMY_ADDRESS);
|
|
}
|
|
|
|
function addPool(address pool) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(pool, DUMMY_ADDRESS);
|
|
}
|
|
|
|
function removePool(uint256 index) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(index, 1337);
|
|
}
|
|
|
|
function close(uint256 id) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(id, 420);
|
|
}
|
|
|
|
function create(
|
|
uint256[3] calldata market,
|
|
uint256[2] calldata terms,
|
|
address quoteToken,
|
|
uint32[2] calldata intervals,
|
|
bool[2] calldata booleans
|
|
) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
|
|
assertEq(market[0], 69);
|
|
assertEq(market[1], 420);
|
|
assertEq(market[2], 1337);
|
|
|
|
assertEq(terms[0], 420);
|
|
assertEq(terms[1], 1337);
|
|
|
|
assertEq(quoteToken, DUMMY_ADDRESS);
|
|
|
|
assertEq(intervals[0], 34);
|
|
assertEq(intervals[1], 35);
|
|
|
|
assertEq(booleans[0], true);
|
|
assertEq(booleans[1], true);
|
|
}
|
|
|
|
function enable(STATUS status, address token, address calculator) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
|
|
if (status != STATUS.RESERVETOKEN) revert();
|
|
assertEq(token, DUMMY_ADDRESS);
|
|
assertEq(calculator, DUMMY_ADDRESS);
|
|
}
|
|
|
|
function disable(STATUS status, address token) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
|
|
if (status != STATUS.LIQUIDITYTOKEN) revert();
|
|
assertEq(token, DUMMY_ADDRESS);
|
|
}
|
|
|
|
function forfeitReserves(address router, uint256 liquidity, bool destroyerMode) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(router, DUMMY_ADDRESS);
|
|
assertEq(liquidity, 420);
|
|
assertEq(destroyerMode, true);
|
|
}
|
|
|
|
function redeemReserve(address router, uint256 amount) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(router, DUMMY_ADDRESS);
|
|
assertEq(amount, 420);
|
|
}
|
|
|
|
function withdraw(address token, uint256 amount) external view {
|
|
require(msg.sender == GATEKEEPER);
|
|
assertEq(token, DUMMY_ADDRESS);
|
|
assertEq(amount, 420);
|
|
}
|
|
|
|
function auditReserves() external {
|
|
require(msg.sender == GATEKEEPER);
|
|
auditCalled = true;
|
|
}
|
|
}
|
|
|
|
contract MockStaking is Test {
|
|
Gatekeeper public gatekeeper;
|
|
WETH9 public mockReserve;
|
|
|
|
mapping(address => uint256) private _recalledAmounts;
|
|
|
|
constructor() {
|
|
mockReserve = new WETH9();
|
|
StorageHistory history = new StorageHistory();
|
|
gatekeeper = new Gatekeeper(address(history));
|
|
gatekeeper.initialize(address(0));
|
|
history.setOwner(address(gatekeeper));
|
|
}
|
|
|
|
function runGhost(bytes32 receiver, uint256 amount) external {
|
|
gatekeeper.ghost(receiver, amount);
|
|
}
|
|
|
|
function runRecall(
|
|
uint256 exodusSession,
|
|
uint256 amount,
|
|
uint256 packed,
|
|
address caller
|
|
) external payable {
|
|
if (msg.value > 0) {
|
|
vm.deal(address(gatekeeper), address(gatekeeper).balance + msg.value);
|
|
}
|
|
|
|
vm.prank(address(gatekeeper), caller);
|
|
gatekeeper.recall{value: msg.value}(exodusSession, amount, packed);
|
|
}
|
|
|
|
function recall(address receiver, uint256 amount) external {
|
|
_recalledAmounts[receiver] += amount;
|
|
}
|
|
|
|
function recall(uint256 amount, uint256, uint256) external returns (address, uint256, uint256){
|
|
_recalledAmounts[tx.origin] += amount;
|
|
return (address(mockReserve), 0, 0);
|
|
}
|
|
|
|
function recalledAmount(address who) external view returns (uint256) {
|
|
return _recalledAmounts[who];
|
|
}
|
|
|
|
function totalReserves() external pure returns (uint256) {
|
|
return type(uint256).max;
|
|
}
|
|
|
|
function baseSupply() external pure returns (uint256) {
|
|
return type(uint256).max;
|
|
}
|
|
}
|
|
|
|
contract GatekeeperTest is Test {
|
|
using RequestPacking for RequestPacking.RequestPayload;
|
|
|
|
address constant ALICE = 0x0000000000000000000000000000000000000001;
|
|
address constant BOB = 0x0000000000000000000000000000000000000002;
|
|
uint256 constant INIT_AMOUNT = 69 * 1e18;
|
|
address constant DUMMY_ADDRESS = address(0x0101010101010101010101010101010101010101);
|
|
|
|
MockGovernance governance;
|
|
Gatekeeper gatekeeper;
|
|
MockStaking staking;
|
|
|
|
event Ghosted(bytes32 indexed receiver, uint256 indexed amount);
|
|
|
|
function setUp() public {
|
|
vm.prank(ALICE, ALICE);
|
|
staking = new MockStaking();
|
|
gatekeeper = staking.gatekeeper();
|
|
|
|
MockGovernance tempGov = new MockGovernance(address(gatekeeper), DUMMY_ADDRESS);
|
|
bytes memory govBytecode = address(tempGov).code;
|
|
|
|
vm.etch(DUMMY_ADDRESS, govBytecode);
|
|
governance = MockGovernance(DUMMY_ADDRESS);
|
|
}
|
|
|
|
function test_correctInitialization() public view {
|
|
assertEq(gatekeeper.staking(), address(staking));
|
|
assertEq(gatekeeper.ghostedSupply(), 0);
|
|
}
|
|
|
|
function test_ghostTokensWork(uint256 ghostAmount) public {
|
|
vm.assume(ghostAmount >= gatekeeper.EXISTENTIAL_DEPOSIT() && ghostAmount < type(uint96).max);
|
|
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
|
|
uint256 ghostedSupply = gatekeeper.ghostedSupply();
|
|
|
|
vm.prank(ALICE);
|
|
staking.runGhost(receiver, ghostAmount);
|
|
assertEq(gatekeeper.ghostedSupply(), ghostedSupply + ghostAmount);
|
|
}
|
|
|
|
function test_couldNotGhostTokensFromArbitraryAddress(address someone) public {
|
|
vm.assume(someone != ALICE);
|
|
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
|
|
|
|
vm.expectRevert();
|
|
vm.prank(someone);
|
|
staking.runGhost(receiver, 69);
|
|
assertEq(gatekeeper.ghostedSupply(), 0);
|
|
}
|
|
|
|
function test_ghostTokensEmitsEvent(uint256 ghostAmount) public {
|
|
vm.assume(ghostAmount >= gatekeeper.EXISTENTIAL_DEPOSIT());
|
|
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
|
|
|
|
vm.expectEmit(true, true, true, false, address(gatekeeper));
|
|
emit Ghosted(receiver, ghostAmount);
|
|
vm.prank(ALICE);
|
|
staking.runGhost(receiver, ghostAmount);
|
|
}
|
|
|
|
function test_recallWork(uint256 exodusSession, uint256 bobAmount, uint32 bobCommission) public {
|
|
vm.assume(bobAmount > gatekeeper.EXISTENTIAL_DEPOSIT() && bobAmount < 1_000 ether);
|
|
vm.assume(bobCommission > 0 && bobCommission <= type(uint32).max);
|
|
|
|
address storageHistory = gatekeeper.storageHistory();
|
|
uint256 commissionAmount = FullMath.mulDiv(bobAmount, uint256(bobCommission), type(uint32).max);
|
|
uint256 bobPacked = RequestPacking.pack(uint32(bobCommission), uint64(block.chainid), BOB);
|
|
|
|
vm.prank(ALICE);
|
|
staking.runGhost(bytes32(abi.encodePacked(ALICE)), bobAmount);
|
|
|
|
uint256 nativeNeeded = FullMath.mulDiv(commissionAmount, staking.totalReserves(), staking.baseSupply());
|
|
|
|
vm.deal(ALICE, nativeNeeded + 1 ether);
|
|
assertEq(BOB.balance, 0 ether);
|
|
|
|
vm.prank(ALICE);
|
|
staking.runRecall(exodusSession, bobAmount, bobPacked, ALICE);
|
|
|
|
assert(IStorageHistory(storageHistory).isTransactionExecuted(exodusSession));
|
|
}
|
|
|
|
function test_rotateWork(bytes32 aggregatedPublicKey) public {
|
|
vm.warp(block.timestamp + 1);
|
|
vm.prank(address(gatekeeper));
|
|
gatekeeper.rotate(block.timestamp, aggregatedPublicKey, 0);
|
|
}
|
|
|
|
function test_couldNotBridgeBelowExistential(uint256 amount) public {
|
|
vm.assume(amount < gatekeeper.EXISTENTIAL_DEPOSIT());
|
|
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
|
|
|
|
vm.expectRevert();
|
|
vm.prank(ALICE);
|
|
staking.runGhost(receiver, amount);
|
|
|
|
assertEq(gatekeeper.ghostedSupply(), 0);
|
|
}
|
|
|
|
function test_signatureVerificationsWorks() public {
|
|
assertEq(gatekeeper.deployer(), ALICE);
|
|
|
|
vm.prank(ALICE);
|
|
staking.runGhost(bytes32(abi.encodePacked(ALICE)), type(uint104).max);
|
|
|
|
vm.prank(ALICE);
|
|
gatekeeper.updatePublicKeyMetadata(0, 0x875cdcba4ae5494518fa2602791e667ca0998402b6a69e5b7cb4c72dba4e4669, 0);
|
|
|
|
(bytes32 prevPublicKey, uint8 prevParity,) = gatekeeper.latestPublicKeyInfo();
|
|
|
|
// genesis validators 4 validators, DKG #0
|
|
// exodus session #0
|
|
gatekeeper.verify(
|
|
hex"49f03a670000000000000000000000000000000000000000000000000000000000000000875cdcba4ae5494518fa2602791e667ca0998402b6a69e5b7cb4c72dba4e46690000000000000000000000000000000000000000000000000000000000000000",
|
|
hex"044d9fa18df9da04381ed256981570a6ef6a0893496ded966fc994662df931ed423b29e2737394b31d8498594caad7b77e36ab31ac79df3796a1b6f26baa5552ae",
|
|
0x24029a571fcaeadd14f4afe8be62afe3d07876ae270c3caf446ecb6cfc7c08f2
|
|
);
|
|
|
|
(bytes32 publicKey, uint8 parity, uint64 session) = gatekeeper.latestPublicKeyInfo();
|
|
assertEq(publicKey, prevPublicKey);
|
|
assertEq(parity, prevParity);
|
|
assertEq(session, 0);
|
|
|
|
// could not apply signature from DKG #2
|
|
vm.expectRevert();
|
|
gatekeeper.verify(
|
|
hex"49f03a6700000000000000000000000000000000000000000000000000000000000000133492bc8bb10848f1f788496ccadde7d458eac4ac2c1eca2dd2c7a506d8fa2c5b0000000000000000000000000000000000000000000000000000000000000000",
|
|
hex"0434c3b37293516c6204dc291821e19ab5b3d8afb0947a0a2dffc91600fbd3f6b9783a66887d515e774b98a63a35a08bb3d914407fd768e92020b0ebaa3c8602b3",
|
|
0x71cd57e697af70f84a960cc94fcbae5889efbf919df410282a04c6d19f92609e
|
|
);
|
|
|
|
// genesis validators 7 validators, DKG #1
|
|
// exodus session #11
|
|
gatekeeper.verify(
|
|
hex"49f03a67000000000000000000000000000000000000000000000000000000000000000b4e8c1fe96d6737cdabbcc96501d6656b9d0b659b3a528ef507f2d52bef29e1570000000000000000000000000000000000000000000000000000000000000000",
|
|
hex"04b51db09ec2f4bebdb65c5352efa75f8d07088408e3ff907c74b0d7928a40dbe06f864364a3e6d219849ca8e7d47e6c66f8a18ca9f4fa4752df13bb6c2eae1172",
|
|
0x072e625bdd3ff7d09f2bf896b5e261efa007f8d81a9e2c828525ec74bd3ee08d
|
|
);
|
|
|
|
(publicKey, parity, session) = gatekeeper.latestPublicKeyInfo();
|
|
assert(publicKey != prevPublicKey);
|
|
assertEq(parity, prevParity);
|
|
assertEq(session, 11);
|
|
|
|
prevPublicKey = publicKey;
|
|
prevParity = parity;
|
|
|
|
// genesis validators 5 validators, DKG #2
|
|
// exodus session #19
|
|
gatekeeper.verify(
|
|
hex"49f03a6700000000000000000000000000000000000000000000000000000000000000133492bc8bb10848f1f788496ccadde7d458eac4ac2c1eca2dd2c7a506d8fa2c5b0000000000000000000000000000000000000000000000000000000000000000",
|
|
hex"0434c3b37293516c6204dc291821e19ab5b3d8afb0947a0a2dffc91600fbd3f6b9783a66887d515e774b98a63a35a08bb3d914407fd768e92020b0ebaa3c8602b3",
|
|
0x71cd57e697af70f84a960cc94fcbae5889efbf919df410282a04c6d19f92609e
|
|
);
|
|
|
|
(publicKey, parity, session) = gatekeeper.latestPublicKeyInfo();
|
|
assert(publicKey != prevPublicKey);
|
|
assertEq(parity, prevParity);
|
|
assertEq(session, 19);
|
|
|
|
|
|
uint256 aliceAmountBefore = staking.recalledAmount(ALICE);
|
|
uint256 bobAmountBefore = staking.recalledAmount(BOB);
|
|
uint256 aliceBalanceBefore = ALICE.balance;
|
|
uint256 bobBalanceBefore = BOB.balance;
|
|
|
|
// execute bridge out, happened on DKG #0
|
|
// amount: 69; commission: 0%; ALICE
|
|
// exodus session #1
|
|
vm.prank(ALICE, ALICE);
|
|
gatekeeper.verify(
|
|
hex"bf06188a0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000010000000000007a6900000000",
|
|
hex"04bccb4cd4633e2c61ca5c65006a6a09baa893be219b21509866123a8d6299f92aefe9c380bd9728dbe0b93a8042f431636d08ed191b5c04062bf14e1347059cb9",
|
|
0xe579753d931a78b143d7e3d86e1117ccbc9d2d7357b0207ea682046a0b06d798
|
|
);
|
|
|
|
assertEq(aliceAmountBefore + 69, staking.recalledAmount(ALICE));
|
|
assertEq(bobAmountBefore, staking.recalledAmount(BOB));
|
|
assertEq(aliceBalanceBefore, ALICE.balance);
|
|
assertEq(bobBalanceBefore, BOB.balance);
|
|
|
|
vm.deal(ALICE, 220);
|
|
|
|
aliceAmountBefore = staking.recalledAmount(ALICE);
|
|
bobAmountBefore = staking.recalledAmount(BOB);
|
|
aliceBalanceBefore = ALICE.balance;
|
|
bobBalanceBefore = BOB.balance;
|
|
|
|
uint256 buyback = 220;
|
|
|
|
// execute bridge out, happened on DKG #1
|
|
// amount: 420; commission: 50%; BOB
|
|
// exodus session #12
|
|
vm.prank(ALICE, ALICE);
|
|
gatekeeper.verify{value: buyback}(
|
|
hex"bf06188a000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000020000000000007a6980000000",
|
|
hex"049f458500a78f56420380f0c6863905f1181e705f6b562eb469bd81a03676a2d9b436a53d2356ea0a5bb175ca837655fab8114c6e64cfdd47f3d36d1a945d7122",
|
|
0x772731b359ee7ecac7830438333e4ffb61759b36610f69cef20f66f7a79a405f
|
|
);
|
|
|
|
assertApproxEqAbs(aliceAmountBefore + 210, staking.recalledAmount(ALICE), 1);
|
|
assertApproxEqAbs(bobAmountBefore + 210, staking.recalledAmount(BOB), 1);
|
|
|
|
// execute setDistributor, exodusSession: 2
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000020000000000007a690101010101010101010101010101010101010101000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000002475619ab5000000000000000000000000010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000",
|
|
hex"049f222e7ec776c390c7fe96b9c2034c37f4fc71a9714588a5d98ccb50dc748c98fe375c628e7bcc4db4f204a2a168b22ecbc631616a69987ef42601ad239b2ab5",
|
|
0x515539c5b713900a4dd4b3b119b22a47f862c90fdff9da91ed3fca687ea8db06
|
|
);
|
|
|
|
// execute setWarmupPeriod, exodusSession: 3
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000030000000000007a6901010101010101010101010101010101010101010000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000024a85667c5000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000",
|
|
hex"04c2d9b903c0bd640ff858de3518c64965e2ff07215a131c85a8febec629999cfd60970a3a99d0d04ba08a334f2aa865842ebde37407c6fee2b17f820c8104fc88",
|
|
0xe1727e132cbb7502a60bab56c5dedce1abca8130792ddd6d9ba59918766688e8
|
|
);
|
|
|
|
// execute setBounty, exodusSession: 4
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000040000000000007a69010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000245d87d363000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000",
|
|
hex"04ec7d454696833a1c9c04d79be81e0dfe8a4791862f1dc5d4e908338df30621911fb182e6f204699c53ea5b11db1c855f55dfd149d4882a80afa437d80c58d9cd",
|
|
0x22d3138ed4e72f104c5d86814c1b4e6eeed39cdcf97e087effe33f860d06f133
|
|
);
|
|
|
|
// execute setAdjustment, exodusSession: 5
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000050000000000007a690101010101010101010101010101010101010101000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000006446d36ab5000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000000001a4000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000",
|
|
hex"0484819be6cb8879179f91aaf94c1513234d9068052dd42bf067606033c2d173efe85e87acf5bc1020cab6ec67d5ec8f7b237c5f315b825b56e915e4736c2b7b62",
|
|
0x865b1e9006973e8b5b5492f2f6a0c85ee69ee7ae72f714ee076035865cd26a72
|
|
);
|
|
|
|
// execute updateGatekeeperAddress, exodusSession: 6
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000060000000000007a690101010101010101010101010101010101010101000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000002484f157cd000000000000000000000000010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000",
|
|
hex"040bfec065e85cb245d891a94b50b12ea8f91d27a90e113c0bf47f93e76c0c21380e6ff8dc05406d1e8ec34b2c90cc345fea1245c1ca3eb7ecccd8606bfb334f76",
|
|
0x15141679af9a42a9228adc686f802fe183515180bed3de3933e1622668e06796
|
|
);
|
|
|
|
// execute addPool, exodusSession: 7
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000070000000000007a6901010101010101010101010101010101010101010000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000024d914cd4b000000000000000000000000010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000",
|
|
hex"04eb497652f4ad64ddd9223cd1af4785b37c6b2a41f8c1f54b906d595ab0d2b53305cd006238ca4eaf7eede77b3e2c0d1019e9f9d505fe80e86240e0d83051dcf2",
|
|
0xa93dcb9c9c399973a17abc3b3667e37da716bdd5e9ed9c0b99d9fc869a886700
|
|
);
|
|
|
|
// execute removePool, exodusSession: 8
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000080000000000007a6901010101010101010101010101010101010101010000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000024a38dcbd0000000000000000000000000000000000000000000000000000000000000053900000000000000000000000000000000000000000000000000000000",
|
|
hex"0446039e3eec08f356c0a6e9fdd243aed6d840c1d9d973d1496db70499061055d45faf8e945d2fb87016cdcfda040df8fcaf22fe9a466dbdd4687cbfde7c87d0d8",
|
|
0x110eedf82f6533d95a43a19de3da026c51557e552bd4c5b6f06ca94d6ab2c8db
|
|
);
|
|
|
|
// execute close, exodusSession: 9
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000090000000000007a69010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000240aebeb4e00000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000000000000000000000",
|
|
hex"048da83909e645cf4313d00985c86bcbd24f584512f2279476767fb94829a2a9c7b95bcfeacc3bee2fe4710bfc2bcf2e72e58bcd37fc02293b660a7b70e2efd184",
|
|
0x8a28d3b7b5db6564e4abb846bc662a69d9b52ed08bd2ce2dbc6af4e86167f55e
|
|
);
|
|
|
|
// execute close, exodusSession: 10
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"31371426000000000000000000000000000000000000000000000000000000000000000a0000000000007a6901010101010101010101010101010101010101010000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000144a0139f41000000000000000000000000000000000000000000000000000000000000004500000000000000000000000000000000000000000000000000000000000001a4000000000000000000000000000000000000000000000000000000000000053900000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000000000000000000000000005390000000000000000000000000101010101010101010101010101010101010101000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000230000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000",
|
|
hex"0417bd8b7509486284c1f613117c61abc39cee8a24422fce457099e430b805468be33547f272d8123e9aa6f8895babbaa3a3731eaeda7d8ad4286c9fb117034d21",
|
|
0x0b71c4d8ca7748ec35257a42f26e09aaab9fa4a03e40d50a96bfdfdce10ce7e5
|
|
);
|
|
|
|
// execute enable, exodusSession: 13
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"31371426000000000000000000000000000000000000000000000000000000000000000d0000000000007a6901010101010101010101010101010101010101010000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000064e4e33ef800000000000000000000000000000000000000000000000000000000000000010000000000000000000000000101010101010101010101010101010101010101000000000000000000000000010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000",
|
|
hex"04f34417b947a4da097ca9596838430bf40587339fb42a09210ceb0dbbcfd98a99b1e8fd8f4d2301ee5b5d304e1d8b8e8b81ac14688f1e7de41d65c09a65975f01",
|
|
0xa4084ea553df2f808c86437547550be910554d41d33a5d66a4643c9792c4f56f
|
|
);
|
|
|
|
// execute disable, exodusSession: 14
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"31371426000000000000000000000000000000000000000000000000000000000000000e0000000000007a6901010101010101010101010101010101010101010000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044529918310000000000000000000000000000000000000000000000000000000000000003000000000000000000000000010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000",
|
|
hex"04f94dad10974c9f0b9307444dc4c660f1f169b25fd3ed9fd563df74714e73c2d4e92b3429505989327d449d9a68e6cce0f557574c92c0ca7bc8126dd710094e9e",
|
|
0xb6b75ed763f4d06b9d7a7557ca8d095df656ca25db74645fb47a0b45d27ec501
|
|
);
|
|
|
|
// execute forfeitReserves, exodusSession: 15
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"31371426000000000000000000000000000000000000000000000000000000000000000f0000000000007a6901010101010101010101010101010101010101010000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000064f0de236c000000000000000000000000010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000000001a4000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000",
|
|
hex"04af06146f4ca63ef11b82ad891d8e03525a11922316a7dd3f71ff4b6aa5ee6793d29e6af2355d26bc173bb52c1f5eb7d8b279ed40bef2d1cd521da33517b6d3cd",
|
|
0x6343b047bb8fe39200758de1e874ddfaf296e1f9259f0b720a070a69e7a3ee08
|
|
);
|
|
|
|
// execute redeemReserve, exodusSession: 16
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000100000000000007a690101010101010101010101010101010101010101000000000000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000004482a21577000000000000000000000000010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000000000000000000000",
|
|
hex"041ff894074000f2d934cf3b136165766044b177e69de4c36fac4d1265b855e1a5b4b7b2b25400fbf4d5eb4619039ffc95555db216991d3050bb6fd966f6e3eeab",
|
|
0x7d31ebf1e510616e541795b6448d387d2119b3fdd0124e5116c53726b6b1cc15
|
|
);
|
|
|
|
// execute withdraw, exodusSession: 17
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000110000000000007a6901010101010101010101010101010101010101010000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044f3fef3a3000000000000000000000000010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000000000000000000000",
|
|
hex"04f31030cf8563dd976d1a823a84e43ebdcc13bb5e5e0d7a2ff372006c71e6ab3d4d0770771682dcd6eff9e13fb3d113b484d7384d08f247760b07149dca1aa234",
|
|
0x06aad271d98e69d1ff18bf39e6713f347aba0df04d99bc4a9304b780431d12ae
|
|
);
|
|
|
|
// execute auditReserves, exodusSession: 18
|
|
vm.prank(ALICE);
|
|
gatekeeper.verify(
|
|
hex"3137142600000000000000000000000000000000000000000000000000000000000000120000000000007a69010101010101010101010101010101010101010100000000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000042b7ce50000000000000000000000000000000000000000000000000000000000",
|
|
hex"049e5d54fd32dcec64b20943a61763dc760b1e3e9d31948780e2193480d904984c0cdaa8074196c06104557b1a04de6aeeda135e0c3413192f9e4331f3b7447ff2",
|
|
0x43ed5301b16b4b2bc91c28dcfbaecc9949a7fc8fe5c57dfef6229f62493da6d2
|
|
);
|
|
|
|
address storageHistory = gatekeeper.storageHistory();
|
|
for (uint256 exodusSession; exodusSession < 19; exodusSession++) {
|
|
assert(IStorageHistory(storageHistory).isTransactionExecuted(exodusSession));
|
|
}
|
|
assert(IStorageHistory(storageHistory).isTransactionExecuted(19));
|
|
}
|
|
}
|