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

make metadata historically dependant

Browse Source 
Signed-off-by: Uncle Fatso <uncle.fatso@ghostchain.io>
This commit is contained in:
Uncle Fatso 2026-08-02 22:13:31 +03:00
parent 15e93e7f32
commit 379cc331e2
Signed by: f4ts0
GPG Key ID: 565F4F2860226EBB
9 changed files with 47 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.env.template
View File

@ -105,18 +105,10 @@ GOVERNOR_PROPOSAL_THRESHOLD=
GOVERNOR_QUORUM_FRACTION=
###################### Initial ghosted supply on gatekeeper ###########################
## ghostedSupply - supply that is currently locked inside the gatekeeper ##
## existential - minimum amount that could be reflected inside other chain ##
## 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 ##
## previousWeaver - previous weaver address if any to make linked list of weavers ##
#######################################################################################
INITIAL_GHOSTED_SUPPLY=
INITIAL_EXISTENTIAL_DEPOSIT=
INITIAL_GHOSTED_IN=
INITIAL_GHOSTED_OUT=
GATEKEEPER_DEPLOYED_AT=
PREVIOUS_WEAVER_ADDRESS=
SEPOLIA_TEST_RPC_URL=

23
src/Gatekeeper.sol
View File

@ -10,23 +10,24 @@ contract Gatekeeper is IGatekeeper, Metadata, Weaver {
uint256 public override existentialDeposit;
uint256 public override ghostedSupply;
address public immutable staking; // forge-lint: disable-line(screaming-snake-case-immutable)
address public override staking;
uint256 private _aggregatedPublicKey;
mapping(uint256 => mapping(uint256 => bool)) private _executedTransaction;
constructor(
address _staking,
uint256 _ghostedSupply,
uint256 _existential,
address _previousWeaver,
uint48 _deployedAt,
uint104 _amountIn,
uint104 _amountOut
) Metadata(_deployedAt, _amountIn, _amountOut) Weaver(_previousWeaver) {
existentialDeposit = _existential;
ghostedSupply = _ghostedSupply;
staking = _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 {
staking = _staking;
}
}
function ghost(bytes32 receiver, uint256 amount) external override returns (uint256) {

1
src/interfaces/IGatekeeper.sol
View File

@ -13,6 +13,7 @@ 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;

25
src/types/Metadata.sol
View File

@ -6,16 +6,21 @@ import {IMetadata} from "../interfaces/IMetadata.sol";
abstract contract Metadata is IMetadata {
GatekeeperMetadata internal _metadata;
constructor(
uint48 _deployedAt,
uint104 _amountIn,
uint104 _amountOut
) {
_metadata = GatekeeperMetadata({
deployedAt: _deployedAt,
amountIn: _amountIn,
amountOut: _amountOut
});
constructor(address previosMetadata) {
if (previosMetadata == address(0)) {
_metadata = GatekeeperMetadata({
deployedAt: uint48(block.number),
amountIn: 0,
amountOut: 0
});
} 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) {

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, 0, address(0), 0, 0, 0);
Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, address(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, 0, address(0), 0, 0, 0);
Gatekeeper gatekeeper = new Gatekeeper(address(staking), 0, address(0));
staking.setGatekeeperAddress(address(gatekeeper));
staking.setWarmupPeriod(10);
vm.stopPrank();

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

@ -14,18 +14,21 @@ contract GatekeeperTest is Test {
event Ghosted(bytes32 indexed receiver, uint256 indexed amount);
function setUp() public {
gatekeeper = new Gatekeeper(ALICE, 0, EXISTENTIAL, address(0), 0, 0, 0);
gatekeeper = new Gatekeeper(ALICE, EXISTENTIAL, address(0));
}
function test_correctInitialization() public {
assertEq(gatekeeper.staking(), ALICE);
assertEq(gatekeeper.ghostedSupply(), 0);
Gatekeeper anotherGatekeeper = new Gatekeeper(BOB, INIT_AMOUNT, EXISTENTIAL, address(0), 0, 0, 0);
assertEq(anotherGatekeeper.staking(), BOB);
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);
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,22 +9,19 @@ 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, INIT_GHOSTED, EXISTENTIAL, address(0), DEPLOYED_AT, AMOUNT_IN, AMOUNT_OUT);
gatekeeper = new Gatekeeper(ALICE, EXISTENTIAL, address(0));
}
function test_correctMetadataInitialization() public view {
Gatekeeper.GatekeeperMetadata memory metadata = gatekeeper.metadata();
assertEq(metadata.deployedAt, DEPLOYED_AT);
assertEq(metadata.amountIn, AMOUNT_IN);
assertEq(metadata.amountOut, AMOUNT_OUT);
assertEq(gatekeeper.ghostedSupply(), INIT_GHOSTED);
assertEq(metadata.deployedAt, block.number);
assertEq(metadata.amountIn, 0);
assertEq(metadata.amountOut, 0);
assertEq(gatekeeper.ghostedSupply(), 0);
}
function test_historicalAmountsOnlyIncrease(uint256 ghostAmount) public {

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

@ -12,20 +12,12 @@ contract GatekeeperVerification is Gatekeeper {
constructor(
address staking,
uint256 ghostedSupply,
uint256 existential,
address previousWeaver,
uint48 deployedAt,
uint104 amountIn,
uint104 amountOut
address previousWeaver
) Gatekeeper(
staking,
ghostedSupply,
existential,
previousWeaver,
deployedAt,
amountIn,
amountOut
previousWeaver
) {}
function filledEntries(uint256 session) public view returns (uint256) {
@ -104,7 +96,7 @@ contract GatekeeperWeaverTest is Test {
GatekeeperVerification gatekeeper;
function setUp() public {
gatekeeper = new GatekeeperVerification(ALICE, 0, EXISTENTIAL, address(0), 0, 0, 0);
gatekeeper = new GatekeeperVerification(ALICE, EXISTENTIAL, address(0));
}
function test_insertationWorksAsExpected() public {
@ -142,7 +134,7 @@ contract GatekeeperWeaverTest is Test {
assertFalse(_verifyProof(2047, currentSession, 100, amounts[2047], whos[2047]));
vm.roll(block.number + 420);
gatekeeper = new GatekeeperVerification(ALICE, 0, EXISTENTIAL, address(gatekeeper), 0, 0, 0);
gatekeeper = new GatekeeperVerification(ALICE, EXISTENTIAL, address(gatekeeper));
uint256 finalSession = gatekeeper.currentSession();
for (uint256 i = 0; i < 69; i++) {
@ -166,7 +158,6 @@ contract GatekeeperWeaverTest is Test {
assertFalse(_verifyProof(1337, currentSession, 100, amounts[1337], whos[1337]));
assertFalse(_verifyProof(2047, currentSession, 100, amounts[2047], whos[2047]));
// TODO: this fails for some reason
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]));

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