ghostchain/ghost-dao-contracts
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tests for new gatekeeper logic; except materialize function. actual signatures needed

Browse Source 
Signed-off-by: Uncle Fatso <uncle.fatso@ghostchain.io>
This commit is contained in:
Uncle Fatso 2026-08-24 15:10:19 +03:00
parent c4f4f2e0e2
commit 0d043ea964
Signed by: f4ts0
GPG Key ID: 565F4F2860226EBB
9 changed files with 230 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
test/bonding/BondDepositorty.t.sol
View File

@ -9,7 +9,6 @@ import {GhostAuthority} from "../../src/GhostAuthority.sol";
import {GhostTreasury} from "../../src/Treasury.sol";
import {GhostStaking} from "../../src/Staking.sol";
import {GhostBondDepository} from "../../src/BondDepository.sol";
import {Gatekeeper} from "../../src/Gatekeeper.sol";
import {ERC20Mock} from "../../src/mocks/ERC20Mock.sol";
import {WETH9} from "../../src/mocks/WETH9.sol";
import {GhostBondingCalculator} from "../../src/StandardBondingCalculator.sol";
@ -76,7 +75,8 @@ contract GhostBondDepositoryTest is Test {
EPOCH_LENGTH,
EPOCH_NUMBER,
EPOCH_END_TIME,
address(authority)
address(authority),
0
);
treasury = new GhostTreasury(address(ftso), 69, address(authority));
calculator = new GhostBondingCalculator(address(ftso), 1, 1);
@ -324,8 +324,6 @@ contract GhostBondDepositoryTest is Test {
uint256 amount = 10_000 * 1e18; // 10,000
vm.startPrank(GOVERNOR);
Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, address(0));
staking.setGatekeeperAddress(address(gatekeeper));
staking.setWarmupPeriod(1);
vm.stopPrank();
@ -509,8 +507,6 @@ contract GhostBondDepositoryTest is Test {
}
vm.startPrank(GOVERNOR);
Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, address(0));
staking.setGatekeeperAddress(address(gatekeeper));
staking.setWarmupPeriod(10);
vm.stopPrank();

96
test/gatekeeper/Gatekeeper.t.sol
View File

@ -14,7 +14,8 @@ contract GatekeeperTest is Test {
event Ghosted(bytes32 indexed receiver, uint256 indexed amount);
function setUp() public {
gatekeeper = new Gatekeeper(ALICE, EXISTENTIAL, address(0));
vm.prank(ALICE, ALICE);
gatekeeper = new Gatekeeper(EXISTENTIAL, address(0));
}
function test_correctInitialization() public {
@ -25,14 +26,15 @@ contract GatekeeperTest is Test {
vm.prank(ALICE);
gatekeeper.ghost(receiver, INIT_AMOUNT);
Gatekeeper anotherGatekeeper = new Gatekeeper(BOB, EXISTENTIAL, address(gatekeeper));
vm.prank(BOB);
Gatekeeper anotherGatekeeper = new Gatekeeper(EXISTENTIAL, address(gatekeeper));
assertEq(anotherGatekeeper.staking(), ALICE);
assertEq(anotherGatekeeper.ghostedSupply(), INIT_AMOUNT);
assertEq(anotherGatekeeper.existentialDeposit(), EXISTENTIAL);
}
function test_ghostTokensWork(uint256 ghostAmount) public {
vm.assume(ghostAmount >= EXISTENTIAL);
vm.assume(ghostAmount >= EXISTENTIAL && ghostAmount < type(uint96).max);
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
uint256 ghostedSupply = gatekeeper.ghostedSupply();
@ -61,14 +63,16 @@ contract GatekeeperTest is Test {
gatekeeper.ghost(receiver, ghostAmount);
}
function test_materializeWork(uint256 ghostAmount) public {
vm.expectRevert();
gatekeeper.materialize(ALICE, ghostAmount, 0, 0);
}
// TODO: revisit with actual signatures from the cargo test
// function test_materializeWork(uint256 ghostAmount) public {
// vm.prank(ALICE);
// gatekeeper.materialize(0, ghostAmount, 0, ALICE);
// }
function test_rotateWork(uint256 aggregatedPublicKey) public {
vm.expectRevert();
gatekeeper.rotate(aggregatedPublicKey, 0, 0);
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 {
@ -80,6 +84,78 @@ contract GatekeeperTest is Test {
gatekeeper.ghost(receiver, amount);
assertEq(gatekeeper.ghostedSupply(), 0);
}
function test_signatureVerificationsWorks() public {
assertEq(gatekeeper.deployer(), ALICE);
vm.prank(ALICE);
gatekeeper.updatePublicKeyMetadata(0, 0x875cdcba4ae5494518fa2602791e667ca0998402b6a69e5b7cb4c72dba4e4669, 0);
(bytes32 prevPublicKey, uint8 prevParity, uint64 prevSession) = gatekeeper.latestPublicKeyInfo();
gatekeeper.verify(
hex"49f03a670000000000000000000000000000000000000000000000000000000000000000875cdcba4ae5494518fa2602791e667ca0998402b6a69e5b7cb4c72dba4e46690000000000000000000000000000000000000000000000000000000000000000",
hex"044d9fa18df9da04381ed256981570a6ef6a0893496ded966fc994662df931ed423b29e2737394b31d8498594caad7b77e36ab31ac79df3796a1b6f26baa5552ae",
0x24029a571fcaeadd14f4afe8be62afe3d07876ae270c3caf446ecb6cfc7c08f2
);
(bytes32 publicKey, uint8 parity, uint64 session) = gatekeeper.latestPublicKeyInfo();
assertEq(publicKey, prevPublicKey);
assertEq(parity, prevParity);
assertEq(session, prevSession);
vm.expectRevert();
gatekeeper.verify(
hex"49f03a6700000000000000000000000000000000000000000000000000000000000000023492bc8bb10848f1f788496ccadde7d458eac4ac2c1eca2dd2c7a506d8fa2c5b0000000000000000000000000000000000000000000000000000000000000000",
hex"042b45a8909a137e7bab5caf4b2870ece0469c6a4149c10074cfdaf2c114a65daefe14179830c95d07fea439ce78d2ad11898578e5e678dbcb98a7576da9e57c77",
0x5a61b59cededac4010b89bc6935e0cb7d975f5e2db457227ee473203de5247ed
);
gatekeeper.verify(
hex"49f03a6700000000000000000000000000000000000000000000000000000000000000014e8c1fe96d6737cdabbcc96501d6656b9d0b659b3a528ef507f2d52bef29e1570000000000000000000000000000000000000000000000000000000000000000",
hex"04d4c4daeb68bf8e40db4b516ddf3be9dd0f56a81809945e30bf06b7e5b26d1b27c83367de842f00c915f06ab1755dc511a3a3fe213308b5e65c6832d9d9bb3b38",
0xd93d1b1613277ddb27df66bdea16d7b91adf975eb150e27a872ce035655ec13d
);
(publicKey, parity, session) = gatekeeper.latestPublicKeyInfo();
assert(publicKey != prevPublicKey);
assertEq(parity, prevParity);
assertEq(session, prevSession + 1);
prevPublicKey = publicKey;
prevParity = parity;
prevSession = session;
gatekeeper.verify(
hex"49f03a6700000000000000000000000000000000000000000000000000000000000000023492bc8bb10848f1f788496ccadde7d458eac4ac2c1eca2dd2c7a506d8fa2c5b0000000000000000000000000000000000000000000000000000000000000000",
hex"042b45a8909a137e7bab5caf4b2870ece0469c6a4149c10074cfdaf2c114a65daefe14179830c95d07fea439ce78d2ad11898578e5e678dbcb98a7576da9e57c77",
0x5a61b59cededac4010b89bc6935e0cb7d975f5e2db457227ee473203de5247ed
);
(publicKey, parity, session) = gatekeeper.latestPublicKeyInfo();
assert(publicKey != prevPublicKey);
assertEq(parity, prevParity);
assertEq(session, prevSession + 1);
vm.expectRevert();
gatekeeper.verify(
hex"49f03a670000000000000000000000000000000000000000000000000000000000000000875cdcba4ae5494518fa2602791e667ca0998402b6a69e5b7cb4c72dba4e46690000000000000000000000000000000000000000000000000000000000000000",
hex"044d9fa18df9da04381ed256981570a6ef6a0893496ded966fc994662df931ed423b29e2737394b31d8498594caad7b77e36ab31ac79df3796a1b6f26baa5552ae",
0x24029a571fcaeadd14f4afe8be62afe3d07876ae270c3caf446ecb6cfc7c08f2
);
vm.expectRevert();
gatekeeper.verify(
hex"49f03a6700000000000000000000000000000000000000000000000000000000000000014e8c1fe96d6737cdabbcc96501d6656b9d0b659b3a528ef507f2d52bef29e1570000000000000000000000000000000000000000000000000000000000000000",
hex"04d4c4daeb68bf8e40db4b516ddf3be9dd0f56a81809945e30bf06b7e5b26d1b27c83367de842f00c915f06ab1755dc511a3a3fe213308b5e65c6832d9d9bb3b38",
0xd93d1b1613277ddb27df66bdea16d7b91adf975eb150e27a872ce035655ec13d
);
vm.expectRevert();
gatekeeper.verify(
hex"49f03a6700000000000000000000000000000000000000000000000000000000000000023492bc8bb10848f1f788496ccadde7d458eac4ac2c1eca2dd2c7a506d8fa2c5b0000000000000000000000000000000000000000000000000000000000000000",
hex"042b45a8909a137e7bab5caf4b2870ece0469c6a4149c10074cfdaf2c114a65daefe14179830c95d07fea439ce78d2ad11898578e5e678dbcb98a7576da9e57c77",
0x5a61b59cededac4010b89bc6935e0cb7d975f5e2db457227ee473203de5247ed
);
}
}

62
test/gatekeeper/GatekeeperHistory.t.sol Normal file
View File

@ -0,0 +1,62 @@
pragma solidity 0.8.20;
import {Test} from "forge-std/Test.sol";
import {Gatekeeper} from "../../src/Gatekeeper.sol";
import {IStorageHistory} from "../../src/interfaces/IStorageHistory.sol";
contract GatekeeperStorageHistoryTest is Test {
address constant ALICE = 0x0000000000000000000000000000000000000001;
address constant BOB = 0x0000000000000000000000000000000000000002;
uint256 constant INIT_AMOUNT = 69 * 1e18;
uint256 constant INIT_GHOSTED = type(uint104).max / 2;
uint256 constant EXISTENTIAL = 0;
Gatekeeper gatekeeper;
function setUp() public {
vm.prank(ALICE);
gatekeeper = new Gatekeeper(EXISTENTIAL, address(0));
}
function test_correctStorageHistoryInitialization() public view {
address storageHistory = gatekeeper.storageHistory();
IStorageHistory.DeploymentSnapshot memory snapshot = IStorageHistory(storageHistory).deploymentSnapshot();
assertEq(snapshot.deployedAt, 0);
assertEq(snapshot.amountIn, 0);
assertEq(snapshot.amountOut, 0);
assertEq(gatekeeper.ghostedSupply(), 0);
}
function test_historicalAmountsOnlyIncrease(uint256 ghostAmount) public {
vm.assume(ghostAmount > 0 && ghostAmount < INIT_GHOSTED / 2);
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
address storageHistory = gatekeeper.storageHistory();
IStorageHistory.DeploymentSnapshot memory snapshot = IStorageHistory(storageHistory).deploymentSnapshot();
uint104 amountIn = snapshot.amountIn;
uint104 amountOut = snapshot.amountOut;
if (ghostAmount % 2 == 0) {
vm.prank(ALICE);
gatekeeper.ghost(receiver, ghostAmount);
// forge-lint: disable-next-line(unsafe-typecast)
amountIn += uint104(ghostAmount);
} else {
if (IStorageHistory(storageHistory).bridgeImbalance() >= ghostAmount) {
vm.prank(ALICE);
gatekeeper.materialize(0, ghostAmount, 0, BOB);
// forge-lint: disable-next-line(unsafe-typecast)
amountOut += uint104(ghostAmount);
}
}
IStorageHistory.DeploymentSnapshot memory newSnapshot = IStorageHistory(storageHistory).deploymentSnapshot();
assertEq(newSnapshot.amountIn, amountIn);
assertEq(newSnapshot.amountOut, amountOut);
assertEq(gatekeeper.ghostedSupply(), amountIn - amountOut);
}
}

53
test/gatekeeper/GatekeeperMetadata.t.sol
View File

@ -1,53 +0,0 @@
pragma solidity 0.8.20;
import {Test} from "forge-std/Test.sol";
import {Gatekeeper} from "../../src/Gatekeeper.sol";
contract GatekeeperMetadataTest is Test {
address constant ALICE = 0x0000000000000000000000000000000000000001;
uint256 constant INIT_AMOUNT = 69 * 1e18;
uint256 constant INIT_GHOSTED = type(uint104).max / 2;
uint256 constant EXISTENTIAL = 0;
Gatekeeper gatekeeper;
function setUp() public {
gatekeeper = new Gatekeeper(ALICE, EXISTENTIAL, address(0));
}
function test_correctMetadataInitialization() public view {
Gatekeeper.GatekeeperMetadata memory metadata = gatekeeper.metadata();
assertEq(metadata.deployedAt, block.number);
assertEq(metadata.amountIn, 0);
assertEq(metadata.amountOut, 0);
assertEq(gatekeeper.ghostedSupply(), 0);
}
function test_historicalAmountsOnlyIncrease(uint256 ghostAmount) public {
vm.assume(ghostAmount > 0 && ghostAmount < INIT_GHOSTED / 2);
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
uint256 ghostedSupply = gatekeeper.ghostedSupply();
Gatekeeper.GatekeeperMetadata memory metadata = gatekeeper.metadata();
uint104 amountIn = metadata.amountIn;
uint104 amountOut = metadata.amountOut;
if (ghostAmount % 2 == 0) {
vm.prank(ALICE);
gatekeeper.ghost(receiver, ghostAmount);
amountIn += uint104(ghostAmount); // forge-lint: disable-line(unsafe-typecast)
ghostedSupply += ghostAmount;
} else {
vm.expectRevert();
vm.prank(ALICE);
gatekeeper.materialize(ALICE, ghostAmount, 0, 0);
}
Gatekeeper.GatekeeperMetadata memory newMetadata = gatekeeper.metadata();
assertEq(newMetadata.amountIn, amountIn);
assertEq(newMetadata.amountOut, amountOut);
assertEq(gatekeeper.ghostedSupply(), ghostedSupply);
}
}

108
test/gatekeeper/GatekeeperWeaver.t.sol
View File

@ -5,20 +5,37 @@ import {Test} from "forge-std/Test.sol";
import {Gatekeeper} from "../../src/Gatekeeper.sol";
import {Hashes} from "../../src/libraries/Hashes.sol";
import {Checkpoints} from "../../src/libraries/Checkpoints.sol";
import {IGatekeeper} from "../../src/interfaces/IGatekeeper.sol";
import {IStorageHistory} from "../../src/interfaces/IStorageHistory.sol";
contract MockStaking {
GatekeeperVerification public gatekeeper;
address public governor;
constructor(uint256 existential) {
gatekeeper = new GatekeeperVerification(existential, address(0));
governor = msg.sender;
}
function ghost(bytes32 receiver, uint256 amount) external returns (uint256) {
require(msg.sender == governor);
return gatekeeper.ghost(receiver, amount);
}
function createNewGatekeeper(uint256 existential, address previousGatekeeper) external {
require(msg.sender == governor);
GatekeeperVerification newGatekeeper = new GatekeeperVerification(existential, address(gatekeeper));
address storageHistory = IGatekeeper(previousGatekeeper).storageHistory();
IStorageHistory(storageHistory).setOwner(address(newGatekeeper));
gatekeeper = newGatekeeper;
}
}
contract GatekeeperVerification is Gatekeeper {
using Checkpoints for Checkpoints.Trace256;
using Checkpoints for Checkpoints.Trace160;
constructor(
address staking,
uint256 existential,
address previousWeaver
) Gatekeeper(
staking,
existential,
previousWeaver
) {}
constructor(uint256 existential, address previousWeaver) Gatekeeper(existential, previousWeaver) {}
function filledEntries(uint256 session) public view returns (uint256) {
return _filledEntries[session];
@ -93,14 +110,17 @@ contract GatekeeperWeaverTest is Test {
uint256 constant EXISTENTIAL = 1337;
uint256 constant AMOUNT = 1 * 1e7;
MockStaking staking;
GatekeeperVerification gatekeeper;
function setUp() public {
gatekeeper = new GatekeeperVerification(ALICE, EXISTENTIAL, address(0));
vm.prank(ALICE);
staking = new MockStaking(EXISTENTIAL);
gatekeeper = staking.gatekeeper();
}
function test_insertationWorksAsExpected() public {
uint256 currentSession = gatekeeper.currentSession();
uint256 currentWeavingSession = gatekeeper.currentWeavingSession();
uint256 maxCount = gatekeeper.ENTRIES();
uint256 globalIndex;
@ -108,55 +128,59 @@ contract GatekeeperWeaverTest is Test {
for (uint256 i = 0; i < maxCount; i++) {
if (i % 5 == 0) { vm.roll(block.number + 1); }
globalIndex = _insertWithAssert(currentSession, amounts[i], whos[i]);
assertTrue(_verifyProof(globalIndex, currentSession, block.number, amounts[i], whos[i]));
globalIndex = _insertWithAssert(currentWeavingSession, amounts[i], whos[i]);
assertTrue(_verifyProof(globalIndex, currentWeavingSession, block.number, amounts[i], whos[i]));
}
globalIndex = _insertWithAssert(currentSession, amounts[69], whos[69]);
uint256 newSession = gatekeeper.currentSession();
globalIndex = _insertWithAssert(currentWeavingSession, amounts[69], whos[69]);
uint256 newSession = gatekeeper.currentWeavingSession();
assertEq(currentSession + 1, newSession);
assertEq(currentWeavingSession + 1, newSession);
vm.roll(block.number + 1337);
assertTrue(_verifyProof(globalIndex, newSession, block.number, amounts[69], whos[69]));
assertTrue(_verifyProof(0, currentSession, block.number, amounts[0], whos[0]));
assertTrue(_verifyProof(69, currentSession, block.number, amounts[69], whos[69]));
assertTrue(_verifyProof(420, currentSession, block.number, amounts[420], whos[420]));
assertTrue(_verifyProof(1337, currentSession, block.number, amounts[1337], whos[1337]));
assertTrue(_verifyProof(2047, currentSession, block.number, amounts[2047], whos[2047]));
assertTrue(_verifyProof(0, currentWeavingSession, block.number, amounts[0], whos[0]));
assertTrue(_verifyProof(69, currentWeavingSession, block.number, amounts[69], whos[69]));
assertTrue(_verifyProof(420, currentWeavingSession, block.number, amounts[420], whos[420]));
assertTrue(_verifyProof(1337, currentWeavingSession, block.number, amounts[1337], whos[1337]));
assertTrue(_verifyProof(2047, currentWeavingSession, block.number, amounts[2047], whos[2047]));
assertTrue(_verifyProof(0, currentSession, 100, amounts[0], whos[0]));
assertTrue(_verifyProof(69, currentSession, 100, amounts[69], whos[69]));
assertTrue(_verifyProof(420, currentSession, 100, amounts[420], whos[420]));
assertTrue(_verifyProof(0, currentWeavingSession, 100, amounts[0], whos[0]));
assertTrue(_verifyProof(69, currentWeavingSession, 100, amounts[69], whos[69]));
assertTrue(_verifyProof(420, currentWeavingSession, 100, amounts[420], whos[420]));
assertFalse(_verifyProof(globalIndex, newSession, 100, amounts[69], whos[69]));
assertFalse(_verifyProof(1337, currentSession, 100, amounts[1337], whos[1337]));
assertFalse(_verifyProof(2047, currentSession, 100, amounts[2047], whos[2047]));
assertFalse(_verifyProof(1337, currentWeavingSession, 100, amounts[1337], whos[1337]));
assertFalse(_verifyProof(2047, currentWeavingSession, 100, amounts[2047], whos[2047]));
vm.roll(block.number + 420);
gatekeeper = new GatekeeperVerification(ALICE, EXISTENTIAL, address(gatekeeper));
uint256 finalSession = gatekeeper.currentSession();
vm.prank(ALICE);
staking.createNewGatekeeper(EXISTENTIAL, address(gatekeeper));
gatekeeper = staking.gatekeeper();
uint256 finalSession = gatekeeper.currentWeavingSession();
for (uint256 i = 0; i < 69; i++) {
if (i % 2 == 0) { vm.roll(block.number + 1); }
vm.prank(ALICE);
gatekeeper.ghost(whos[i], amounts[i]);
staking.ghost(whos[i], amounts[i]);
}
assertTrue(_verifyProof(globalIndex, newSession, block.number, amounts[69], whos[69]));
assertTrue(_verifyProof(0, currentSession, block.number, amounts[0], whos[0]));
assertTrue(_verifyProof(69, currentSession, block.number, amounts[69], whos[69]));
assertTrue(_verifyProof(420, currentSession, block.number, amounts[420], whos[420]));
assertTrue(_verifyProof(1337, currentSession, block.number, amounts[1337], whos[1337]));
assertTrue(_verifyProof(2047, currentSession, block.number, amounts[2047], whos[2047]));
assertTrue(_verifyProof(0, currentWeavingSession, block.number, amounts[0], whos[0]));
assertTrue(_verifyProof(69, currentWeavingSession, block.number, amounts[69], whos[69]));
assertTrue(_verifyProof(420, currentWeavingSession, block.number, amounts[420], whos[420]));
assertTrue(_verifyProof(1337, currentWeavingSession, block.number, amounts[1337], whos[1337]));
assertTrue(_verifyProof(2047, currentWeavingSession, block.number, amounts[2047], whos[2047]));
assertTrue(_verifyProof(0, currentSession, 100, amounts[0], whos[0]));
assertTrue(_verifyProof(69, currentSession, 100, amounts[69], whos[69]));
assertTrue(_verifyProof(420, currentSession, 100, amounts[420], whos[420]));
assertTrue(_verifyProof(0, currentWeavingSession, 100, amounts[0], whos[0]));
assertTrue(_verifyProof(69, currentWeavingSession, 100, amounts[69], whos[69]));
assertTrue(_verifyProof(420, currentWeavingSession, 100, amounts[420], whos[420]));
assertFalse(_verifyProof(globalIndex, newSession, 100, amounts[69], whos[69]));
assertFalse(_verifyProof(1337, currentSession, 100, amounts[1337], whos[1337]));
assertFalse(_verifyProof(2047, currentSession, 100, amounts[2047], whos[2047]));
assertFalse(_verifyProof(1337, currentWeavingSession, 100, amounts[1337], whos[1337]));
assertFalse(_verifyProof(2047, currentWeavingSession, 100, amounts[2047], whos[2047]));
assertTrue(_verifyProof(0, finalSession, block.number, amounts[0], whos[0]));
assertTrue(_verifyProof(34, finalSession, block.number, amounts[34], whos[34]));
@ -191,14 +215,14 @@ contract GatekeeperWeaverTest is Test {
uint160 prevLength = gatekeeper.slotLengths(session, targetSlot);
vm.prank(ALICE);
globalIndex = gatekeeper.ghost(who, amount);
globalIndex = staking.ghost(who, amount);
if (session + 1 == gatekeeper.currentSession()) {
if (session + 1 == gatekeeper.currentWeavingSession()) {
assertEq(prevLength, gatekeeper.DEPTH());
assertEq(gatekeeper.slotLengths(session + 1, 0), 1);
assertEq(prevEntries, gatekeeper.ENTRIES());
assertEq(gatekeeper.filledEntries(session + 1), 1);
assertEq(session + 1, gatekeeper.currentSession());
assertEq(session + 1, gatekeeper.currentWeavingSession());
session += 1;
previousHash = bytes32(0);

53
test/staking/Staking.t.sol
View File

@ -10,7 +10,6 @@ import {GhostDistributor} from "../../src/StakingDistributor.sol";
import {GhostTreasury} from "../../src/Treasury.sol";
import {GhostStaking} from "../../src/Staking.sol";
import {ERC20Mock} from "../../src/mocks/ERC20Mock.sol";
import {Gatekeeper} from "../../src/Gatekeeper.sol";
import {GhostBondingCalculator} from "../../src/StandardBondingCalculator.sol";
import {ITreasury} from "../../src/interfaces/ITreasury.sol";
@ -61,7 +60,6 @@ contract StakingTest is Test {
GhostStaking staking;
GhostTreasury treasury;
GhostAuthority authority;
Gatekeeper gatekeeper;
GhostBondingCalculator calculator;
uint256 public constant AMOUNT = 69;
@ -105,12 +103,12 @@ contract StakingTest is Test {
EPOCH_LENGTH,
EPOCH_NUMBER,
EPOCH_END_TIME,
address(authority)
address(authority),
0
);
treasury = new GhostTreasury(address(ftso), 69, address(authority));
stnk.initialize(address(staking), address(treasury), address(ghst));
ghst.initialize(address(staking));
gatekeeper = new Gatekeeper(address(staking), 0, address(0));
calculator = new GhostBondingCalculator(address(ftso), 1, 1);
vm.stopPrank();
vm.roll(block.number + 1);
@ -588,34 +586,14 @@ contract StakingTest is Test {
staking.setDistributor(maybeGatekeeper);
}
function test_GOVERNORCouldSetGatekeeper(address maybeGatekeeper) public {
vm.assume(maybeGatekeeper != address(0));
assertEq(staking.gatekeeper(), address(0));
function test_GOVERNORCouldSetGatekeeper() public {
address previousGatekeeper = staking.gatekeeper();
vm.prank(GOVERNOR);
staking.setGatekeeperAddress(maybeGatekeeper);
assertEq(staking.gatekeeper(), maybeGatekeeper);
}
function test_couldNotGhostIfNoGatekeeper() public {
assertEq(staking.ghostedSupply(), 0);
vm.expectRevert();
staking.ghost(bytes32(abi.encodePacked(ALICE)), AMOUNT);
assertEq(staking.ghostedSupply(), 0);
}
function test_couldNotMaterializeIfNoGatekeeper() public {
assertEq(staking.ghostedSupply(), 0);
vm.expectRevert();
staking.materialize(ALICE, AMOUNT, 0, 0); // dummy rx and s
assertEq(staking.ghostedSupply(), 0);
staking.setGatekeeperAddress(420);
assert(staking.gatekeeper() != previousGatekeeper);
}
function test_couldNotGhostTokensIfNoGhst() public {
assertEq(staking.gatekeeper(), address(0));
vm.prank(GOVERNOR);
staking.setGatekeeperAddress(address(gatekeeper));
assertEq(staking.gatekeeper(), address(gatekeeper));
assertEq(staking.ghostedSupply(), 0);
vm.expectRevert();
vm.prank(ALICE);
@ -624,11 +602,6 @@ contract StakingTest is Test {
}
function test_correctlyGhostTokens() public {
assertEq(staking.gatekeeper(), address(0));
vm.prank(GOVERNOR);
staking.setGatekeeperAddress(address(gatekeeper));
assertEq(staking.gatekeeper(), address(gatekeeper));
_prepareAndRoll(ALICE, BIG_AMOUNT, true, true);
uint256 aliceBalance = stnk.balanceOf(ALICE);
@ -650,11 +623,6 @@ contract StakingTest is Test {
}
function test_ghostTokensEmitsEvent() public {
assertEq(staking.gatekeeper(), address(0));
vm.prank(GOVERNOR);
staking.setGatekeeperAddress(address(gatekeeper));
assertEq(staking.gatekeeper(), address(gatekeeper));
_prepareAndRoll(ALICE, BIG_AMOUNT, true, true);
uint256 aliceBalance = stnk.balanceOf(ALICE);
@ -664,7 +632,7 @@ contract StakingTest is Test {
vm.stopPrank();
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
vm.expectEmit(true, true, true, false, address(gatekeeper));
vm.expectEmit(true, true, true, false, staking.gatekeeper());
emit Ghosted(receiver, ghstBalance);
vm.prank(ALICE);
@ -672,11 +640,6 @@ contract StakingTest is Test {
}
function test_breakoutLogicWorks() public {
assertEq(staking.gatekeeper(), address(0));
vm.prank(GOVERNOR);
staking.setGatekeeperAddress(address(gatekeeper));
assertEq(staking.gatekeeper(), address(gatekeeper));
uint256 initialIndex = staking.index();
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
uint256 rebased = _prepareAndRoll(ALICE, BIG_AMOUNT, false, false);
@ -697,7 +660,7 @@ contract StakingTest is Test {
uint256 range = (payout * 3) / 100;
requestedPayout = (pseudoRandom % range) + 1;
vm.expectEmit(true, true, true, false, address(gatekeeper));
vm.expectEmit(true, true, true, false, staking.gatekeeper());
emit Ghosted(receiver, requestedPayout);
vm.prank(ALICE);

3
test/staking/StakingDistributor.t.sol
View File

@ -61,7 +61,8 @@ contract StakingDistributorTest is Test {
EPOCH_LENGTH,
EPOCH_NUMBER,
EPOCH_END_TIME,
address(authority)
address(authority),
0
);
treasury = new GhostTreasury(address(ftso), 69, address(authority));
calculator = new GhostBondingCalculator(address(ftso), 1, 1);

3
test/tokens/Ghst.t.sol
View File

@ -53,7 +53,8 @@ contract GhostTest is
69,
1337,
1337,
address(authority)
address(authority),
0
);
stnk.initialize(address(staking), TREASURY, address(ghst));
ghst.initialize(address(staking));

3
test/tokens/Stnk.t.sol
View File

@ -59,7 +59,8 @@ contract StinkyTest is Test, ERC20PermitTest, ERC20AllowanceTest, ERC20TransferT
69,
1337,
1337,
address(authority)
address(authority),
0
);
ghst.initialize(address(staking));
vm.stopPrank();