diff --git a/src/LockstakeEngine.sol b/src/LockstakeEngine.sol index 66e3fece..fdddf8f1 100644 --- a/src/LockstakeEngine.sol +++ b/src/LockstakeEngine.sol @@ -78,8 +78,8 @@ contract LockstakeEngine { NstJoinLike immutable public nstJoin; GemLike immutable public nst; bytes32 immutable public ilk; - GemLike immutable public ngt; - GemLike immutable public stkNgt; + GemLike immutable public gov; + GemLike immutable public stkGov; uint256 immutable public fee; // --- events --- @@ -118,14 +118,14 @@ contract LockstakeEngine { // --- constructor --- - constructor(address delegateFactory_, address nstJoin_, bytes32 ilk_, address stkNgt_, uint256 fee_) { + constructor(address delegateFactory_, address nstJoin_, bytes32 ilk_, address stkGov_, uint256 fee_) { delegateFactory = DelegateFactoryLike(delegateFactory_); nstJoin = NstJoinLike(nstJoin_); vat = nstJoin.vat(); nst = nstJoin.nst(); ilk = ilk_; - ngt = delegateFactory.gov(); - stkNgt = GemLike(stkNgt_); + gov = delegateFactory.gov(); + stkGov = GemLike(stkGov_); fee = fee_; nst.approve(nstJoin_, type(uint256).max); vat.hope(nstJoin_); @@ -177,7 +177,7 @@ contract LockstakeEngine { uint256 index ) external view returns (address urn) { uint256 salt = uint256(keccak256(abi.encode(owner, index))); - bytes32 codeHash = keccak256(abi.encodePacked(type(LockstakeUrn).creationCode, abi.encode(vat, stkNgt))); + bytes32 codeHash = keccak256(abi.encodePacked(type(LockstakeUrn).creationCode, abi.encode(vat, stkGov))); urn = address(uint160(uint256( keccak256( abi.encodePacked(bytes1(0xff), address(this), salt, codeHash) @@ -190,7 +190,7 @@ contract LockstakeEngine { function open(address delegate) external returns (address urn) { require(delegateFactory.isDelegate(delegate) == 1, "LockstateEngine/not-valid-delegate"); uint256 salt = uint256(keccak256(abi.encode(msg.sender, urnsAmt[msg.sender]++))); - bytes memory code = abi.encodePacked(type(LockstakeUrn).creationCode, abi.encode(vat, stkNgt)); + bytes memory code = abi.encodePacked(type(LockstakeUrn).creationCode, abi.encode(vat, stkGov)); assembly { urn := create2(0, add(code, 0x20), mload(code), salt) } @@ -202,15 +202,15 @@ contract LockstakeEngine { function lock(address urn, uint256 wad) external urnOwner(urn) { require(wad <= uint256(type(int256).max), "LockstateEngine/wad-overflow"); - ngt.transferFrom(msg.sender, address(this), wad); + gov.transferFrom(msg.sender, address(this), wad); address delegate = urnDelegates[urn]; - ngt.approve(address(delegate), wad); + gov.approve(address(delegate), wad); DelegateLike(delegate).lock(wad); // TODO: define if we want an internal registry to register how much is locked per user, - // the vat.slip and stkNgt balance act already as a registry so probably not needed an extra one + // the vat.slip and stkGov balance act already as a registry so probably not needed an extra one vat.slip(ilk, urn, int256(wad)); vat.frob(ilk, urn, urn, address(0), int256(wad), 0); - stkNgt.mint(urn, wad); + stkGov.mint(urn, wad); emit Lock(urn, wad); } @@ -218,12 +218,12 @@ contract LockstakeEngine { require(wad <= uint256(type(int256).max), "LockstateEngine/wad-overflow"); vat.frob(ilk, urn, urn, address(0), -int256(wad), 0); vat.slip(ilk, urn, -int256(wad)); - stkNgt.burn(urn, wad); + stkGov.burn(urn, wad); address delegate = urnDelegates[urn]; DelegateLike(delegate).free(wad); uint256 burn = wad * fee / WAD; - ngt.burn(address(this), burn); - ngt.transfer(msg.sender, wad - burn); + gov.burn(address(this), burn); + gov.transfer(msg.sender, wad - burn); emit Free(urn, wad, burn); } @@ -233,7 +233,7 @@ contract LockstakeEngine { require(prevDelegate != delegate, "LockstateEngine/same-delegate"); (uint256 wad,) = vat.urns(ilk, urn); DelegateLike(prevDelegate).free(wad); - ngt.approve(address(delegate), wad); + gov.approve(address(delegate), wad); DelegateLike(delegate).lock(wad); urnDelegates[urn] = delegate; emit Move(urn, delegate); @@ -294,19 +294,19 @@ contract LockstakeEngine { function onKick(address urn, uint256 wad) external auth { address selectedFarmUrn = selectedFarm[urn]; if (selectedFarmUrn != address(0)){ - uint256 freed = GemLike(stkNgt).balanceOf(address(urn)); + uint256 freed = GemLike(stkGov).balanceOf(address(urn)); if (wad > freed) { LockstakeUrn(urn).withdraw(selectedFarmUrn, wad - freed); } } - stkNgt.burn(urn, wad); // Burn the whole liquidated amount of staking token - DelegateLike(urnDelegates[urn]).free(wad); // Undelegate liquidated amount and retain NGT + stkGov.burn(urn, wad); // Burn the whole liquidated amount of staking token + DelegateLike(urnDelegates[urn]).free(wad); // Undelegate liquidated amount and retain GOV // Urn confiscation happens in Dog contract where ilk vat.gem is sent to the LockstakeClipper emit OnKick(urn, wad); } function onTake(address urn, address who, uint256 wad) external auth { - ngt.transfer(who, wad); // Free NGT to the auction buyer + gov.transfer(who, wad); // Free GOV to the auction buyer emit OnTake(urn, who, wad); } @@ -318,20 +318,20 @@ contract LockstakeEngine { } else { unchecked { left = left - burn; } } - ngt.burn(address(this), burn); // Burn NGT + gov.burn(address(this), burn); // Burn GOV if (left > 0) { address delegate = urnDelegates[urn]; - ngt.approve(address(delegate), left); + gov.approve(address(delegate), left); DelegateLike(delegate).lock(left); vat.slip(ilk, urn, int256(left)); vat.frob(ilk, urn, urn, address(0), int256(left), 0); - stkNgt.mint(urn, left); + stkGov.mint(urn, left); } emit OnTakeLeftovers(urn, tot, left, burn); } function onYank(address urn, uint256 wad) external auth { - ngt.burn(address(this), wad); + gov.burn(address(this), wad); emit OnYank(urn, wad); } } diff --git a/src/LockstakeUrn.sol b/src/LockstakeUrn.sol index b0e88916..b579eb15 100644 --- a/src/LockstakeUrn.sol +++ b/src/LockstakeUrn.sol @@ -37,7 +37,7 @@ contract LockstakeUrn { // --- immutables --- address immutable public engine; - GemLike immutable public stkNgt; + GemLike immutable public stkGov; // --- modifiers --- @@ -48,17 +48,17 @@ contract LockstakeUrn { // --- constructor --- - constructor(address vat_, address stkNgt_) { + constructor(address vat_, address stkGov_) { engine = msg.sender; - stkNgt = GemLike(stkNgt_); + stkGov = GemLike(stkGov_); VatLike(vat_).hope(msg.sender); - stkNgt.approve(msg.sender, type(uint256).max); + stkGov.approve(msg.sender, type(uint256).max); } // --- staking functions --- function stake(address farm, uint256 wad, uint16 ref) external isEngine { - stkNgt.approve(farm, wad); + stkGov.approve(farm, wad); StakingRewardsLike(farm).stake(wad, ref); } diff --git a/test/LockstakeEngine.t.sol b/test/LockstakeEngine.t.sol index e37335b0..33a41834 100644 --- a/test/LockstakeEngine.t.sol +++ b/test/LockstakeEngine.t.sol @@ -61,7 +61,7 @@ contract AllocatorVaultTest is DssTest { address public vat; address public spot; address public dog; - GemMock public ngt; + GemMock public gov; address public jug; LockstakeEngine public engine; LockstakeClipper public clip; @@ -69,7 +69,7 @@ contract AllocatorVaultTest is DssTest { DelegateFactoryMock public delFactory; NstMock public nst; NstJoinMock public nstJoin; - GemMock public stkNgt; + GemMock public stkGov; GemMock public rTok; StakingRewardsMock public farm; bytes32 public ilk = "LSE"; @@ -107,21 +107,21 @@ contract AllocatorVaultTest is DssTest { vat = ChainlogLike(LOG).getAddress("MCD_VAT"); spot = ChainlogLike(LOG).getAddress("MCD_SPOT"); dog = ChainlogLike(LOG).getAddress("MCD_DOG"); - ngt = GemMock(ChainlogLike(LOG).getAddress("MCD_GOV")); + gov = GemMock(ChainlogLike(LOG).getAddress("MCD_GOV")); jug = ChainlogLike(LOG).getAddress("MCD_JUG"); nst = new NstMock(); nstJoin = new NstJoinMock(vat, address(nst)); - stkNgt = new GemMock(0); + stkGov = new GemMock(0); rTok = new GemMock(0); - farm = new StakingRewardsMock(address(rTok), address(stkNgt)); + farm = new StakingRewardsMock(address(rTok), address(stkGov)); pip = new PipMock(); - delFactory = new DelegateFactoryMock(address(ngt)); + delFactory = new DelegateFactoryMock(address(gov)); voter = address(123); vm.prank(voter); voterDelegate = delFactory.create(); vm.startPrank(pauseProxy); - engine = new LockstakeEngine(address(delFactory), address(nstJoin), ilk, address(stkNgt), 15 * WAD / 100); + engine = new LockstakeEngine(address(delFactory), address(nstJoin), ilk, address(stkGov), 15 * WAD / 100); engine.file("jug", jug); VatLike(vat).rely(address(engine)); VatLike(vat).init(ilk); @@ -129,12 +129,12 @@ contract AllocatorVaultTest is DssTest { JugLike(jug).file(ilk, "duty", 1001 * 10**27 / 1000); SpotterLike(spot).file(ilk, "pip", address(pip)); SpotterLike(spot).file(ilk, "mat", 3 * 10**27); // 300% coll ratio - pip.setPrice(0.1 * 10**18); // 1 NGT = 0.1 USD + pip.setPrice(0.1 * 10**18); // 1 GOV = 0.1 USD SpotterLike(spot).poke(ilk); VatLike(vat).file(ilk, "line", 1_000_000 * 10**45); vm.stopPrank(); - deal(address(ngt), address(this), 100_000 * 10**18, true); + deal(address(gov), address(this), 100_000 * 10**18, true); // Add some existing DAI assigned to nstJoin to avoid a particular error stdstore.target(address(vat)).sig("dai(address)").with_key(address(nstJoin)).depth(0).checked_write(100_000 * RAD); @@ -214,48 +214,48 @@ contract AllocatorVaultTest is DssTest { } function testLockFree() public { - uint256 initialSupply = ngt.totalSupply(); - assertEq(ngt.balanceOf(address(this)), 100_000 * 10**18); + uint256 initialSupply = gov.totalSupply(); + assertEq(gov.balanceOf(address(this)), 100_000 * 10**18); address urn = engine.open(voterDelegate); assertEq(_ink(ilk, urn), 0); - assertEq(stkNgt.balanceOf(urn), 0); - ngt.approve(address(engine), 100_000 * 10**18); + assertEq(stkGov.balanceOf(urn), 0); + gov.approve(address(engine), 100_000 * 10**18); vm.expectEmit(true, true, true, true); emit Lock(urn, 100_000 * 10**18); engine.lock(urn, 100_000 * 10**18); assertEq(_ink(ilk, urn), 100_000 * 10**18); - assertEq(stkNgt.balanceOf(urn), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(this)), 0); - assertEq(ngt.totalSupply(), initialSupply); + assertEq(stkGov.balanceOf(urn), 100_000 * 10**18); + assertEq(gov.balanceOf(address(this)), 0); + assertEq(gov.totalSupply(), initialSupply); vm.expectEmit(true, true, true, true); emit Free(urn, 40_000 * 10**18, 40_000 * 10**18 * 15 / 100); engine.free(urn, 40_000 * 10**18); assertEq(_ink(ilk, urn), 60_000 * 10**18); - assertEq(stkNgt.balanceOf(urn), 60_000 * 10**18); - assertEq(ngt.balanceOf(address(this)), 40_000 * 10**18 - 40_000 * 10**18 * 15 / 100); - assertEq(ngt.totalSupply(), initialSupply - 40_000 * 10**18 * 15 / 100); + assertEq(stkGov.balanceOf(urn), 60_000 * 10**18); + assertEq(gov.balanceOf(address(this)), 40_000 * 10**18 - 40_000 * 10**18 * 15 / 100); + assertEq(gov.totalSupply(), initialSupply - 40_000 * 10**18 * 15 / 100); } function testMove() public { address urn = engine.open(voterDelegate); vm.prank(address(888)); address voterDelegate2 = delFactory.create(); - ngt.approve(address(engine), 100_000 * 10**18); + gov.approve(address(engine), 100_000 * 10**18); engine.lock(urn, 100_000 * 10**18); assertEq(DelegateMock(voterDelegate).stake(address(engine)), 100_000 * 10**18); assertEq(DelegateMock(voterDelegate2).stake(address(engine)), 0); - assertEq(ngt.balanceOf(voterDelegate), 100_000 * 10**18); - assertEq(ngt.balanceOf(voterDelegate2), 0); + assertEq(gov.balanceOf(voterDelegate), 100_000 * 10**18); + assertEq(gov.balanceOf(voterDelegate2), 0); engine.move(urn, voterDelegate2); assertEq(DelegateMock(voterDelegate).stake(address(engine)), 0); assertEq(DelegateMock(voterDelegate2).stake(address(engine)), 100_000 * 10**18); - assertEq(ngt.balanceOf(voterDelegate), 0); - assertEq(ngt.balanceOf(voterDelegate2), 100_000 * 10**18); + assertEq(gov.balanceOf(voterDelegate), 0); + assertEq(gov.balanceOf(voterDelegate2), 100_000 * 10**18); } function testDrawWipe() public { - deal(address(ngt), address(this), 100_000 * 10**18, true); + deal(address(gov), address(this), 100_000 * 10**18, true); address urn = engine.open(voterDelegate); - ngt.approve(address(engine), 100_000 * 10**18); + gov.approve(address(engine), 100_000 * 10**18); engine.lock(urn, 100_000 * 10**18); assertEq(_art(ilk, urn), 0); vm.expectEmit(true, true, true, true); @@ -291,7 +291,7 @@ contract AllocatorVaultTest is DssTest { } function testSelectFarm() public { - StakingRewardsMock farm2 = new StakingRewardsMock(address(rTok), address(stkNgt)); + StakingRewardsMock farm2 = new StakingRewardsMock(address(rTok), address(stkGov)); address urn = engine.open(voterDelegate); assertEq(engine.selectedFarm(urn), address(0)); vm.expectRevert("LockstakeEngine/non-existing-farm"); @@ -304,7 +304,7 @@ contract AllocatorVaultTest is DssTest { vm.prank(pauseProxy); engine.addFarm(address(farm2)); engine.selectFarm(urn, address(farm2)); assertEq(engine.selectedFarm(urn), address(farm2)); - ngt.approve(address(engine), 100_000 * 10**18); + gov.approve(address(engine), 100_000 * 10**18); engine.lock(urn, 100_000 * 10**18); engine.stake(urn, 100_000, 1); vm.expectRevert("LockstakeEngine/withdraw-first"); @@ -316,27 +316,27 @@ contract AllocatorVaultTest is DssTest { function testStakeWithdraw() public { vm.prank(pauseProxy); engine.addFarm(address(farm)); address urn = engine.open(voterDelegate); - ngt.approve(address(engine), 100_000 * 10**18); + gov.approve(address(engine), 100_000 * 10**18); engine.lock(urn, 100_000 * 10**18); vm.expectRevert("LockstakeEngine/missing-selected-farm"); engine.stake(urn, 100_000, 1); vm.expectRevert("LockstakeEngine/missing-selected-farm"); engine.withdraw(urn, 0); engine.selectFarm(urn, address(farm)); - assertEq(stkNgt.balanceOf(address(urn)), 100_000 * 10**18); - assertEq(stkNgt.balanceOf(address(farm)), 0); + assertEq(stkGov.balanceOf(address(urn)), 100_000 * 10**18); + assertEq(stkGov.balanceOf(address(farm)), 0); assertEq(farm.balanceOf(address(urn)), 0); vm.expectEmit(true, true, true, true); emit Stake(urn, address(farm), 60_000 * 10**18, 1); engine.stake(urn, 60_000 * 10**18, 1); - assertEq(stkNgt.balanceOf(address(urn)), 40_000 * 10**18); - assertEq(stkNgt.balanceOf(address(farm)), 60_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 40_000 * 10**18); + assertEq(stkGov.balanceOf(address(farm)), 60_000 * 10**18); assertEq(farm.balanceOf(address(urn)), 60_000 * 10**18); vm.expectEmit(true, true, true, true); emit Withdraw(urn, address(farm), 15_000 * 10**18); engine.withdraw(urn, 15_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 55_000 * 10**18); - assertEq(stkNgt.balanceOf(address(farm)), 45_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 55_000 * 10**18); + assertEq(stkGov.balanceOf(address(farm)), 45_000 * 10**18); assertEq(farm.balanceOf(address(urn)), 45_000 * 10**18); } @@ -374,7 +374,7 @@ contract AllocatorVaultTest is DssTest { vm.stopPrank(); urn = engine.open(voterDelegate); - ngt.approve(address(engine), 100_000 * 10**18); + gov.approve(address(engine), 100_000 * 10**18); engine.lock(urn, 100_000 * 10**18); engine.draw(urn, 2_000 * 10**18); assertEq(_ink(ilk, urn), 100_000 * 10**18); @@ -392,10 +392,10 @@ contract AllocatorVaultTest is DssTest { function testOnKickFullNoStaked() public { address urn = _clipperSetUp(); - assertEq(ngt.balanceOf(address(voterDelegate)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(engine)), 0); - assertEq(stkNgt.balanceOf(address(urn)), 100_000 * 10**18); - uint256 stkNgtInitialSupply = stkNgt.totalSupply(); + assertEq(gov.balanceOf(address(voterDelegate)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(engine)), 0); + assertEq(stkGov.balanceOf(address(urn)), 100_000 * 10**18); + uint256 stkGovInitialSupply = stkGov.totalSupply(); uint256 id = _forceLiquidation(urn); @@ -413,10 +413,10 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 0); assertEq(VatLike(vat).gem(ilk, address(clip)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 0); - assertEq(ngt.balanceOf(address(engine)), 100_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 0); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 0); + assertEq(gov.balanceOf(address(engine)), 100_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 0); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 100_000 * 10**18); } function testOnKickPartialNoStaked() public { @@ -424,7 +424,7 @@ contract AllocatorVaultTest is DssTest { vm.prank(pauseProxy); DogLike(dog).file(ilk, "hole", 500 * 10**45); - uint256 stkNgtInitialSupply = stkNgt.totalSupply(); + uint256 stkGovInitialSupply = stkGov.totalSupply(); uint256 id = _forceLiquidation(urn); @@ -442,10 +442,10 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 1_500 * 10**18); assertEq(VatLike(vat).gem(ilk, address(clip)), 25_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 75_000 * 10**18); - assertEq(ngt.balanceOf(address(engine)), 25_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 75_000 * 10**18); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 25_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 75_000 * 10**18); + assertEq(gov.balanceOf(address(engine)), 25_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 75_000 * 10**18); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 25_000 * 10**18); } function testOnKickFullStakedPartial() public { @@ -453,14 +453,14 @@ contract AllocatorVaultTest is DssTest { engine.selectFarm(urn, address(farm)); engine.stake(urn, 60_000 * 10**18, 1); - assertEq(stkNgt.balanceOf(address(urn)), 40_000 * 10**18); - assertEq(stkNgt.balanceOf(address(farm)), 60_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 40_000 * 10**18); + assertEq(stkGov.balanceOf(address(farm)), 60_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(engine)), 0); - assertEq(stkNgt.balanceOf(address(urn)), 40_000 * 10**18); - assertEq(stkNgt.balanceOf(address(farm)), 60_000 * 10**18); - uint256 stkNgtInitialSupply = stkNgt.totalSupply(); + assertEq(gov.balanceOf(address(voterDelegate)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(engine)), 0); + assertEq(stkGov.balanceOf(address(urn)), 40_000 * 10**18); + assertEq(stkGov.balanceOf(address(farm)), 60_000 * 10**18); + uint256 stkGovInitialSupply = stkGov.totalSupply(); uint256 id = _forceLiquidation(urn); @@ -478,11 +478,11 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 0); assertEq(VatLike(vat).gem(ilk, address(clip)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 0); - assertEq(ngt.balanceOf(address(engine)), 100_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 0); - assertEq(stkNgt.balanceOf(address(farm)), 0); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 0); + assertEq(gov.balanceOf(address(engine)), 100_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 0); + assertEq(stkGov.balanceOf(address(farm)), 0); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 100_000 * 10**18); } function testOnKickPartialStakedPartialNoWithdraw() public { @@ -490,12 +490,12 @@ contract AllocatorVaultTest is DssTest { engine.selectFarm(urn, address(farm)); engine.stake(urn, 60_000 * 10**18, 1); - assertEq(stkNgt.balanceOf(address(urn)), 40_000 * 10**18); - assertEq(stkNgt.balanceOf(address(farm)), 60_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 40_000 * 10**18); + assertEq(stkGov.balanceOf(address(farm)), 60_000 * 10**18); vm.prank(pauseProxy); DogLike(dog).file(ilk, "hole", 500 * 10**45); - uint256 stkNgtInitialSupply = stkNgt.totalSupply(); + uint256 stkGovInitialSupply = stkGov.totalSupply(); uint256 id = _forceLiquidation(urn); @@ -513,11 +513,11 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 1_500 * 10**18); assertEq(VatLike(vat).gem(ilk, address(clip)), 25_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 75_000 * 10**18); - assertEq(ngt.balanceOf(address(engine)), 25_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 15_000 * 10**18); - assertEq(stkNgt.balanceOf(address(farm)), 60_000 * 10**18); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 25_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 75_000 * 10**18); + assertEq(gov.balanceOf(address(engine)), 25_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 15_000 * 10**18); + assertEq(stkGov.balanceOf(address(farm)), 60_000 * 10**18); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 25_000 * 10**18); } function testOnKickPartialStakedPartialWithdraw() public { @@ -525,12 +525,12 @@ contract AllocatorVaultTest is DssTest { engine.selectFarm(urn, address(farm)); engine.stake(urn, 80_000 * 10**18, 1); - assertEq(stkNgt.balanceOf(address(urn)), 20_000 * 10**18); - assertEq(stkNgt.balanceOf(address(farm)), 80_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 20_000 * 10**18); + assertEq(stkGov.balanceOf(address(farm)), 80_000 * 10**18); vm.prank(pauseProxy); DogLike(dog).file(ilk, "hole", 500 * 10**45); - uint256 stkNgtInitialSupply = stkNgt.totalSupply(); + uint256 stkGovInitialSupply = stkGov.totalSupply(); uint256 id = _forceLiquidation(urn); @@ -548,22 +548,22 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 1_500 * 10**18); assertEq(VatLike(vat).gem(ilk, address(clip)), 25_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 75_000 * 10**18); - assertEq(ngt.balanceOf(address(engine)), 25_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 0); - assertEq(stkNgt.balanceOf(address(farm)), 75_000 * 10**18); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 25_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 75_000 * 10**18); + assertEq(gov.balanceOf(address(engine)), 25_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 0); + assertEq(stkGov.balanceOf(address(farm)), 75_000 * 10**18); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 25_000 * 10**18); } function testOnTake() public { address urn = _clipperSetUp(); - assertEq(ngt.balanceOf(address(voterDelegate)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(engine)), 0); - assertEq(stkNgt.balanceOf(address(urn)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(engine)), 0); + assertEq(stkGov.balanceOf(address(urn)), 100_000 * 10**18); - uint256 ngtInitialSupply = ngt.totalSupply(); - uint256 stkNgtInitialSupply = stkNgt.totalSupply(); + uint256 govInitialSupply = gov.totalSupply(); + uint256 stkGovInitialSupply = stkGov.totalSupply(); address vow = address(ChainlogLike(LOG).getAddress("MCD_VOW")); uint256 vowInitialBalance = VatLike(vat).dai(vow); @@ -583,17 +583,17 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 0); assertEq(VatLike(vat).gem(ilk, address(clip)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 0); - assertEq(ngt.balanceOf(address(engine)), 100_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 0); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 0); + assertEq(gov.balanceOf(address(engine)), 100_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 0); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 100_000 * 10**18); address buyer = address(888); vm.prank(pauseProxy); VatLike(vat).suck(address(0), buyer, 2_000 * 10**45); vm.prank(buyer); VatLike(vat).hope(address(clip)); - assertEq(ngt.balanceOf(buyer), 0); + assertEq(gov.balanceOf(buyer), 0); vm.prank(buyer); clip.take(id, 20_000 * 10**18, type(uint256).max, buyer, ""); - assertEq(ngt.balanceOf(buyer), 20_000 * 10**18); + assertEq(gov.balanceOf(buyer), 20_000 * 10**18); (sale.pos, sale.tab, sale.lot, sale.tot, sale.usr, sale.tic, sale.top) = clip.sales(id); assertEq(sale.pos, 0); @@ -608,13 +608,13 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 0); assertEq(VatLike(vat).gem(ilk, address(clip)), 80_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 0); - assertEq(ngt.balanceOf(address(engine)), 80_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 0); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 0); + assertEq(gov.balanceOf(address(engine)), 80_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 0); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 100_000 * 10**18); vm.prank(buyer); clip.take(id, 12_000 * 10**18, type(uint256).max, buyer, ""); - assertEq(ngt.balanceOf(buyer), 32_000 * 10**18); + assertEq(gov.balanceOf(buyer), 32_000 * 10**18); (sale.pos, sale.tab, sale.lot, sale.tot, sale.usr, sale.tic, sale.top) = clip.sales(id); assertEq(sale.pos, 0); @@ -629,23 +629,23 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 0); assertEq(VatLike(vat).gem(ilk, address(clip)), 0); - assertEq(ngt.balanceOf(address(voterDelegate)), (100_000 - 32_000 * 1.15) * 10**18); - assertEq(ngt.balanceOf(address(engine)), 0); - assertEq(ngt.totalSupply(), ngtInitialSupply - 32_000 * 0.15 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), (100_000 - 32_000 * 1.15) * 10**18); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 32_000 * 1.15 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), (100_000 - 32_000 * 1.15) * 10**18); + assertEq(gov.balanceOf(address(engine)), 0); + assertEq(gov.totalSupply(), govInitialSupply - 32_000 * 0.15 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), (100_000 - 32_000 * 1.15) * 10**18); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 32_000 * 1.15 * 10**18); assertEq(VatLike(vat).dai(vow), vowInitialBalance + 2_000 * 10**45); } function testOnTakePartialBurn() public { address urn = _clipperSetUp(); - assertEq(ngt.balanceOf(address(voterDelegate)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(engine)), 0); - assertEq(stkNgt.balanceOf(address(urn)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(engine)), 0); + assertEq(stkGov.balanceOf(address(urn)), 100_000 * 10**18); - uint256 ngtInitialSupply = ngt.totalSupply(); - uint256 stkNgtInitialSupply = stkNgt.totalSupply(); + uint256 govInitialSupply = gov.totalSupply(); + uint256 stkGovInitialSupply = stkGov.totalSupply(); address vow = address(ChainlogLike(LOG).getAddress("MCD_VOW")); uint256 vowInitialBalance = VatLike(vat).dai(vow); @@ -665,41 +665,41 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 0); assertEq(VatLike(vat).gem(ilk, address(clip)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 0); - assertEq(ngt.balanceOf(address(engine)), 100_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 0); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 0); + assertEq(gov.balanceOf(address(engine)), 100_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 0); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 100_000 * 10**18); vm.warp(block.timestamp + 65); // Time passes to let the auction price to crash address buyer = address(888); vm.prank(pauseProxy); VatLike(vat).suck(address(0), buyer, 2_000 * 10**45); vm.prank(buyer); VatLike(vat).hope(address(clip)); - assertEq(ngt.balanceOf(buyer), 0); + assertEq(gov.balanceOf(buyer), 0); vm.prank(buyer); clip.take(id, 100_000 * 10**18, type(uint256).max, buyer, ""); - assertEq(ngt.balanceOf(buyer), 91428571428571428571428); + assertEq(gov.balanceOf(buyer), 91428571428571428571428); assertEq(_ink(ilk, urn), 0); assertEq(_art(ilk, urn), 0); assertEq(VatLike(vat).gem(ilk, address(clip)), 0); - assertEq(ngt.balanceOf(address(voterDelegate)), 0); - assertEq(ngt.balanceOf(address(engine)), 0); - assertEq(ngt.totalSupply(), ngtInitialSupply - (100_000 * 10**18 - 91428571428571428571428)); // Can't burn 15% of 91428571428571428571428 - assertEq(stkNgt.balanceOf(address(urn)), 0); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 0); + assertEq(gov.balanceOf(address(engine)), 0); + assertEq(gov.totalSupply(), govInitialSupply - (100_000 * 10**18 - 91428571428571428571428)); // Can't burn 15% of 91428571428571428571428 + assertEq(stkGov.balanceOf(address(urn)), 0); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 100_000 * 10**18); assertEq(VatLike(vat).dai(vow), vowInitialBalance + 2_000 * 10**45); } function testOnTakeNoBurn() public { address urn = _clipperSetUp(); - assertEq(ngt.balanceOf(address(voterDelegate)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(engine)), 0); - assertEq(stkNgt.balanceOf(address(urn)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(engine)), 0); + assertEq(stkGov.balanceOf(address(urn)), 100_000 * 10**18); - uint256 ngtInitialSupply = ngt.totalSupply(); - uint256 stkNgtInitialSupply = stkNgt.totalSupply(); + uint256 govInitialSupply = gov.totalSupply(); + uint256 stkGovInitialSupply = stkGov.totalSupply(); address vow = address(ChainlogLike(LOG).getAddress("MCD_VOW")); uint256 vowInitialBalance = VatLike(vat).dai(vow); @@ -719,40 +719,40 @@ contract AllocatorVaultTest is DssTest { assertEq(_art(ilk, urn), 0); assertEq(VatLike(vat).gem(ilk, address(clip)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(voterDelegate)), 0); - assertEq(ngt.balanceOf(address(engine)), 100_000 * 10**18); - assertEq(stkNgt.balanceOf(address(urn)), 0); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 0); + assertEq(gov.balanceOf(address(engine)), 100_000 * 10**18); + assertEq(stkGov.balanceOf(address(urn)), 0); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 100_000 * 10**18); vm.warp(block.timestamp + 80); // Time passes to let the auction price to crash address buyer = address(888); vm.prank(pauseProxy); VatLike(vat).suck(address(0), buyer, 2_000 * 10**45); vm.prank(buyer); VatLike(vat).hope(address(clip)); - assertEq(ngt.balanceOf(buyer), 0); + assertEq(gov.balanceOf(buyer), 0); vm.prank(buyer); clip.take(id, 100_000 * 10**18, type(uint256).max, buyer, ""); - assertEq(ngt.balanceOf(buyer), 100_000 * 10**18); + assertEq(gov.balanceOf(buyer), 100_000 * 10**18); assertEq(_ink(ilk, urn), 0); assertEq(_art(ilk, urn), 0); assertEq(VatLike(vat).gem(ilk, address(clip)), 0); - assertEq(ngt.balanceOf(address(voterDelegate)), 0); - assertEq(ngt.balanceOf(address(engine)), 0); - assertEq(ngt.totalSupply(), ngtInitialSupply); // Can't burn anything - assertEq(stkNgt.balanceOf(address(urn)), 0); - assertEq(stkNgt.totalSupply(), stkNgtInitialSupply - 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 0); + assertEq(gov.balanceOf(address(engine)), 0); + assertEq(gov.totalSupply(), govInitialSupply); // Can't burn anything + assertEq(stkGov.balanceOf(address(urn)), 0); + assertEq(stkGov.totalSupply(), stkGovInitialSupply - 100_000 * 10**18); assertLt(VatLike(vat).dai(vow), vowInitialBalance + 2_000 * 10**45); // Doesn't recover full debt } function testOnYank() public { address urn = _clipperSetUp(); - assertEq(ngt.balanceOf(address(voterDelegate)), 100_000 * 10**18); - assertEq(ngt.balanceOf(address(engine)), 0); - assertEq(stkNgt.balanceOf(address(urn)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(voterDelegate)), 100_000 * 10**18); + assertEq(gov.balanceOf(address(engine)), 0); + assertEq(stkGov.balanceOf(address(urn)), 100_000 * 10**18); - uint256 ngtInitialSupply = ngt.totalSupply(); + uint256 govInitialSupply = gov.totalSupply(); uint256 id = _forceLiquidation(urn); @@ -777,6 +777,6 @@ contract AllocatorVaultTest is DssTest { assertEq(sale.tic, 0); assertEq(sale.top, 0); - assertEq(ngt.totalSupply(), ngtInitialSupply - 100_000 * 10**18); + assertEq(gov.totalSupply(), govInitialSupply - 100_000 * 10**18); } } diff --git a/test/mocks/DelegateMock.sol b/test/mocks/DelegateMock.sol index 2a995c6a..f63a615b 100644 --- a/test/mocks/DelegateMock.sol +++ b/test/mocks/DelegateMock.sol @@ -31,7 +31,7 @@ contract DelegateMock { gov = GemLike(gov_); } - // --- NGT owner functions + // --- GOV owner functions function lock(uint256 wad) external { gov.transferFrom(msg.sender, address(this), wad);