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

Compare commits

base: ghostchain:379cc331e253a4db3370d342f426da0866aa7d31
Branches Tags
ghostchain:main
..
compare: ghostchain:699835588729d2f36b37aa4caecddef7a85209d3
Branches Tags
ghostchain:main

No commits in common. "379cc331e253a4db3370d342f426da0866aa7d31" and "699835588729d2f36b37aa4caecddef7a85209d3" have entirely different histories.
379cc331e2 ... 6998355887

12 changed files with 64 additions and 112 deletions
Show Stats Expand all files Collapse all files

14
.env.template
View File

@ -104,12 +104,18 @@ GOVERNOR_VOTING_PERIOD=
GOVERNOR_PROPOSAL_THRESHOLD=
GOVERNOR_QUORUM_FRACTION=
###################### Initial ghosted supply on gatekeeper ###########################
###################### Initial ghosted supply on gatekeeper ##########################
## ghostedSupply - supply that is currently locked inside the gatekeeper ##
## existential - minimum amount that could be reflected inside other chain ##
## previousWeaver - previous weaver address if any to make linked list of weavers ##
#######################################################################################
## ghostedIn - historical supply that was bridged in (max value is 2^104) ##
## ghostedOut - historical supply that was bridged out (max value is 2^104) ##
## deployedAt - time when gatekeepers was deployed, could be inherited if needed ##
######################################################################################
INITIAL_GHOSTED_SUPPLY=
INITIAL_EXISTENTIAL_DEPOSIT=
PREVIOUS_WEAVER_ADDRESS=
INITIAL_GHOSTED_IN=
INITIAL_GHOSTED_OUT=
GATEKEEPER_DEPLOYED_AT=
SEPOLIA_TEST_RPC_URL=
SEPOLIA_TEST_API_KEY=

20
src/Gatekeeper.sol
View File

@ -10,25 +10,23 @@ contract Gatekeeper is IGatekeeper, Metadata, Weaver {
uint256 public override existentialDeposit;
uint256 public override ghostedSupply;
address public override staking;
address public immutable staking; // forge-lint: disable-line(screaming-snake-case-immutable)
uint256 private _aggregatedPublicKey;
mapping(uint256 => mapping(uint256 => bool)) private _executedTransaction;
constructor(
address _staking,
uint256 _existentialDeposit,
address _previousGatekeeper
) Metadata(_previousGatekeeper) Weaver(_previousGatekeeper) {
existentialDeposit = _existentialDeposit;
if (_previousGatekeeper != address(0)) {
IGatekeeper previousGatekeeper = IGatekeeper(_previousGatekeeper);
ghostedSupply = previousGatekeeper.ghostedSupply();
staking = previousGatekeeper.staking();
} else {
uint256 _ghostedSupply,
uint256 _existential,
uint48 _deployedAt,
uint104 _amountIn,
uint104 _amountOut
) Metadata(_deployedAt, _amountIn, _amountOut) Weaver() {
existentialDeposit = _existential;
ghostedSupply = _ghostedSupply;
staking = _staking;
}
}
function ghost(bytes32 receiver, uint256 amount) external override returns (uint256) {
if (msg.sender != staking) revert NotStaking();

1
src/interfaces/IGatekeeper.sol
View File

@ -13,7 +13,6 @@ interface IGatekeeper {
function ghostedSupply() external view returns (uint256);
function existentialDeposit() external view returns (uint256);
function staking() external view returns (address);
function ghost(bytes32 receiver, uint256 amount) external returns (uint256);
function materialize(address receiver, uint256 amount, uint256 rx, uint256 s) external;
function rotate(uint256 aggregatedPublicKey, uint256 rx, uint256 s) external;

8
src/interfaces/IWeaver.sol
View File

@ -2,9 +2,7 @@
pragma solidity ^0.8.20;
interface IWeaver {
function currentSession() external view returns (uint256);
function startSession() external view returns (uint256);
function getSlotValues(uint256 globalIndex, uint256 session, uint256 atBlock) external view returns (bytes32[] memory);
function getProof(uint256 globalIndex, uint256 session, uint256 atBlock) external view returns (bytes32[] memory);
function getRoot(uint256 session, uint256 atBlock) external view returns (bytes32, uint256);
function getSlotValues(uint256 globalIndex, uint256 session, uint256 atBlock) external returns (bytes32[] memory);
function getProof(uint256 globalIndex, uint256 session, uint256 atBlock) external returns (bytes32[] memory);
function getRoot(uint256 session, uint256 atBlock) external returns (bytes32, uint256);
}

2
src/mocks/WeaverMock.sol
View File

@ -4,7 +4,7 @@ pragma solidity ^0.8.20;
import {Weaver} from "../types/Weaver.sol";
contract WeaverMock is Weaver {
constructor(address previousWeaver) Weaver(previousWeaver) {}
constructor() Weaver() {}
function insertTreeNode(bytes32 receiver, uint256 amount) external returns (uint256) {
return _insertTreeNode(receiver, amount);

21
src/types/Metadata.sol
View File

@ -6,21 +6,16 @@ import {IMetadata} from "../interfaces/IMetadata.sol";
abstract contract Metadata is IMetadata {
GatekeeperMetadata internal _metadata;
constructor(address previosMetadata) {
if (previosMetadata == address(0)) {
constructor(
uint48 _deployedAt,
uint104 _amountIn,
uint104 _amountOut
) {
_metadata = GatekeeperMetadata({
deployedAt: uint48(block.number),
amountIn: 0,
amountOut: 0
deployedAt: _deployedAt,
amountIn: _amountIn,
amountOut: _amountOut
});
} else {
IMetadata.GatekeeperMetadata memory previousMetadata = IMetadata(previosMetadata).metadata();
_metadata = GatekeeperMetadata({
deployedAt: previousMetadata.deployedAt,
amountIn: previousMetadata.amountIn,
amountOut: previousMetadata.amountOut
});
}
}
function metadata() external view returns (GatekeeperMetadata memory) {

31
src/types/Weaver.sol
View File

@ -14,33 +14,20 @@ abstract contract Weaver is IWeaver {
uint256 public constant SLOTS = 2 ** DEPTH;
uint256 public constant ENTRIES = DEPTH * SLOTS;
uint256 public override currentSession;
uint256 public override startSession;
address public previousWeaver;
uint256 public currentSession;
mapping(uint256 => mapping(uint256 => Checkpoints.Trace256)) internal _treeNodes;
mapping(uint256 => mapping(uint256 => Checkpoints.Trace160)) internal _slotLenghts;
mapping(uint256 => mapping(uint256 => bytes32[])) internal _slotValues;
mapping(uint256 => uint256) internal _filledEntries;
constructor(address _previousWeaver) {
previousWeaver = _previousWeaver;
if (_previousWeaver != address(0)) {
uint256 newSession = IWeaver(_previousWeaver).currentSession() + 1;
currentSession = newSession;
startSession = newSession;
}
}
constructor() {}
function getSlotValues(
uint256 globalIndex,
uint256 session,
uint256 atBlock
) external override view returns (bytes32[] memory) {
if (session < startSession) {
return IWeaver(previousWeaver).getSlotValues(globalIndex, session, atBlock);
}
) external view returns (bytes32[] memory) {
uint256 slotIndex = globalIndex % SLOTS;
// forge-lint: disable-next-line(unsafe-typecast)
uint256 length = _slotLenghts[session][slotIndex].upperLookupRecent(uint96(atBlock));
@ -55,11 +42,7 @@ abstract contract Weaver is IWeaver {
return values;
}
function getRoot(uint256 session, uint256 atBlock) public override view returns (bytes32, uint256) {
if (session < startSession) {
return IWeaver(previousWeaver).getRoot(session, atBlock);
}
function getRoot(uint256 session, uint256 atBlock) public view returns (bytes32, uint256) {
uint256 currentLevelCount = SLOTS >> 1;
bytes32[] memory currentLevel = new bytes32[](currentLevelCount);
@ -100,11 +83,7 @@ abstract contract Weaver is IWeaver {
uint256 globalIndex,
uint256 session,
uint256 atBlock
) external override view returns (bytes32[] memory) {
if (session < startSession) {
return IWeaver(previousWeaver).getProof(globalIndex, session, atBlock);
}
) external view returns (bytes32[] memory) {
uint256 currentLevelCount = SLOTS;
uint256 currentIndex = globalIndex % SLOTS;

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

@ -324,7 +324,7 @@ contract GhostBondDepositoryTest is Test {
uint256 amount = 10_000 * 1e18; // 10,000
vm.startPrank(GOVERNOR);
Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, address(0));
Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, 0, 0, 0, 0);
staking.setGatekeeperAddress(address(gatekeeper));
staking.setWarmupPeriod(1);
vm.stopPrank();
@ -509,7 +509,7 @@ contract GhostBondDepositoryTest is Test {
}
vm.startPrank(GOVERNOR);
Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, address(0));
Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, 0, 0, 0, 0);
staking.setGatekeeperAddress(address(gatekeeper));
staking.setWarmupPeriod(10);
vm.stopPrank();

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

@ -14,21 +14,18 @@ contract GatekeeperTest is Test {
event Ghosted(bytes32 indexed receiver, uint256 indexed amount);
function setUp() public {
gatekeeper = new Gatekeeper(ALICE, EXISTENTIAL, address(0));
gatekeeper = new Gatekeeper(ALICE, 0, EXISTENTIAL, 0, 0, 0);
}
function test_correctInitialization() public {
assertEq(gatekeeper.staking(), ALICE);
assertEq(gatekeeper.ghostedSupply(), 0);
bytes32 receiver = bytes32(abi.encodePacked(ALICE));
vm.prank(ALICE);
gatekeeper.ghost(receiver, INIT_AMOUNT);
Gatekeeper anotherGatekeeper = new Gatekeeper(BOB, EXISTENTIAL, address(gatekeeper));
assertEq(anotherGatekeeper.staking(), ALICE);
Gatekeeper anotherGatekeeper = new Gatekeeper(BOB, INIT_AMOUNT, EXISTENTIAL, 0, 0, 0);
assertEq(anotherGatekeeper.staking(), BOB);
assertEq(anotherGatekeeper.ghostedSupply(), INIT_AMOUNT);
assertEq(anotherGatekeeper.existentialDeposit(), EXISTENTIAL);
assertEq(anotherGatekeeper.ghostedSupply(), INIT_AMOUNT);
}
function test_ghostTokensWork(uint256 ghostAmount) public {

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

@ -9,19 +9,22 @@ contract GatekeeperMetadataTest is Test {
uint256 constant INIT_AMOUNT = 69 * 1e18;
uint256 constant INIT_GHOSTED = type(uint104).max / 2;
uint256 constant EXISTENTIAL = 0;
uint48 constant DEPLOYED_AT = 1337;
uint104 constant AMOUNT_IN = 69;
uint104 constant AMOUNT_OUT = 420;
Gatekeeper gatekeeper;
function setUp() public {
gatekeeper = new Gatekeeper(ALICE, EXISTENTIAL, address(0));
gatekeeper = new Gatekeeper(ALICE, INIT_GHOSTED, EXISTENTIAL, DEPLOYED_AT, AMOUNT_IN, AMOUNT_OUT);
}
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);
assertEq(metadata.deployedAt, DEPLOYED_AT);
assertEq(metadata.amountIn, AMOUNT_IN);
assertEq(metadata.amountOut, AMOUNT_OUT);
assertEq(gatekeeper.ghostedSupply(), INIT_GHOSTED);
}
function test_historicalAmountsOnlyIncrease(uint256 ghostAmount) public {

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

@ -12,12 +12,18 @@ contract GatekeeperVerification is Gatekeeper {
constructor(
address staking,
uint256 ghostedSupply,
uint256 existential,
address previousWeaver
uint48 deployedAt,
uint104 amountIn,
uint104 amountOut
) Gatekeeper(
staking,
ghostedSupply,
existential,
previousWeaver
deployedAt,
amountIn,
amountOut
) {}
function filledEntries(uint256 session) public view returns (uint256) {
@ -96,7 +102,7 @@ contract GatekeeperWeaverTest is Test {
GatekeeperVerification gatekeeper;
function setUp() public {
gatekeeper = new GatekeeperVerification(ALICE, EXISTENTIAL, address(0));
gatekeeper = new GatekeeperVerification(ALICE, 0, EXISTENTIAL, 0, 0, 0);
}
function test_insertationWorksAsExpected() public {
@ -132,35 +138,6 @@ contract GatekeeperWeaverTest is Test {
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]));
vm.roll(block.number + 420);
gatekeeper = new GatekeeperVerification(ALICE, EXISTENTIAL, address(gatekeeper));
uint256 finalSession = gatekeeper.currentSession();
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]);
}
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, currentSession, 100, amounts[0], whos[0]));
assertTrue(_verifyProof(69, currentSession, 100, amounts[69], whos[69]));
assertTrue(_verifyProof(420, currentSession, 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]));
assertTrue(_verifyProof(0, finalSession, block.number, amounts[0], whos[0]));
assertTrue(_verifyProof(34, finalSession, block.number, amounts[34], whos[34]));
assertTrue(_verifyProof(35, finalSession, block.number, amounts[35], whos[35]));
}
function _verifyProof(

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

@ -110,7 +110,7 @@ contract StakingTest is Test {
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));
gatekeeper = new Gatekeeper(address(staking), 0, 0, 0, 0, 0);
calculator = new GhostBondingCalculator(address(ftso), 1, 1);
vm.stopPrank();
vm.roll(block.number + 1);