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

Compare commits

base: ghostchain:566bf34febb372df9f5c92889d8f0db926103168
Branches Tags
ghostchain:main
..
compare: ghostchain:6a47e18b355fb3089407d1fed312a34eb14b435b
Branches Tags
ghostchain:main

No commits in common. "566bf34febb372df9f5c92889d8f0db926103168" and "6a47e18b355fb3089407d1fed312a34eb14b435b" have entirely different histories.
566bf34feb ... 6a47e18b35

11 changed files with 65 additions and 220 deletions
Show Stats Expand all files Collapse all files

2
src/BondDepository.sol
View File

@ -251,7 +251,7 @@ contract GhostBondDepository is IBondDepository, NoteKeeper {
}
function isLive(uint256 id) public view override returns (bool) {
return terms[id].conclusion > block.timestamp;
return (markets[id].capacity > 0 && terms[id].conclusion > block.timestamp);
}
function liveMarkets() external view override returns (uint256[] memory) {

62
src/Staking.sol
View File

@ -4,7 +4,6 @@ pragma solidity ^0.8.20;
import {SafeERC20} from "@openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@openzeppelin-contracts/token/ERC20/IERC20.sol";
import {GhostWarmup} from "./Warmup.sol";
import {GhostAccessControlled} from "./types/GhostAccessControlled.sol";
import {ISTNK} from "./interfaces/ISTNK.sol";
@ -13,7 +12,6 @@ import {IDistributor} from "./interfaces/IDistributor.sol";
import {IStaking} from "./interfaces/IStaking.sol";
import {IGatekeeper} from "./interfaces/IGatekeeper.sol";
import {IGhostAuthority} from "./interfaces/IGhostAuthority.sol";
import {IGhostWarmup} from "./interfaces/IGhostWarmup.sol";
contract GhostStaking is IStaking, GhostAccessControlled {
using SafeERC20 for IERC20;
@ -29,9 +27,9 @@ contract GhostStaking is IStaking, GhostAccessControlled {
Epoch public epoch;
address public distributor;
address public gatekeeper;
address public warmup;
uint256 public sharesInWarmup;
mapping(address => bool) public locks;
mapping(address => Claim) public warmupInfo;
constructor(
address _ftso,
@ -65,35 +63,40 @@ contract GhostStaking is IStaking, GhostAccessControlled {
if (isClaim && warmupPeriod == 0) {
returnAmount = _send(returnAmount, to, isRebase);
} else {
if (locks[to] && to != msg.sender) revert ExternalDepositsLocked();
uint48 expiry = epoch.number + warmupPeriod;
IGhostWarmup(warmup).addToWarmup(amount, to, expiry);
Claim storage info = warmupInfo[to];
if (info.lock && to != msg.sender) revert ExternalDepositsLocked();
info.deposit += returnAmount;
info.shares += ISTNK(stnk).sharesForBalance(returnAmount);
info.expiry = epoch.number + warmupPeriod;
sharesInWarmup += ISTNK(stnk).sharesForBalance(returnAmount);
}
}
function claim(address to, bool isRebase) public override returns (uint256 claimedAmount) {
if (locks[to] && to != msg.sender) revert ExternalDepositsLocked();
claimedAmount = IGhostWarmup(warmup).claim(to, epoch.number);
if (isRebase) {
claimedAmount = IGHST(ghst).balanceFrom(claimedAmount);
ISTNK(stnk).safeTransfer(to, claimedAmount);
} else {
IGHST(ghst).mint(to, claimedAmount);
Claim memory info = warmupInfo[to];
if (info.lock && to != msg.sender) revert ExternalDepositsLocked();
if (epoch.number >= info.expiry && info.expiry > 0) {
delete warmupInfo[to];
sharesInWarmup -= info.shares;
claimedAmount = _send(ISTNK(stnk).balanceForShares(info.shares), to, isRebase);
}
}
function breakout(bytes32 receiver, uint256 amount) public override {
IGhostWarmup(warmup).breakout(msg.sender, amount);
IGatekeeper(gatekeeper).ghost(receiver, amount);
}
function forfeit() external override returns (uint256) {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
function forfeit() external override returns (uint256 deposit) {
deposit = IGhostWarmup(warmup).forfeit(msg.sender);
IERC20(ftso).safeTransfer(msg.sender, deposit);
sharesInWarmup -= info.shares;
IERC20(ftso).safeTransfer(msg.sender, info.deposit);
return info.deposit;
}
function toggleLock() external override {
locks[msg.sender] = !locks[msg.sender];
warmupInfo[msg.sender].lock = !warmupInfo[msg.sender].lock;
}
function unstake(
@ -180,10 +183,6 @@ contract GhostStaking is IStaking, GhostAccessControlled {
function setWarmupPeriod(uint256 _warmupPeriod) external onlyGovernor {
// forge-lint: disable-next-line(unsafe-typecast)
warmupPeriod = uint48(_warmupPeriod);
if (warmup == address(0)) {
GhostWarmup newWarmup = new GhostWarmup(ghst);
warmup = address(newWarmup);
}
emit WarmupSet(_warmupPeriod);
}
@ -197,10 +196,7 @@ contract GhostStaking is IStaking, GhostAccessControlled {
}
function supplyInWarmup() public view override returns (uint256) {
if (warmup == address(0)) {
return 0;
}
return IGHST(ghst).balanceFrom(IGhostWarmup(warmup).ghstInWarmup());
return ISTNK(stnk).balanceForShares(sharesInWarmup);
}
function ghostedSupply() public view override returns (uint256 amount) {
@ -209,12 +205,6 @@ contract GhostStaking is IStaking, GhostAccessControlled {
}
}
function warmupInfo(address who) external view returns (uint256, uint256, uint48, bool) {
bool lock = locks[who];
(uint256 deposit, uint256 payout, uint48 expiry) = IGhostWarmup(warmup).warmupInfo(who);
return (deposit, payout, expiry, lock);
}
function _send(
uint256 amount,
address to,

80
src/Warmup.sol
View File

@ -1,80 +0,0 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import {IGhostWarmup} from "./interfaces/IGhostWarmup.sol";
import {IGHST} from "./interfaces/IGHST.sol";
import {FullMath} from "./libraries/FullMath.sol";
contract GhostWarmup is IGhostWarmup {
address public immutable STAKING;
address public immutable GHST;
uint256 private _ghstInWarmup;
mapping(address => Claim) private _warmupInfo;
constructor(address ghst) {
STAKING = msg.sender;
GHST = ghst;
}
function addToWarmup(
uint256 payout,
address who,
uint48 expiry
) external override {
if (msg.sender != STAKING) revert NotStakingContract();
Claim storage info = _warmupInfo[who];
uint256 ghstPayout = IGHST(GHST).balanceTo(payout);
info.deposit += payout;
info.payout += ghstPayout;
info.expiry = expiry;
_ghstInWarmup += ghstPayout;
}
function claim(
address to,
uint256 epochNumber
) external override returns (uint256 claimedAmount) {
if (msg.sender != STAKING) revert NotStakingContract();
Claim memory info = _warmupInfo[to];
if (epochNumber >= info.expiry && info.expiry > 0) {
delete _warmupInfo[to];
_ghstInWarmup -= info.payout;
claimedAmount = info.payout;
}
}
function breakout(address who, uint256 payout) external override {
if (msg.sender != STAKING) revert NotStakingContract();
Claim storage info = _warmupInfo[who];
uint256 depositReduction = FullMath.mulDiv(info.deposit, payout, info.payout);
info.deposit -= depositReduction;
info.payout -= payout;
_ghstInWarmup -= payout;
}
function forfeit(address who) external override returns (uint256) {
if (msg.sender != STAKING) revert NotStakingContract();
Claim memory info = _warmupInfo[who];
delete _warmupInfo[who];
_ghstInWarmup -= info.payout;
return info.deposit;
}
function ghstInWarmup() external view override returns (uint256) {
return _ghstInWarmup;
}
function warmupInfo(address who) external view override returns (uint256, uint256, uint48) {
Claim memory info = _warmupInfo[who];
return (info.deposit, info.payout, info.expiry);
}
}

20
src/interfaces/IGhostWarmup.sol
View File

@ -1,20 +0,0 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
interface IGhostWarmup {
struct Claim {
uint256 deposit;
uint256 payout;
uint48 expiry;
}
error NotStakingContract();
error ExternalDepositsLocked();
function addToWarmup(uint256 payout, address who, uint48 expiry) external;
function claim(address who, uint256 epochNumber) external returns (uint256);
function breakout(address who, uint256 amount) external;
function forfeit(address who) external returns (uint256);
function ghstInWarmup() external view returns (uint256);
function warmupInfo(address who) external view returns (uint256, uint256, uint48);
}

6
src/interfaces/INoteKeeper.sol
View File

@ -21,13 +21,7 @@ interface INoteKeeper {
uint256[] memory _indexes
) external returns (uint256);
function forceRedeem(
bytes32 _receiver,
uint256[] memory _indexes
) external returns (uint256);
function redeemAll(address _user, bool _sendGhst) external returns (uint256);
function forceRedeemAll(bytes32 _receiver) external returns (uint256);
function pushNote(address to, uint256 index) external;
function pullNote(address from, uint256 index) external returns (uint256 newIndex_);
function indexesFor(address _user) external view returns (uint256[] memory);

1
src/interfaces/IStaking.sol
View File

@ -32,7 +32,6 @@ interface IStaking {
) external returns (uint256);
function claim(address _recipient, bool _rebasing) external returns (uint256);
function breakout(bytes32 _receiver, uint256 _amount) external;
function forfeit() external returns (uint256);
function toggleLock() external;

10
src/libraries/FullMath.sol
View File

@ -3,20 +3,17 @@ pragma solidity ^0.8.20;
library FullMath {
function fullMul(uint256 x, uint256 y) private pure returns (uint256 l, uint256 h) {
unchecked {
uint256 mm = mulmod(x, y, type(uint256).max);
l = x * y;
h = mm - l;
if (mm < l) h -= 1;
}
}
function fullDiv(
uint256 l,
uint256 h,
uint256 d
) private pure returns (uint256) {
unchecked {
uint256 pow2 = d & (~d + 1);
d /= pow2;
l /= pow2;
@ -32,19 +29,15 @@ library FullMath {
r *= 2 - d * r;
return l * r;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 d
) internal pure returns (uint256) {
if (d == 0) revert("FullMath: DIVISION_BY_ZERO");
unchecked {
(uint256 l, uint256 h) = fullMul(x, y);
uint256 mm = mulmod(x, y, d);
uint256 mm = mulmod(x, y, d);
if (mm > l) h -= 1;
l -= mm;
@ -53,5 +46,4 @@ library FullMath {
require(h < d, "FullMath: FULLDIV_OVERFLOW");
return fullDiv(l, h, d);
}
}
}

25
src/types/NoteKeeper.sol
View File

@ -93,27 +93,6 @@ abstract contract NoteKeeper is INoteKeeper, FrontEndRewarder {
else _STAKING.unwrap(user, payout);
}
function forceRedeem(
bytes32 receiver,
uint256[] memory indexes
) public override returns (uint256 payout) {
address user = msg.sender;
uint48 time = uint48(block.timestamp);
uint256 i;
for (; i < indexes.length; ) {
(uint256 pay, bool matured) = pendingFor(user, indexes[i]);
if (matured) {
_pendingIndexes[user].remove(indexes[i]);
notes[user][indexes[i]].redeemed = time;
payout += pay;
}
unchecked { ++i; }
}
_STAKING.breakout(receiver, payout);
}
function redeemAll(
address user,
bool sendGhst
@ -121,10 +100,6 @@ abstract contract NoteKeeper is INoteKeeper, FrontEndRewarder {
return redeem(user, sendGhst, indexesFor(user));
}
function forceRedeemAll(bytes32 receiver) external override returns (uint256) {
return forceRedeem(receiver, indexesFor(msg.sender));
}
function pushNote(address to, uint256 index) external override {
if (notes[msg.sender][index].created == 0) revert NoteNotFound(msg.sender, index);
_noteTransfers[msg.sender][index] = to;

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

@ -89,10 +89,6 @@ contract GhostBondDepositoryTest is Test {
address(weth)
);
vm.stopPrank();
vm.prank(GOVERNOR);
staking.setWarmupPeriod(0);
_createFirstBond();
}

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

@ -76,9 +76,6 @@ contract StakingTest is Test {
gatekeeper = new Gatekeeper(address(staking), 0, 0, 0, 0, 0);
calculator = new GhostBondingCalculator(address(ftso), 1, 1);
vm.stopPrank();
vm.prank(GOVERNOR);
staking.setWarmupPeriod(0);
}
function test_correctAfterConstruction() public view {
@ -142,12 +139,13 @@ contract StakingTest is Test {
vm.prank(ALICE);
uint256 rebased = staking.stake(AMOUNT, ALICE, false, false);
assertEq(ftso.balanceOf(ALICE), 0);
assertApproxEqAbs(staking.supplyInWarmup(), rebased, 1);
(uint256 deposit, uint256 payout, uint48 expiry, bool lock) = staking.warmupInfo(ALICE);
assertEq(ftso.balanceOf(ALICE), 0);
assertEq(staking.sharesInWarmup(), stnk.sharesForBalance(rebased));
(uint256 deposit, uint256 shares, uint48 expiry, bool lock) = staking.warmupInfo(ALICE);
assertEq(deposit, AMOUNT);
assertEq(payout, ghst.balanceTo(AMOUNT));
assertEq(shares, stnk.sharesForBalance(AMOUNT));
assertEq(expiry, 1);
assertEq(lock, false);
}
@ -181,11 +179,11 @@ contract StakingTest is Test {
uint256 rebased = staking.stake(AMOUNT, ALICE, false, true);
assertEq(ftso.balanceOf(ALICE), 0);
assertApproxEqAbs(staking.supplyInWarmup(), rebased, 1);
assertEq(staking.sharesInWarmup(), stnk.sharesForBalance(rebased));
(uint256 deposit, uint256 payout, uint48 expiry, bool lock) = staking.warmupInfo(ALICE);
(uint256 deposit, uint256 shares, uint48 expiry, bool lock) = staking.warmupInfo(ALICE);
assertEq(deposit, AMOUNT);
assertEq(payout, ghst.balanceTo(AMOUNT));
assertEq(shares, stnk.sharesForBalance(AMOUNT));
assertEq(expiry, 2);
assertEq(lock, false);
}
@ -250,7 +248,6 @@ contract StakingTest is Test {
assertEq(ghst.balanceOf(ALICE), 0);
vm.prank(BOB);
uint256 rebased = staking.claim(ALICE, false);
assertEq(ghst.balanceOf(ALICE), rebased);
assertEq(rebased > 0, true);
}
@ -281,11 +278,13 @@ contract StakingTest is Test {
_prepareAndRoll(ALICE, AMOUNT, false, false);
assertEq(ftso.balanceOf(ALICE), 0);
assertEq(staking.sharesInWarmup(), stnk.sharesForBalance(AMOUNT));
vm.prank(ALICE);
uint256 deposit = staking.forfeit();
assertEq(ftso.balanceOf(ALICE), deposit);
assertEq(staking.supplyInWarmup(), 0);
assertEq(staking.sharesInWarmup(), 0);
(uint256 depositInWarmup, uint256 shares, uint48 expiry,) = staking.warmupInfo(ALICE);
assertEq(depositInWarmup, 0);
@ -298,7 +297,7 @@ contract StakingTest is Test {
uint256 deposit = staking.forfeit();
assertEq(deposit, 0);
assertEq(ftso.balanceOf(ALICE), 0);
assertEq(staking.supplyInWarmup(), 0);
assertEq(staking.sharesInWarmup(), 0);
}
function test_unstake_canRedeemStinkyToFatso() public {

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

@ -150,7 +150,7 @@ contract StinkyTest is Test, ERC20PermitTest, ERC20AllowanceTest, ERC20TransferT
staking.stake(AMOUNT, ALICE, true, true);
vm.stopPrank();
assertApproxEqAbs(stnk.circulatingSupply(), AMOUNT, 1);
assertEq(stnk.circulatingSupply(), AMOUNT);
assertEq(ftso.totalSupply(), AMOUNT);
assertEq(stnk.totalSupply(), TOTAL_INITIAL_SUPPLY);
assertEq(stnk.balanceOf(address(staking)), TOTAL_INITIAL_SUPPLY);