From 4ac3de6912cfc6c3c7037b4c9920c1dc5772cc83 Mon Sep 17 00:00:00 2001 From: mihailo-maksa Date: Thu, 23 May 2024 19:16:00 +0200 Subject: [PATCH 1/3] update asset and share solvency for triples, add triple lifecylce invariant assertions --- .../EthMultiVaultBasicInvariant.t.sol | 15 +- .../EthMultiVaultSingleVaultInvariant.t.sol | 13 +- test/invariant/InvariantEthMultiVaultBase.sol | 20 ++ test/invariant/actors/EthMultiVaultActor.sol | 240 +++++++++++++++++- .../actors/EthMultiVaultSingleVaultActor.sol | 130 +++++++++- 5 files changed, 403 insertions(+), 15 deletions(-) diff --git a/test/invariant/EthMultiVaultBasicInvariant.t.sol b/test/invariant/EthMultiVaultBasicInvariant.t.sol index a717a6d9..c79e70ec 100644 --- a/test/invariant/EthMultiVaultBasicInvariant.t.sol +++ b/test/invariant/EthMultiVaultBasicInvariant.t.sol @@ -24,10 +24,13 @@ contract EthMultiVaultBasicInvariantTest is InvariantEthMultiVaultBase { targetContract(address(actor)); // selectors for actor functions - bytes4[] memory selectors = new bytes4[](3); + bytes4[] memory selectors = new bytes4[](6); selectors[0] = actor.createAtom.selector; // createAtom selectors[1] = actor.depositAtom.selector; // depositAtom selectors[2] = actor.redeemAtom.selector; // redeemAtom + selectors[3] = actor.createTriple.selector; // createTriple + selectors[4] = actor.depositTriple.selector; // depositTriple + selectors[5] = actor.redeemTriple.selector; // redeemTriple FuzzSelector memory fuzzSelector = FuzzSelector({addr: address(actor), selectors: selectors}); @@ -39,11 +42,15 @@ contract EthMultiVaultBasicInvariantTest is InvariantEthMultiVaultBase { // assets less than or equal to eth balance invariant_ethMultiVault_asset_solvency(); // shares less than or equal to assets - //invariant_ethMultiVault_share_solvency(); + invariant_ethMultiVault_share_solvency(); + emit log_named_uint("actor.numberOfCalls()---", actor.numberOfCalls()); emit log_named_uint("actor.numberOfAtoms()---", actor.numberOfAtoms()); - emit log_named_uint("actor.numberOfDeposits()", actor.numberOfDeposits()); - emit log_named_uint("actor.numberOfRedeems()-", actor.numberOfRedeems()); + emit log_named_uint("actor.numberOfAtomDeposits()", actor.numberOfAtomDeposits()); + emit log_named_uint("actor.numberOfAtomRedeems()-", actor.numberOfAtomRedeems()); + emit log_named_uint("actor.numberOfTriples()---", actor.numberOfTriples()); + emit log_named_uint("actor.numberOfTripleDeposits()", actor.numberOfTripleDeposits()); + emit log_named_uint("actor.numberOfTripleRedeems()", actor.numberOfTripleRedeems()); emit log_named_uint("ETHMULTIVAULT ETH BALANCE---", address(ethMultiVault).balance); } } diff --git a/test/invariant/EthMultiVaultSingleVaultInvariant.t.sol b/test/invariant/EthMultiVaultSingleVaultInvariant.t.sol index 443f7b14..c8e8516e 100644 --- a/test/invariant/EthMultiVaultSingleVaultInvariant.t.sol +++ b/test/invariant/EthMultiVaultSingleVaultInvariant.t.sol @@ -27,9 +27,11 @@ contract EthMultiVaultSingleVaultInvariantTest is InvariantEthMultiVaultBase { targetContract(address(actor)); // selectors for actor functions - bytes4[] memory selectors = new bytes4[](2); + bytes4[] memory selectors = new bytes4[](4); selectors[0] = actor.depositAtom.selector; // depositAtom selectors[1] = actor.redeemAtom.selector; // redeemAtom + selectors[2] = actor.depositTriple.selector; // depositTriple + selectors[3] = actor.redeemTriple.selector; // redeemTriple FuzzSelector memory fuzzSelector = FuzzSelector({addr: address(actor), selectors: selectors}); @@ -40,9 +42,14 @@ contract EthMultiVaultSingleVaultInvariantTest is InvariantEthMultiVaultBase { function invariant_ethMultiVault_single() external { // assets less than or equal to eth balance invariant_ethMultiVault_asset_solvency(); + // shares less than or equal to assets + invariant_ethMultiVault_share_solvency(); + emit log_named_uint("actor.numberOfCalls()---", actor.numberOfCalls()); - emit log_named_uint("actor.numberOfDeposits()", actor.numberOfDeposits()); - emit log_named_uint("actor.numberOfRedeems()-", actor.numberOfRedeems()); + emit log_named_uint("actor.numberOfAtomDeposits()", actor.numberOfAtomDeposits()); + emit log_named_uint("actor.numberOfAtomRedeems()-", actor.numberOfAtomRedeems()); + emit log_named_uint("actor.numberOfTripleDeposits()", actor.numberOfTripleDeposits()); + emit log_named_uint("actor.numberOfTripleRedeems()", actor.numberOfTripleRedeems()); emit log_named_uint("EthMultiVAULT ETH BALANCE---", address(ethMultiVault).balance); } } diff --git a/test/invariant/InvariantEthMultiVaultBase.sol b/test/invariant/InvariantEthMultiVaultBase.sol index fbdebe72..2f0ff270 100644 --- a/test/invariant/InvariantEthMultiVaultBase.sol +++ b/test/invariant/InvariantEthMultiVaultBase.sol @@ -18,6 +18,18 @@ contract InvariantEthMultiVaultBase is EthMultiVaultBase { for (uint256 i = 1; i <= ethMultiVault.count(); i++) { totalAssetsAcrossAllVaults += super.vaultTotalAssets(i); } + + uint256 totalAssetsAcrossAllCounterTripleVaults; + uint256 counterTripleId = type(uint256).max - 1; + for (uint256 i = 1; i <= ethMultiVault.count(); i++) { + if (ethMultiVault.isTripleId(i)) { + totalAssetsAcrossAllCounterTripleVaults += super.vaultTotalAssets(counterTripleId); + counterTripleId--; + } + } + + totalAssetsAcrossAllVaults += totalAssetsAcrossAllCounterTripleVaults; + assertLe(totalAssetsAcrossAllVaults, address(ethMultiVault).balance); } @@ -25,5 +37,13 @@ contract InvariantEthMultiVaultBase is EthMultiVaultBase { for (uint256 i = 1; i <= ethMultiVault.count(); i++) { assertLe(super.vaultTotalShares(i), super.vaultTotalAssets(i)); } + + uint256 counterTripleId = type(uint256).max; + for (uint256 i = 1; i <= ethMultiVault.count(); i++) { + if (ethMultiVault.isTripleId(i)) { + assertLe(super.vaultTotalShares(counterTripleId), super.vaultTotalAssets(counterTripleId)); + counterTripleId--; + } + } } } diff --git a/test/invariant/actors/EthMultiVaultActor.sol b/test/invariant/actors/EthMultiVaultActor.sol index 1a18d52c..54f03645 100644 --- a/test/invariant/actors/EthMultiVaultActor.sol +++ b/test/invariant/actors/EthMultiVaultActor.sol @@ -18,8 +18,11 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { // ghost variables uint256 public numberOfCalls; uint256 public numberOfAtoms; - uint256 public numberOfDeposits; - uint256 public numberOfRedeems; + uint256 public numberOfAtomDeposits; + uint256 public numberOfAtomRedeems; + uint256 public numberOfTriples; + uint256 public numberOfTripleDeposits; + uint256 public numberOfTripleRedeems; modifier useActor(uint256 actorIndexSeed) { currentActor = actors[bound(actorIndexSeed, 0, actors.length - 1)]; @@ -124,7 +127,7 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { uint256 actorIndexSeed ) public useActor(actorIndexSeed) returns (uint256) { numberOfCalls++; - numberOfDeposits++; + numberOfAtomDeposits++; emit log_named_uint( "==================================== ACTOR depositAtom ====================================", 6000000009 ); @@ -210,7 +213,7 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { uint256 actorIndexSeed ) public useActor(actorIndexSeed) returns (uint256) { numberOfCalls++; - numberOfRedeems++; + numberOfAtomRedeems++; emit log_named_uint( "==================================== ACTOR redeemAtom START ====================================", 6000000009 @@ -287,5 +290,234 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { return assetsForReceiver; } + function createTriple( + uint256 _subjectId, + uint256 _predicateId, + uint256 _objectId, + uint256 msgValue, + uint256 actorIndexSeed + ) public useActor(actorIndexSeed) returns (uint256) { + numberOfCalls++; + numberOfTriples++; + emit log_named_uint( + "==================================== ACTOR createTriple START ====================================", + 6000000009 + ); + emit log_named_address("currentActor-----", currentActor); + emit log_named_uint("currentActor.balance", currentActor.balance); + emit log_named_uint("msgValue------------", msgValue); + if (currentActor.balance < getAtomCost()) { + vm.deal(currentActor, 1 ether); + } + if (msgValue < getAtomCost()) { + msgValue = getAtomCost(); + } + if (msgValue > currentActor.balance) { + if (msgValue > 1 ether) { + vm.deal(currentActor, 1 ether); + msgValue = 1 ether; + } else { + vm.deal(currentActor, msgValue); + } + } + emit log_named_uint("msg.sender.balance Right before create", currentActor.balance); + emit log_named_address("msg.sender-----", currentActor); + + uint256 totalAssetsBefore = vaultTotalAssets(ethMultiVault.count() + 1); + uint256 totalSharesBefore = vaultTotalShares(ethMultiVault.count() + 1); + + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + + // create atom + uint256 id = actEthMultiVault.createTriple{value: msgValue}(_subjectId, _predicateId, _objectId); + assertEq(id, actEthMultiVault.count()); + + checkDepositOnAtomVaultCreation(id, msgValue, totalAssetsBefore, totalSharesBefore); + + uint256 userDeposit = msgValue - getAtomCost(); + + checkProtocolVaultBalanceOnVaultCreation(id, userDeposit, protocolVaultBalanceBefore); + + // logs + emit log_named_uint( + "------------------------------------ POST STATE ------------------------------------------", 6000000009 + ); + emit log_named_uint("msg.sender.balance", currentActor.balance); + emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(id)); + emit log_named_uint("vaultTAssets------", getVaultTotalShares(id)); + emit log_named_uint( + "==================================== ACTOR createTriple END ====================================", id + ); + return id; + } + + function depositTriple(address _receiver, uint256 _vaultId, uint256 msgValue, uint256 actorIndexSeed) + public + useActor(actorIndexSeed) + returns (uint256) + { + numberOfCalls++; + numberOfTripleDeposits++; + emit log_named_uint( + "==================================== ACTOR depositTriple ====================================", 6000000009 + ); + emit log_named_address("currentActor-----", currentActor); + emit log_named_uint("currentActor.balance", currentActor.balance); + emit log_named_uint("msgValue------------", msgValue); + // bound _receiver to msg.sender always + _receiver = currentActor; + uint256 shares; + // if no atom exist yet, create and deposit on one + if (actEthMultiVault.count() == 0) { + vm.deal(currentActor, getAtomCost()); + _vaultId = actEthMultiVault.createTriple{value: getAtomCost()}(1, 2, 3); + emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(_vaultId)); + emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(_vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + msgValue = bound(msgValue, getMinDeposit(), 10 ether); + vm.deal(currentActor, msgValue); + emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); + + uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); + uint256 totalSharesBefore = vaultTotalShares(_vaultId); + + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + + shares = actEthMultiVault.depositTriple{value: msgValue}(_receiver, _vaultId); + + checkDepositIntoVault( + msgValue - getProtocolFeeAmount(msgValue, _vaultId), _vaultId, totalAssetsBefore, totalSharesBefore + ); + + checkProtocolVaultBalance(_vaultId, msgValue, protocolVaultBalanceBefore); + } else { + // deposit on existing vault + // bound _vaultId between 1 and count() + if (_vaultId == 0 || _vaultId > actEthMultiVault.count()) { + _vaultId = bound(_vaultId, 1, actEthMultiVault.count()); + } + emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(_vaultId)); + emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(_vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + // bound msgValue to between minDeposit and 10 ether + msgValue = bound(msgValue, getAtomCost(), 10 ether); + vm.deal(currentActor, msgValue); + emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 2|||||||||||||||||||||||||||||||||||", 2); + + uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); + uint256 totalSharesBefore = vaultTotalShares(_vaultId); + + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + + shares = actEthMultiVault.depositTriple{value: msgValue}(_receiver, _vaultId); + + checkDepositIntoVault( + msgValue - getProtocolFeeAmount(msgValue, _vaultId), _vaultId, totalAssetsBefore, totalSharesBefore + ); + + checkProtocolVaultBalance(_vaultId, msgValue, protocolVaultBalanceBefore); + } + // deposit triple + emit log_named_uint("balance currentActor", currentActor.balance); + emit log_named_uint("balance EthMultiVaultbal-", address(actEthMultiVault).balance); + emit log_named_uint("balance this--------", address(this).balance); + // logs + emit log_named_uint( + "------------------------------------ POST STATE -------------------------------------------", 6000000009 + ); + emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(_vaultId)); + emit log_named_uint("vaultTAssets--------", getVaultTotalShares(_vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint( + "==================================== ACTOR depositTriple ====================================", shares + ); + return shares; + } + + function redeemTriple( + uint256 _shares2Redeem, + address _receiver, + uint256 _vaultId, + uint256 msgValue, + uint256 actorIndexSeed + ) public useActor(actorIndexSeed) returns (uint256) { + numberOfCalls++; + numberOfTripleRedeems++; + emit log_named_uint( + "==================================== ACTOR redeemTriple START ====================================", + 6000000009 + ); + emit log_named_address("currentActor-----", currentActor); + emit log_named_uint("currentActor.balance", currentActor.balance); + emit log_named_uint("msgValue------------", msgValue); + // if no atom vaults exist create one and deposit on it + if (actEthMultiVault.count() == 0) { + vm.deal(currentActor, getAtomCost()); + _vaultId = actEthMultiVault.createTriple{value: getAtomCost()}(1, 2, 3); + msgValue = bound(msgValue, getMinDeposit(), 10 ether); + vm.deal(currentActor, msgValue); + emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); + _shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}(currentActor, 1); + } else { + // vault exists + // bound _vaultId between 1 and count() + if (_vaultId == 0 || _vaultId > actEthMultiVault.count()) { + _vaultId = bound(_vaultId, 1, actEthMultiVault.count()); + } + // if vault balance of the selected vault is 0, deposit minDeposit + if (getVaultBalanceForAddress(_vaultId, currentActor) == 0) { + vm.deal(currentActor, 10 ether); + emit log_named_uint("vaultTShares--", getVaultTotalAssets(_vaultId)); + emit log_named_uint("vaultTAssets--", getVaultTotalShares(_vaultId)); + emit log_named_uint("vaultBalanceOf", getVaultBalanceForAddress(_vaultId, currentActor)); + msgValue = bound(msgValue, getAtomCost(), 10 ether); + emit log_named_uint("REEEE getVaultTotalAssets(_vaultId)", getVaultTotalAssets(_vaultId)); + emit log_named_uint("REEEE getVaultTotalShares(_vaultId)", getVaultTotalShares(_vaultId)); + emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 2||||||||||||||||||||||||||||||||||||", 2); + _shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}(currentActor, _vaultId); + emit log_named_uint("_shares2Redeem", _shares2Redeem); + } else { + emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 3||||||||||||||||||||||||||||||||||||", 3); + // bound _shares2Redeem to between 1 and vaultBalanceOf + _shares2Redeem = bound(_shares2Redeem, 1, getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint("_shares2Redeem", _shares2Redeem); + } + } + // use the redeemer as the receiver always + _receiver = currentActor; + + emit log_named_uint("before vaultTotalShares--", getVaultTotalAssets(_vaultId)); + emit log_named_uint("before vaultTAssets------", getVaultTotalShares(_vaultId)); + emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); + + // snapshots before redeem + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + uint256 userSharesBeforeRedeem = getSharesInVault(_vaultId, _receiver); + uint256 userBalanceBeforeRedeem = address(_receiver).balance; + + uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, _vaultId); + + // redeem atom + uint256 assetsForReceiver = actEthMultiVault.redeemTriple(_shares2Redeem, _receiver, _vaultId); + + checkProtocolVaultBalance(_vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); + + assertEq(getSharesInVault(_vaultId, _receiver), userSharesBeforeRedeem - _shares2Redeem); + assertEq(address(_receiver).balance - userBalanceBeforeRedeem, assetsForReceiver); + + // logs + emit log_named_uint( + "------------------------------------ POST STATE -------------------------------------------", 6000000009 + ); + emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(_vaultId)); + emit log_named_uint("vaultTAssets------", getVaultTotalShares(_vaultId)); + emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint( + "==================================== ACTOR redeemTriple END ====================================", + assetsForReceiver + ); + return assetsForReceiver; + } + receive() external payable {} } diff --git a/test/invariant/actors/EthMultiVaultSingleVaultActor.sol b/test/invariant/actors/EthMultiVaultSingleVaultActor.sol index 4dccd80f..1c5ec1a4 100644 --- a/test/invariant/actors/EthMultiVaultSingleVaultActor.sol +++ b/test/invariant/actors/EthMultiVaultSingleVaultActor.sol @@ -16,8 +16,10 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { // ghost variables uint256 public numberOfCalls; - uint256 public numberOfDeposits; - uint256 public numberOfRedeems; + uint256 public numberOfAtomDeposits; + uint256 public numberOfAtomRedeems; + uint256 public numberOfTripleDeposits; + uint256 public numberOfTripleRedeems; modifier useActor(uint256 actorIndexSeed) { currentActor = actors[bound(actorIndexSeed, 0, actors.length - 1)]; @@ -63,7 +65,7 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { returns (uint256) { numberOfCalls++; - numberOfDeposits++; + numberOfAtomDeposits++; emit log_named_uint( "==================================== ACTOR depositAtom START ====================================", 6000000009 @@ -117,7 +119,7 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { returns (uint256) { numberOfCalls++; - numberOfRedeems++; + numberOfAtomRedeems++; emit log_named_uint( "==================================== ACTOR redeemAtom START ====================================", 6000000009 @@ -177,5 +179,125 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { return assetsForReceiver; } + function depositTriple(address _receiver, uint256 msgValue, uint256 actorIndexSeed) + public + useActor(actorIndexSeed) + returns (uint256) + { + numberOfCalls++; + numberOfTripleDeposits++; + emit log_named_uint( + "==================================== ACTOR depositTriple START ====================================", + 6000000009 + ); + emit log_named_address("currentActor-----", currentActor); + emit log_named_uint("currentActor.balance", currentActor.balance); + emit log_named_uint("msgValue------------", msgValue); + uint256 _vaultId = 1; + emit log_named_uint("vaultTotalAssets----", getVaultTotalAssets(_vaultId)); + emit log_named_uint("vaultTotalShares----", getVaultTotalShares(_vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + // bound _receiver to msg.sender always + _receiver = currentActor; + // bound msgValue to between minDeposit and 10 ether + msgValue = bound(msgValue, getAtomCost(), 10 ether); + vm.deal(currentActor, msgValue); + + uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); + uint256 totalSharesBefore = vaultTotalShares(_vaultId); + + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + + // deposit atom + uint256 shares = actEthMultiVault.depositTriple{value: msgValue}(_receiver, _vaultId); + + checkDepositIntoVault( + msgValue - getProtocolFeeAmount(msgValue, _vaultId), _vaultId, totalAssetsBefore, totalSharesBefore + ); + + checkProtocolVaultBalance(_vaultId, msgValue, protocolVaultBalanceBefore); + + // logs + emit log_named_uint( + "------------------------------------ POST STATE -------------------------------------------", 6000000009 + ); + emit log_named_uint("balance currentActor", currentActor.balance); + emit log_named_uint("balance EthMultiVaultbal-", address(actEthMultiVault).balance); + emit log_named_uint("balance this--------", address(this).balance); + emit log_named_uint("vaultTotalShares----", getVaultTotalShares(_vaultId)); + emit log_named_uint("vaultTAssets--------", getVaultTotalAssets(_vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint( + "==================================== ACTOR depositTriple END ====================================", shares + ); + return shares; + } + + function redeemTriple(uint256 _shares2Redeem, address _receiver, uint256 msgValue, uint256 actorIndexSeed) + public + useActor(actorIndexSeed) + returns (uint256) + { + numberOfCalls++; + numberOfTripleRedeems++; + emit log_named_uint( + "==================================== ACTOR redeemTriple START ====================================", + 6000000009 + ); + emit log_named_address("currentActor-----", currentActor); + emit log_named_uint("currentActor.balance", currentActor.balance); + emit log_named_uint("msgValue------------", msgValue); + uint256 _vaultId = 1; + // if vault balance of the selected vault is 0, deposit minDeposit + if (getVaultBalanceForAddress(_vaultId, currentActor) == 0) { + vm.deal(currentActor, 10 ether); + msgValue = bound(msgValue, getAtomCost(), 10 ether); + _shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}(currentActor, _vaultId); + emit log_named_uint("_shares2Redeem", _shares2Redeem); + } else { + // bound _shares2Redeem to between 1 and vaultBalanceOf + _shares2Redeem = bound(_shares2Redeem, 1, getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint("_shares2Redeem", _shares2Redeem); + } + // use the redeemer as the receiver always + _receiver = currentActor; + + emit log_named_uint("before vaultTotalShares--", getVaultTotalShares(_vaultId)); + emit log_named_uint("before vaultTAssets------", getVaultTotalAssets(_vaultId)); + emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); + + // snapshots before redeem + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + uint256 userSharesBeforeRedeem = getSharesInVault(_vaultId, _receiver); + uint256 userBalanceBeforeRedeem = address(_receiver).balance; + + uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, _vaultId); + + // redeem atom + uint256 assetsForReceiver = actEthMultiVault.redeemTriple(_shares2Redeem, _receiver, _vaultId); + + checkProtocolVaultBalance(_vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); + + // snapshots after redeem + uint256 userSharesAfterRedeem = getSharesInVault(_vaultId, _receiver); + uint256 userBalanceAfterRedeem = address(_receiver).balance; + + assertEq(userSharesAfterRedeem, userSharesBeforeRedeem - _shares2Redeem); + assertEq(userBalanceAfterRedeem - userBalanceBeforeRedeem, assetsForReceiver); + + // logs + emit log_named_uint( + "------------------------------------ POST STATE -------------------------------------------", 6000000009 + ); + emit log_named_uint("vaultTotalShares--", getVaultTotalShares(_vaultId)); + emit log_named_uint("vaultTAssets------", getVaultTotalAssets(_vaultId)); + emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint( + "==================================== ACTOR redeemTriple END ====================================", + assetsForReceiver + ); + return assetsForReceiver; + } + receive() external payable {} } From 78854c21c1829fb173ce52b94a837ed95b70de5e Mon Sep 17 00:00:00 2001 From: mihailo-maksa Date: Thu, 23 May 2024 21:35:12 +0200 Subject: [PATCH 2/3] add single vault actor logic for triple invariants --- .../EthMultiVaultSingleVaultInvariant.t.sol | 7 + test/invariant/actors/EthMultiVaultActor.sol | 832 ++++++++++++++---- .../actors/EthMultiVaultSingleVaultActor.sol | 207 +++-- 3 files changed, 794 insertions(+), 252 deletions(-) diff --git a/test/invariant/EthMultiVaultSingleVaultInvariant.t.sol b/test/invariant/EthMultiVaultSingleVaultInvariant.t.sol index c8e8516e..24e47e09 100644 --- a/test/invariant/EthMultiVaultSingleVaultInvariant.t.sol +++ b/test/invariant/EthMultiVaultSingleVaultInvariant.t.sol @@ -20,6 +20,13 @@ contract EthMultiVaultSingleVaultInvariantTest is InvariantEthMultiVaultBase { // create single vault ethMultiVault.createAtom{value: 100 ether}("PEPE"); + // create 2 more atoms for the triple vault + ethMultiVault.createAtom{value: 100 ether}("WIF"); + ethMultiVault.createAtom{value: 100 ether}("BASE"); + + // create triple vault + ethMultiVault.createTriple{value: 100 ether}(1, 2, 3); + // deploy actor actor = new EthMultiVaultSingleVaultActor(ethMultiVault); diff --git a/test/invariant/actors/EthMultiVaultActor.sol b/test/invariant/actors/EthMultiVaultActor.sol index 54f03645..6861047e 100644 --- a/test/invariant/actors/EthMultiVaultActor.sol +++ b/test/invariant/actors/EthMultiVaultActor.sol @@ -38,33 +38,52 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { actorPks.push(i + 1); actors.push(vm.addr(actorPks[i])); } - //actors.push(msg.sender); + actors.push(msg.sender); } - function getVaultTotalAssets(uint256 vaultId) public view returns (uint256 totalAssets) { - (totalAssets,) = actEthMultiVault.vaults(vaultId); + receive() external payable {} + + function getVaultTotalAssets( + uint256 vaultId + ) public view returns (uint256 totalAssets) { + (totalAssets, ) = actEthMultiVault.vaults(vaultId); } - function getVaultTotalShares(uint256 vaultId) public view returns (uint256 totalShares) { + function getVaultTotalShares( + uint256 vaultId + ) public view returns (uint256 totalShares) { (, totalShares) = actEthMultiVault.vaults(vaultId); } - function getVaultBalanceForAddress(uint256 vaultId, address user) public view returns (uint256) { - (uint256 shares,) = actEthMultiVault.getVaultStateForUser(vaultId, user); + function getVaultBalanceForAddress( + uint256 vaultId, + address user + ) public view returns (uint256) { + (uint256 shares, ) = actEthMultiVault.getVaultStateForUser( + vaultId, + user + ); return shares; } - function getAssetsForReceiverBeforeFees(uint256 shares, uint256 vaultId) public view returns (uint256) { - (, uint256 calculatedAssetsForReceiver, uint256 protocolFees, uint256 exitFees) = - actEthMultiVault.getRedeemAssetsAndFees(shares, vaultId); + function getAssetsForReceiverBeforeFees( + uint256 shares, + uint256 vaultId + ) public view returns (uint256) { + ( + , + uint256 calculatedAssetsForReceiver, + uint256 protocolFees, + uint256 exitFees + ) = actEthMultiVault.getRedeemAssetsAndFees(shares, vaultId); return calculatedAssetsForReceiver + protocolFees + exitFees; } - function createAtom(bytes calldata _data, uint256 msgValue, uint256 actorIndexSeed) - public - useActor(actorIndexSeed) - returns (uint256) - { + function createAtom( + bytes calldata _data, + uint256 msgValue, + uint256 actorIndexSeed + ) public useActor(actorIndexSeed) returns (uint256) { numberOfCalls++; numberOfAtoms++; emit log_named_uint( @@ -88,33 +107,48 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { vm.deal(currentActor, msgValue); } } - emit log_named_uint("msg.sender.balance Right before create", currentActor.balance); + emit log_named_uint( + "msg.sender.balance Right before create", + currentActor.balance + ); emit log_named_address("msg.sender-----", currentActor); uint256 totalAssetsBefore = vaultTotalAssets(ethMultiVault.count() + 1); uint256 totalSharesBefore = vaultTotalShares(ethMultiVault.count() + 1); - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()) + .balance; // create atom uint256 id = actEthMultiVault.createAtom{value: msgValue}(_data); assertEq(id, actEthMultiVault.count()); - checkDepositOnAtomVaultCreation(id, msgValue, totalAssetsBefore, totalSharesBefore); + checkDepositOnAtomVaultCreation( + id, + msgValue, + totalAssetsBefore, + totalSharesBefore + ); uint256 userDeposit = msgValue - getAtomCost(); - checkProtocolVaultBalanceOnVaultCreation(id, userDeposit, protocolVaultBalanceBefore); + checkProtocolVaultBalanceOnVaultCreation( + id, + userDeposit, + protocolVaultBalanceBefore + ); // logs emit log_named_uint( - "------------------------------------ POST STATE ------------------------------------------", 6000000009 + "------------------------------------ POST STATE ------------------------------------------", + 6000000009 ); emit log_named_uint("msg.sender.balance", currentActor.balance); emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(id)); emit log_named_uint("vaultTAssets------", getVaultTotalShares(id)); emit log_named_uint( - "==================================== ACTOR createAtom END ====================================", id + "==================================== ACTOR createAtom END ====================================", + id ); return id; } @@ -129,7 +163,8 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { numberOfCalls++; numberOfAtomDeposits++; emit log_named_uint( - "==================================== ACTOR depositAtom ====================================", 6000000009 + "==================================== ACTOR depositAtom ====================================", + 6000000009 ); emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); @@ -141,65 +176,125 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { if (actEthMultiVault.count() == 0) { vm.deal(currentActor, getAtomCost()); _vaultId = actEthMultiVault.createAtom{value: getAtomCost()}(_data); - emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint( + "vaultTotalAssets----", + getVaultTotalShares(_vaultId) + ); + emit log_named_uint( + "vaultTotalShares----", + getVaultTotalAssets(_vaultId) + ); + emit log_named_uint( + "vaultBalanceOf------", + getVaultBalanceForAddress(_vaultId, currentActor) + ); msgValue = bound(msgValue, getMinDeposit(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); + emit log_named_uint( + "|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", + 1 + ); uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); uint256 totalSharesBefore = vaultTotalShares(_vaultId); - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()) + .balance; - shares = actEthMultiVault.depositAtom{value: msgValue}(_receiver, _vaultId); + shares = actEthMultiVault.depositAtom{value: msgValue}( + _receiver, + _vaultId + ); checkDepositIntoVault( - msgValue - getProtocolFeeAmount(msgValue, _vaultId), _vaultId, totalAssetsBefore, totalSharesBefore + msgValue - getProtocolFeeAmount(msgValue, _vaultId), + _vaultId, + totalAssetsBefore, + totalSharesBefore ); - checkProtocolVaultBalance(_vaultId, msgValue, protocolVaultBalanceBefore); + checkProtocolVaultBalance( + _vaultId, + msgValue, + protocolVaultBalanceBefore + ); } else { // deposit on existing vault // bound _vaultId between 1 and count() if (_vaultId == 0 || _vaultId > actEthMultiVault.count()) { _vaultId = bound(_vaultId, 1, actEthMultiVault.count()); } - emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint( + "vaultTotalAssets----", + getVaultTotalShares(_vaultId) + ); + emit log_named_uint( + "vaultTotalShares----", + getVaultTotalAssets(_vaultId) + ); + emit log_named_uint( + "vaultBalanceOf------", + getVaultBalanceForAddress(_vaultId, currentActor) + ); // bound msgValue to between minDeposit and 10 ether msgValue = bound(msgValue, getAtomCost(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 2|||||||||||||||||||||||||||||||||||", 2); + emit log_named_uint( + "|||||||||||||||||||||||||||||||||||BRANCH 2|||||||||||||||||||||||||||||||||||", + 2 + ); uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); uint256 totalSharesBefore = vaultTotalShares(_vaultId); - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()) + .balance; - shares = actEthMultiVault.depositAtom{value: msgValue}(_receiver, _vaultId); + shares = actEthMultiVault.depositAtom{value: msgValue}( + _receiver, + _vaultId + ); checkDepositIntoVault( - msgValue - getProtocolFeeAmount(msgValue, _vaultId), _vaultId, totalAssetsBefore, totalSharesBefore + msgValue - getProtocolFeeAmount(msgValue, _vaultId), + _vaultId, + totalAssetsBefore, + totalSharesBefore ); - checkProtocolVaultBalance(_vaultId, msgValue, protocolVaultBalanceBefore); + checkProtocolVaultBalance( + _vaultId, + msgValue, + protocolVaultBalanceBefore + ); } // deposit atom emit log_named_uint("balance currentActor", currentActor.balance); - emit log_named_uint("balance EthMultiVaultbal-", address(actEthMultiVault).balance); + emit log_named_uint( + "balance EthMultiVaultbal-", + address(actEthMultiVault).balance + ); emit log_named_uint("balance this--------", address(this).balance); // logs emit log_named_uint( - "------------------------------------ POST STATE -------------------------------------------", 6000000009 + "------------------------------------ POST STATE -------------------------------------------", + 6000000009 + ); + emit log_named_uint( + "vaultTotalShares----", + getVaultTotalAssets(_vaultId) ); - emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultTAssets--------", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); emit log_named_uint( - "==================================== ACTOR depositAtom ====================================", shares + "vaultTAssets--------", + getVaultTotalShares(_vaultId) + ); + emit log_named_uint( + "vaultBalanceOf------", + getVaultBalanceForAddress(_vaultId, currentActor) + ); + emit log_named_uint( + "==================================== ACTOR depositAtom ====================================", + shares ); return shares; } @@ -227,8 +322,14 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { _vaultId = actEthMultiVault.createAtom{value: getAtomCost()}(_data); msgValue = bound(msgValue, getMinDeposit(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); - _shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}(currentActor, 1); + emit log_named_uint( + "|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", + 1 + ); + _shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}( + currentActor, + 1 + ); } else { // vault exists // bound _vaultId between 1 and count() @@ -238,51 +339,116 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { // if vault balance of the selected vault is 0, deposit minDeposit if (getVaultBalanceForAddress(_vaultId, currentActor) == 0) { vm.deal(currentActor, 10 ether); - emit log_named_uint("vaultTShares--", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultTAssets--", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultBalanceOf", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint( + "vaultTShares--", + getVaultTotalAssets(_vaultId) + ); + emit log_named_uint( + "vaultTAssets--", + getVaultTotalShares(_vaultId) + ); + emit log_named_uint( + "vaultBalanceOf", + getVaultBalanceForAddress(_vaultId, currentActor) + ); msgValue = bound(msgValue, getAtomCost(), 10 ether); - emit log_named_uint("REEEE getVaultTotalAssets(_vaultId)", getVaultTotalAssets(_vaultId)); - emit log_named_uint("REEEE getVaultTotalShares(_vaultId)", getVaultTotalShares(_vaultId)); - emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 2||||||||||||||||||||||||||||||||||||", 2); - _shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}(currentActor, _vaultId); + emit log_named_uint( + "REEEE getVaultTotalAssets(_vaultId)", + getVaultTotalAssets(_vaultId) + ); + emit log_named_uint( + "REEEE getVaultTotalShares(_vaultId)", + getVaultTotalShares(_vaultId) + ); + emit log_named_uint( + "|||||||||||||||||||||||||||||||BRANCH 2||||||||||||||||||||||||||||||||||||", + 2 + ); + _shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}( + currentActor, + _vaultId + ); emit log_named_uint("_shares2Redeem", _shares2Redeem); } else { - emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 3||||||||||||||||||||||||||||||||||||", 3); + emit log_named_uint( + "|||||||||||||||||||||||||||||||BRANCH 3||||||||||||||||||||||||||||||||||||", + 3 + ); // bound _shares2Redeem to between 1 and vaultBalanceOf - _shares2Redeem = bound(_shares2Redeem, 1, getVaultBalanceForAddress(_vaultId, currentActor)); + _shares2Redeem = bound( + _shares2Redeem, + 1, + getVaultBalanceForAddress(_vaultId, currentActor) + ); emit log_named_uint("_shares2Redeem", _shares2Redeem); } } // use the redeemer as the receiver always _receiver = currentActor; - emit log_named_uint("before vaultTotalShares--", getVaultTotalAssets(_vaultId)); - emit log_named_uint("before vaultTAssets------", getVaultTotalShares(_vaultId)); - emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint( + "before vaultTotalShares--", + getVaultTotalAssets(_vaultId) + ); + emit log_named_uint( + "before vaultTAssets------", + getVaultTotalShares(_vaultId) + ); + emit log_named_uint( + "before vaultBalanceOf----", + getVaultBalanceForAddress(_vaultId, currentActor) + ); // snapshots before redeem - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()) + .balance; uint256 userSharesBeforeRedeem = getSharesInVault(_vaultId, _receiver); uint256 userBalanceBeforeRedeem = address(_receiver).balance; - uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, _vaultId); + uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees( + userSharesBeforeRedeem, + _vaultId + ); // redeem atom - uint256 assetsForReceiver = actEthMultiVault.redeemAtom(_shares2Redeem, _receiver, _vaultId); + uint256 assetsForReceiver = actEthMultiVault.redeemAtom( + _shares2Redeem, + _receiver, + _vaultId + ); - checkProtocolVaultBalance(_vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); + checkProtocolVaultBalance( + _vaultId, + assetsForReceiverBeforeFees, + protocolVaultBalanceBefore + ); - assertEq(getSharesInVault(_vaultId, _receiver), userSharesBeforeRedeem - _shares2Redeem); - assertEq(address(_receiver).balance - userBalanceBeforeRedeem, assetsForReceiver); + assertEq( + getSharesInVault(_vaultId, _receiver), + userSharesBeforeRedeem - _shares2Redeem + ); + assertEq( + address(_receiver).balance - userBalanceBeforeRedeem, + assetsForReceiver + ); // logs emit log_named_uint( - "------------------------------------ POST STATE -------------------------------------------", 6000000009 + "------------------------------------ POST STATE -------------------------------------------", + 6000000009 + ); + emit log_named_uint( + "vaultTotalShares--", + getVaultTotalAssets(_vaultId) + ); + emit log_named_uint( + "vaultTAssets------", + getVaultTotalShares(_vaultId) + ); + emit log_named_uint( + "vaultBalanceOf----", + getVaultBalanceForAddress(_vaultId, currentActor) ); - emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultTAssets------", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); emit log_named_uint( "==================================== ACTOR redeemAtom END ====================================", assetsForReceiver @@ -291,9 +457,9 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { } function createTriple( - uint256 _subjectId, - uint256 _predicateId, - uint256 _objectId, + uint256 subjectId, + uint256 predicateId, + uint256 objectId, uint256 msgValue, uint256 actorIndexSeed ) public useActor(actorIndexSeed) returns (uint256) { @@ -306,11 +472,11 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); emit log_named_uint("msgValue------------", msgValue); - if (currentActor.balance < getAtomCost()) { + if (currentActor.balance < getTripleCost()) { vm.deal(currentActor, 1 ether); } - if (msgValue < getAtomCost()) { - msgValue = getAtomCost(); + if (msgValue < getTripleCost()) { + msgValue = getTripleCost(); } if (msgValue > currentActor.balance) { if (msgValue > 1 ether) { @@ -320,124 +486,156 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { vm.deal(currentActor, msgValue); } } - emit log_named_uint("msg.sender.balance Right before create", currentActor.balance); + emit log_named_uint( + "msg.sender.balance Right before create", + currentActor.balance + ); emit log_named_address("msg.sender-----", currentActor); - uint256 totalAssetsBefore = vaultTotalAssets(ethMultiVault.count() + 1); - uint256 totalSharesBefore = vaultTotalShares(ethMultiVault.count() + 1); - - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - - // create atom - uint256 id = actEthMultiVault.createTriple{value: msgValue}(_subjectId, _predicateId, _objectId); - assertEq(id, actEthMultiVault.count()); - - checkDepositOnAtomVaultCreation(id, msgValue, totalAssetsBefore, totalSharesBefore); - - uint256 userDeposit = msgValue - getAtomCost(); - - checkProtocolVaultBalanceOnVaultCreation(id, userDeposit, protocolVaultBalanceBefore); + uint256 vaultId = _createTripleChecks( + msgValue, + subjectId, + predicateId, + objectId + ); // logs emit log_named_uint( - "------------------------------------ POST STATE ------------------------------------------", 6000000009 + "------------------------------------ POST STATE ------------------------------------------", + 6000000009 ); emit log_named_uint("msg.sender.balance", currentActor.balance); - emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(id)); - emit log_named_uint("vaultTAssets------", getVaultTotalShares(id)); + emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultTAssets------", getVaultTotalShares(vaultId)); emit log_named_uint( - "==================================== ACTOR createTriple END ====================================", id + "==================================== ACTOR createTriple END ====================================", + vaultId ); - return id; + return vaultId; } - function depositTriple(address _receiver, uint256 _vaultId, uint256 msgValue, uint256 actorIndexSeed) - public - useActor(actorIndexSeed) - returns (uint256) - { + function depositTriple( + address receiver, + uint256 vaultId, + uint256 msgValue, + uint256 actorIndexSeed + ) public useActor(actorIndexSeed) returns (uint256) { numberOfCalls++; numberOfTripleDeposits++; emit log_named_uint( - "==================================== ACTOR depositTriple ====================================", 6000000009 + "==================================== ACTOR depositTriple ====================================", + 6000000009 ); emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); emit log_named_uint("msgValue------------", msgValue); // bound _receiver to msg.sender always - _receiver = currentActor; + receiver = currentActor; uint256 shares; - // if no atom exist yet, create and deposit on one + // if no triple exist yet, create and deposit on one if (actEthMultiVault.count() == 0) { - vm.deal(currentActor, getAtomCost()); - _vaultId = actEthMultiVault.createTriple{value: getAtomCost()}(1, 2, 3); - emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + vm.deal(currentActor, getTripleCost()); + vaultId = actEthMultiVault.createTriple{value: getTripleCost()}( + 1, + 2, + 3 + ); + emit log_named_uint( + "vaultTotalAssets----", + getVaultTotalShares(vaultId) + ); + emit log_named_uint( + "vaultTotalShares----", + getVaultTotalAssets(vaultId) + ); + emit log_named_uint( + "vaultBalanceOf------", + getVaultBalanceForAddress(vaultId, currentActor) + ); msgValue = bound(msgValue, getMinDeposit(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); - - uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); - uint256 totalSharesBefore = vaultTotalShares(_vaultId); - - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - - shares = actEthMultiVault.depositTriple{value: msgValue}(_receiver, _vaultId); - - checkDepositIntoVault( - msgValue - getProtocolFeeAmount(msgValue, _vaultId), _vaultId, totalAssetsBefore, totalSharesBefore + emit log_named_uint( + "|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", + 1 ); - checkProtocolVaultBalance(_vaultId, msgValue, protocolVaultBalanceBefore); + _createTripleChecks(msgValue, 1, 2, 3); } else { - // deposit on existing vault - // bound _vaultId between 1 and count() - if (_vaultId == 0 || _vaultId > actEthMultiVault.count()) { - _vaultId = bound(_vaultId, 1, actEthMultiVault.count()); + // vault exists + if (vaultId == 0 || vaultId > actEthMultiVault.count()) { + uint256[] memory tripleVaults = new uint256[]( + actEthMultiVault.count() + ); + uint256 tripleVaultsCount = 0; + for (uint256 i = 1; i <= actEthMultiVault.count(); i++) { + if (actEthMultiVault.isTripleId(i)) { + tripleVaults[tripleVaultsCount] = i; + tripleVaultsCount++; + } + } + + vaultId = tripleVaults[ + bound(actorIndexSeed, 0, tripleVaultsCount - 1) + ]; } - emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + + emit log_named_uint( + "vaultTotalAssets----", + getVaultTotalShares(vaultId) + ); + emit log_named_uint( + "vaultTotalShares----", + getVaultTotalAssets(vaultId) + ); + emit log_named_uint( + "vaultBalanceOf------", + getVaultBalanceForAddress(vaultId, currentActor) + ); // bound msgValue to between minDeposit and 10 ether - msgValue = bound(msgValue, getAtomCost(), 10 ether); + msgValue = bound(msgValue, getTripleCost(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 2|||||||||||||||||||||||||||||||||||", 2); - - uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); - uint256 totalSharesBefore = vaultTotalShares(_vaultId); - - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - - shares = actEthMultiVault.depositTriple{value: msgValue}(_receiver, _vaultId); - - checkDepositIntoVault( - msgValue - getProtocolFeeAmount(msgValue, _vaultId), _vaultId, totalAssetsBefore, totalSharesBefore + emit log_named_uint( + "|||||||||||||||||||||||||||||||||||BRANCH 2|||||||||||||||||||||||||||||||||||", + 2 ); - checkProtocolVaultBalance(_vaultId, msgValue, protocolVaultBalanceBefore); + shares = _depositTripleChecks(vaultId, msgValue, receiver); } // deposit triple emit log_named_uint("balance currentActor", currentActor.balance); - emit log_named_uint("balance EthMultiVaultbal-", address(actEthMultiVault).balance); + emit log_named_uint( + "balance EthMultiVaultbal-", + address(actEthMultiVault).balance + ); emit log_named_uint("balance this--------", address(this).balance); // logs emit log_named_uint( - "------------------------------------ POST STATE -------------------------------------------", 6000000009 + "------------------------------------ POST STATE -------------------------------------------", + 6000000009 + ); + emit log_named_uint( + "vaultTotalShares----", + getVaultTotalAssets(vaultId) + ); + emit log_named_uint( + "vaultTAssets--------", + getVaultTotalShares(vaultId) ); - emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultTAssets--------", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); emit log_named_uint( - "==================================== ACTOR depositTriple ====================================", shares + "vaultBalanceOf------", + getVaultBalanceForAddress(vaultId, currentActor) + ); + emit log_named_uint( + "==================================== ACTOR depositTriple ====================================", + shares ); return shares; } function redeemTriple( - uint256 _shares2Redeem, - address _receiver, - uint256 _vaultId, + uint256 shares2Redeem, + address receiver, + uint256 vaultId, uint256 msgValue, uint256 actorIndexSeed ) public useActor(actorIndexSeed) returns (uint256) { @@ -450,68 +648,122 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); emit log_named_uint("msgValue------------", msgValue); - // if no atom vaults exist create one and deposit on it + // if no triple vaults exist create one and deposit on it if (actEthMultiVault.count() == 0) { - vm.deal(currentActor, getAtomCost()); - _vaultId = actEthMultiVault.createTriple{value: getAtomCost()}(1, 2, 3); + vm.deal(currentActor, getTripleCost()); + vaultId = _createTripleChecks(msgValue, 1, 2, 3); + msgValue = bound(msgValue, getMinDeposit(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); - _shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}(currentActor, 1); + emit log_named_uint( + "|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", + 1 + ); + shares2Redeem = _depositTripleChecks( + vaultId, + msgValue, + currentActor + ); } else { // vault exists - // bound _vaultId between 1 and count() - if (_vaultId == 0 || _vaultId > actEthMultiVault.count()) { - _vaultId = bound(_vaultId, 1, actEthMultiVault.count()); + if (vaultId == 0 || vaultId > actEthMultiVault.count()) { + uint256[] memory tripleVaults = new uint256[]( + actEthMultiVault.count() + ); + uint256 tripleVaultsCount = 0; + for (uint256 i = 1; i <= actEthMultiVault.count(); i++) { + if (actEthMultiVault.isTripleId(i)) { + tripleVaults[tripleVaultsCount] = i; + tripleVaultsCount++; + } + } + + vaultId = tripleVaults[ + bound(actorIndexSeed, 0, tripleVaultsCount - 1) + ]; } + // if vault balance of the selected vault is 0, deposit minDeposit - if (getVaultBalanceForAddress(_vaultId, currentActor) == 0) { + if (getVaultBalanceForAddress(vaultId, currentActor) == 0) { vm.deal(currentActor, 10 ether); - emit log_named_uint("vaultTShares--", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultTAssets--", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultBalanceOf", getVaultBalanceForAddress(_vaultId, currentActor)); - msgValue = bound(msgValue, getAtomCost(), 10 ether); - emit log_named_uint("REEEE getVaultTotalAssets(_vaultId)", getVaultTotalAssets(_vaultId)); - emit log_named_uint("REEEE getVaultTotalShares(_vaultId)", getVaultTotalShares(_vaultId)); - emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 2||||||||||||||||||||||||||||||||||||", 2); - _shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}(currentActor, _vaultId); - emit log_named_uint("_shares2Redeem", _shares2Redeem); + emit log_named_uint( + "vaultTShares--", + getVaultTotalAssets(vaultId) + ); + emit log_named_uint( + "vaultTAssets--", + getVaultTotalShares(vaultId) + ); + emit log_named_uint( + "vaultBalanceOf", + getVaultBalanceForAddress(vaultId, currentActor) + ); + msgValue = bound(msgValue, getTripleCost(), 10 ether); + emit log_named_uint( + "REEEE getVaultTotalAssets(_vaultId)", + getVaultTotalAssets(vaultId) + ); + emit log_named_uint( + "REEEE getVaultTotalShares(_vaultId)", + getVaultTotalShares(vaultId) + ); + emit log_named_uint( + "|||||||||||||||||||||||||||||||BRANCH 2||||||||||||||||||||||||||||||||||||", + 2 + ); + shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}( + currentActor, + vaultId + ); + _depositTripleChecks(vaultId, msgValue, receiver); + emit log_named_uint("_shares2Redeem", shares2Redeem); } else { - emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 3||||||||||||||||||||||||||||||||||||", 3); + emit log_named_uint( + "|||||||||||||||||||||||||||||||BRANCH 3||||||||||||||||||||||||||||||||||||", + 3 + ); // bound _shares2Redeem to between 1 and vaultBalanceOf - _shares2Redeem = bound(_shares2Redeem, 1, getVaultBalanceForAddress(_vaultId, currentActor)); - emit log_named_uint("_shares2Redeem", _shares2Redeem); + shares2Redeem = bound( + shares2Redeem, + 1, + getVaultBalanceForAddress(vaultId, currentActor) + ); + emit log_named_uint("_shares2Redeem", shares2Redeem); } } // use the redeemer as the receiver always - _receiver = currentActor; - - emit log_named_uint("before vaultTotalShares--", getVaultTotalAssets(_vaultId)); - emit log_named_uint("before vaultTAssets------", getVaultTotalShares(_vaultId)); - emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); + receiver = currentActor; - // snapshots before redeem - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - uint256 userSharesBeforeRedeem = getSharesInVault(_vaultId, _receiver); - uint256 userBalanceBeforeRedeem = address(_receiver).balance; - - uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, _vaultId); - - // redeem atom - uint256 assetsForReceiver = actEthMultiVault.redeemTriple(_shares2Redeem, _receiver, _vaultId); - - checkProtocolVaultBalance(_vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); + emit log_named_uint( + "before vaultTotalShares--", + getVaultTotalAssets(vaultId) + ); + emit log_named_uint( + "before vaultTAssets------", + getVaultTotalShares(vaultId) + ); + emit log_named_uint( + "before vaultBalanceOf----", + getVaultBalanceForAddress(vaultId, currentActor) + ); - assertEq(getSharesInVault(_vaultId, _receiver), userSharesBeforeRedeem - _shares2Redeem); - assertEq(address(_receiver).balance - userBalanceBeforeRedeem, assetsForReceiver); + uint256 assetsForReceiver = _redeemTripleChecks( + shares2Redeem, + receiver, + vaultId + ); // logs emit log_named_uint( - "------------------------------------ POST STATE -------------------------------------------", 6000000009 + "------------------------------------ POST STATE -------------------------------------------", + 6000000009 + ); + emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultTAssets------", getVaultTotalShares(vaultId)); + emit log_named_uint( + "vaultBalanceOf----", + getVaultBalanceForAddress(vaultId, currentActor) ); - emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultTAssets------", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); emit log_named_uint( "==================================== ACTOR redeemTriple END ====================================", assetsForReceiver @@ -519,5 +771,203 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { return assetsForReceiver; } - receive() external payable {} + function _createTripleChecks( + uint256 msgValue, + uint256 subjectId, + uint256 predicateId, + uint256 objectId + ) internal returns (uint256 vaultId) { + uint256 totalAssetsBefore = vaultTotalAssets(ethMultiVault.count() + 1); + uint256 totalSharesBefore = vaultTotalShares(ethMultiVault.count() + 1); + + uint256 protocolVaultBalanceBefore = address(getProtocolVault()) + .balance; + + uint256[3] memory totalAssetsBeforeAtomVaults = [ + vaultTotalAssets(subjectId), + vaultTotalAssets(predicateId), + vaultTotalAssets(objectId) + ]; + uint256[3] memory totalSharesBeforeAtomVaults = [ + vaultTotalShares(subjectId), + vaultTotalShares(predicateId), + vaultTotalShares(objectId) + ]; + + // create triple + vaultId = actEthMultiVault.createTriple{value: msgValue}( + subjectId, + predicateId, + objectId + ); + assertEq(vaultId, actEthMultiVault.count()); + + checkDepositOnTripleVaultCreation( + vaultId, + msgValue, + totalAssetsBefore, + totalSharesBefore + ); + + // snapshots after creating a triple + assertEq( + protocolVaultBalanceBefore, + // protocolVaultBalanceAfterLessFees + address(getProtocolVault()).balance - + protocolFeeAmount(msgValue - getTripleCost(), vaultId) - + getTripleCreationProtocolFee() + ); + + _checkUnderlyingAtomDepositsOnTripleCreation( + [subjectId, predicateId, objectId], + totalAssetsBeforeAtomVaults, + totalSharesBeforeAtomVaults, + msgValue - getTripleCost() + ); + } + + function _checkUnderlyingAtomDepositsOnTripleCreation( + uint256[3] memory atomIds, + uint256[3] memory totalAssetsBeforeAtomVaults, + uint256[3] memory totalSharesBeforeAtomVaults, + uint256 userDeposit + ) internal { + uint256 protocolDepositFee = protocolFeeAmount(userDeposit, atomIds[0]); + uint256 userDepositAfterProtocolFees = userDeposit - protocolDepositFee; + + uint256 atomDepositFraction = atomDepositFractionAmount( + userDepositAfterProtocolFees, + atomIds[0] + ); + uint256 distributeAmountPerAtomVault = atomDepositFraction / 3; + + uint256 atomDepositFractionOnTripleCreationPerAtom = getAtomDepositFractionOnTripleCreation() / + 3; + + for (uint256 i = 0; i < 3; i++) { + checkAtomDepositIntoVaultOnTripleVaultCreation( + distributeAmountPerAtomVault, + atomDepositFractionOnTripleCreationPerAtom, + atomIds[i], + totalAssetsBeforeAtomVaults[i], + totalSharesBeforeAtomVaults[i] + ); + } + } + + function _depositTripleChecks( + uint256 vaultId, + uint256 msgValue, + address receiver + ) internal returns (uint256 shares) { + uint256 totalAssetsBefore = vaultTotalAssets(vaultId); + uint256 totalSharesBefore = vaultTotalShares(vaultId); + + uint256 protocolVaultBalanceBefore = address(getProtocolVault()) + .balance; + + ( + uint256 subjectId, + uint256 predicateId, + uint256 objectId + ) = actEthMultiVault.getTripleAtoms(vaultId); + + uint256[3] memory totalAssetsBeforeAtomVaults = [ + vaultTotalAssets(subjectId), + vaultTotalAssets(predicateId), + vaultTotalAssets(objectId) + ]; + uint256[3] memory totalSharesBeforeAtomVaults = [ + vaultTotalShares(subjectId), + vaultTotalShares(predicateId), + vaultTotalShares(objectId) + ]; + + // deposit triple + shares = actEthMultiVault.depositTriple{value: msgValue}( + receiver, + vaultId + ); + + uint256 userDepositAfterProtocolFees = msgValue - + getProtocolFeeAmount(msgValue, vaultId); + + checkDepositIntoVault( + userDepositAfterProtocolFees, + vaultId, + totalAssetsBefore, + totalSharesBefore + ); + + checkProtocolVaultBalance( + vaultId, + msgValue, + protocolVaultBalanceBefore + ); + + uint256 amountToDistribute = atomDepositFractionAmount( + userDepositAfterProtocolFees, + vaultId + ); + uint256 distributeAmountPerAtomVault = amountToDistribute / 3; + + checkDepositIntoVault( + distributeAmountPerAtomVault, + subjectId, + totalAssetsBeforeAtomVaults[0], + totalSharesBeforeAtomVaults[0] + ); + + checkDepositIntoVault( + distributeAmountPerAtomVault, + predicateId, + totalAssetsBeforeAtomVaults[1], + totalSharesBeforeAtomVaults[1] + ); + + checkDepositIntoVault( + distributeAmountPerAtomVault, + objectId, + totalAssetsBeforeAtomVaults[2], + totalSharesBeforeAtomVaults[2] + ); + } + + function _redeemTripleChecks( + uint256 shares2Redeem, + address receiver, + uint256 vaultId + ) internal returns (uint256 assetsForReceiver) { + // snapshots before redeem + uint256 protocolVaultBalanceBefore = address(getProtocolVault()) + .balance; + uint256 userSharesBeforeRedeem = getSharesInVault(vaultId, receiver); + uint256 userBalanceBeforeRedeem = address(receiver).balance; + + uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees( + userSharesBeforeRedeem, + vaultId + ); + // redeem triple + assetsForReceiver = actEthMultiVault.redeemTriple( + shares2Redeem, + receiver, + vaultId + ); + + checkProtocolVaultBalance( + vaultId, + assetsForReceiverBeforeFees, + protocolVaultBalanceBefore + ); + + assertEq( + getSharesInVault(vaultId, receiver), + userSharesBeforeRedeem - shares2Redeem + ); + assertEq( + address(receiver).balance - userBalanceBeforeRedeem, + assetsForReceiver + ); + } } diff --git a/test/invariant/actors/EthMultiVaultSingleVaultActor.sol b/test/invariant/actors/EthMultiVaultSingleVaultActor.sol index 1c5ec1a4..348eeeb9 100644 --- a/test/invariant/actors/EthMultiVaultSingleVaultActor.sol +++ b/test/invariant/actors/EthMultiVaultSingleVaultActor.sol @@ -35,11 +35,10 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { actorPks.push(i + 1); actors.push(vm.addr(actorPks[i])); } - //vm.deal(actors[0], 1 ether); - //vm.prank(actors[0]); - //actEthMultiVault.createAtom{value: actEthMultiVault.getAtomCost()}("PEPE"); } + receive() external payable {} + function getVaultTotalAssets(uint256 vaultId) public view returns (uint256 totalAssets) { (totalAssets,) = actEthMultiVault.vaults(vaultId); } @@ -179,7 +178,7 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { return assetsForReceiver; } - function depositTriple(address _receiver, uint256 msgValue, uint256 actorIndexSeed) + function depositTriple(address receiver, uint256 msgValue, uint256 actorIndexSeed) public useActor(actorIndexSeed) returns (uint256) @@ -193,29 +192,18 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); emit log_named_uint("msgValue------------", msgValue); - uint256 _vaultId = 1; - emit log_named_uint("vaultTotalAssets----", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultTotalShares----", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + uint256 vaultId = 4; + emit log_named_uint("vaultTotalAssets----", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultTotalShares----", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); // bound _receiver to msg.sender always - _receiver = currentActor; + receiver = currentActor; // bound msgValue to between minDeposit and 10 ether - msgValue = bound(msgValue, getAtomCost(), 10 ether); + msgValue = bound(msgValue, getTripleCost(), 10 ether); vm.deal(currentActor, msgValue); - uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); - uint256 totalSharesBefore = vaultTotalShares(_vaultId); - - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - - // deposit atom - uint256 shares = actEthMultiVault.depositTriple{value: msgValue}(_receiver, _vaultId); - - checkDepositIntoVault( - msgValue - getProtocolFeeAmount(msgValue, _vaultId), _vaultId, totalAssetsBefore, totalSharesBefore - ); - - checkProtocolVaultBalance(_vaultId, msgValue, protocolVaultBalanceBefore); + // deposit triple + uint256 shares = _depositTripleChecks(vaultId, msgValue, receiver); // logs emit log_named_uint( @@ -224,16 +212,16 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { emit log_named_uint("balance currentActor", currentActor.balance); emit log_named_uint("balance EthMultiVaultbal-", address(actEthMultiVault).balance); emit log_named_uint("balance this--------", address(this).balance); - emit log_named_uint("vaultTotalShares----", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultTAssets--------", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint("vaultTotalShares----", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultTAssets--------", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); emit log_named_uint( "==================================== ACTOR depositTriple END ====================================", shares ); return shares; } - function redeemTriple(uint256 _shares2Redeem, address _receiver, uint256 msgValue, uint256 actorIndexSeed) + function redeemTriple(uint256 shares2Redeem, address receiver, uint256 msgValue, uint256 actorIndexSeed) public useActor(actorIndexSeed) returns (uint256) @@ -247,51 +235,35 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); emit log_named_uint("msgValue------------", msgValue); - uint256 _vaultId = 1; + uint256 vaultId = 4; // if vault balance of the selected vault is 0, deposit minDeposit - if (getVaultBalanceForAddress(_vaultId, currentActor) == 0) { + if (getVaultBalanceForAddress(vaultId, currentActor) == 0) { vm.deal(currentActor, 10 ether); - msgValue = bound(msgValue, getAtomCost(), 10 ether); - _shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}(currentActor, _vaultId); - emit log_named_uint("_shares2Redeem", _shares2Redeem); + msgValue = bound(msgValue, getTripleCost(), 10 ether); + shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}(currentActor, vaultId); + emit log_named_uint("_shares2Redeem", shares2Redeem); } else { // bound _shares2Redeem to between 1 and vaultBalanceOf - _shares2Redeem = bound(_shares2Redeem, 1, getVaultBalanceForAddress(_vaultId, currentActor)); - emit log_named_uint("_shares2Redeem", _shares2Redeem); + shares2Redeem = bound(shares2Redeem, 1, getVaultBalanceForAddress(vaultId, currentActor)); + emit log_named_uint("_shares2Redeem", shares2Redeem); } // use the redeemer as the receiver always - _receiver = currentActor; + receiver = currentActor; - emit log_named_uint("before vaultTotalShares--", getVaultTotalShares(_vaultId)); - emit log_named_uint("before vaultTAssets------", getVaultTotalAssets(_vaultId)); - emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); - - // snapshots before redeem - uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - uint256 userSharesBeforeRedeem = getSharesInVault(_vaultId, _receiver); - uint256 userBalanceBeforeRedeem = address(_receiver).balance; - - uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, _vaultId); - - // redeem atom - uint256 assetsForReceiver = actEthMultiVault.redeemTriple(_shares2Redeem, _receiver, _vaultId); - - checkProtocolVaultBalance(_vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); - - // snapshots after redeem - uint256 userSharesAfterRedeem = getSharesInVault(_vaultId, _receiver); - uint256 userBalanceAfterRedeem = address(_receiver).balance; - - assertEq(userSharesAfterRedeem, userSharesBeforeRedeem - _shares2Redeem); - assertEq(userBalanceAfterRedeem - userBalanceBeforeRedeem, assetsForReceiver); + emit log_named_uint("before vaultTotalShares--", getVaultTotalShares(vaultId)); + emit log_named_uint("before vaultTAssets------", getVaultTotalAssets(vaultId)); + emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(vaultId, currentActor)); + // redeem triple + uint256 assetsForReceiver = _redeemTripleChecks(shares2Redeem, receiver, vaultId); + // logs emit log_named_uint( "------------------------------------ POST STATE -------------------------------------------", 6000000009 ); - emit log_named_uint("vaultTotalShares--", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultTAssets------", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint("vaultTotalShares--", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultTAssets------", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(vaultId, currentActor)); emit log_named_uint( "==================================== ACTOR redeemTriple END ====================================", assetsForReceiver @@ -299,5 +271,118 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { return assetsForReceiver; } - receive() external payable {} + function _depositTripleChecks( + uint256 vaultId, + uint256 msgValue, + address receiver + ) internal returns (uint256 shares) { + uint256 totalAssetsBefore = vaultTotalAssets(vaultId); + uint256 totalSharesBefore = vaultTotalShares(vaultId); + + uint256 protocolVaultBalanceBefore = address(getProtocolVault()) + .balance; + + ( + uint256 subjectId, + uint256 predicateId, + uint256 objectId + ) = actEthMultiVault.getTripleAtoms(vaultId); + + uint256[3] memory totalAssetsBeforeAtomVaults = [ + vaultTotalAssets(subjectId), + vaultTotalAssets(predicateId), + vaultTotalAssets(objectId) + ]; + uint256[3] memory totalSharesBeforeAtomVaults = [ + vaultTotalShares(subjectId), + vaultTotalShares(predicateId), + vaultTotalShares(objectId) + ]; + + shares = actEthMultiVault.depositTriple{value: msgValue}( + receiver, + vaultId + ); + + uint256 userDepositAfterProtocolFees = msgValue - + getProtocolFeeAmount(msgValue, vaultId); + + checkDepositIntoVault( + userDepositAfterProtocolFees, + vaultId, + totalAssetsBefore, + totalSharesBefore + ); + + checkProtocolVaultBalance( + vaultId, + msgValue, + protocolVaultBalanceBefore + ); + + uint256 amountToDistribute = atomDepositFractionAmount( + userDepositAfterProtocolFees, + vaultId + ); + uint256 distributeAmountPerAtomVault = amountToDistribute / 3; + + checkDepositIntoVault( + distributeAmountPerAtomVault, + subjectId, + totalAssetsBeforeAtomVaults[0], + totalSharesBeforeAtomVaults[0] + ); + + checkDepositIntoVault( + distributeAmountPerAtomVault, + predicateId, + totalAssetsBeforeAtomVaults[1], + totalSharesBeforeAtomVaults[1] + ); + + checkDepositIntoVault( + distributeAmountPerAtomVault, + objectId, + totalAssetsBeforeAtomVaults[2], + totalSharesBeforeAtomVaults[2] + ); + } + + function _redeemTripleChecks( + uint256 shares2Redeem, + address receiver, + uint256 vaultId + ) internal returns (uint256 assetsForReceiver) { + // snapshots before redeem + uint256 protocolVaultBalanceBefore = address(getProtocolVault()) + .balance; + uint256 userSharesBeforeRedeem = getSharesInVault(vaultId, receiver); + uint256 userBalanceBeforeRedeem = address(receiver).balance; + + uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees( + userSharesBeforeRedeem, + vaultId + ); + // redeem triple + assetsForReceiver = actEthMultiVault.redeemTriple( + shares2Redeem, + receiver, + vaultId + ); + + checkProtocolVaultBalance( + vaultId, + assetsForReceiverBeforeFees, + protocolVaultBalanceBefore + ); + + assertEq( + getSharesInVault(vaultId, receiver), + userSharesBeforeRedeem - shares2Redeem + ); + assertEq( + address(receiver).balance - userBalanceBeforeRedeem, + assetsForReceiver + ); + } } From 0c36cd74f729c1a32aa46a9bcbb6d367dbd23253 Mon Sep 17 00:00:00 2001 From: mihailo-maksa Date: Thu, 23 May 2024 21:56:24 +0200 Subject: [PATCH 3/3] formatting and cleanup --- test/invariant/actors/EthMultiVaultActor.sol | 739 +++++------------- .../actors/EthMultiVaultSingleVaultActor.sol | 206 ++--- 2 files changed, 266 insertions(+), 679 deletions(-) diff --git a/test/invariant/actors/EthMultiVaultActor.sol b/test/invariant/actors/EthMultiVaultActor.sol index 6861047e..c1cd983c 100644 --- a/test/invariant/actors/EthMultiVaultActor.sol +++ b/test/invariant/actors/EthMultiVaultActor.sol @@ -43,47 +43,30 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { receive() external payable {} - function getVaultTotalAssets( - uint256 vaultId - ) public view returns (uint256 totalAssets) { - (totalAssets, ) = actEthMultiVault.vaults(vaultId); + function getVaultTotalAssets(uint256 vaultId) public view returns (uint256 totalAssets) { + (totalAssets,) = actEthMultiVault.vaults(vaultId); } - function getVaultTotalShares( - uint256 vaultId - ) public view returns (uint256 totalShares) { + function getVaultTotalShares(uint256 vaultId) public view returns (uint256 totalShares) { (, totalShares) = actEthMultiVault.vaults(vaultId); } - function getVaultBalanceForAddress( - uint256 vaultId, - address user - ) public view returns (uint256) { - (uint256 shares, ) = actEthMultiVault.getVaultStateForUser( - vaultId, - user - ); + function getVaultBalanceForAddress(uint256 vaultId, address user) public view returns (uint256) { + (uint256 shares,) = actEthMultiVault.getVaultStateForUser(vaultId, user); return shares; } - function getAssetsForReceiverBeforeFees( - uint256 shares, - uint256 vaultId - ) public view returns (uint256) { - ( - , - uint256 calculatedAssetsForReceiver, - uint256 protocolFees, - uint256 exitFees - ) = actEthMultiVault.getRedeemAssetsAndFees(shares, vaultId); + function getAssetsForReceiverBeforeFees(uint256 shares, uint256 vaultId) public view returns (uint256) { + (, uint256 calculatedAssetsForReceiver, uint256 protocolFees, uint256 exitFees) = + actEthMultiVault.getRedeemAssetsAndFees(shares, vaultId); return calculatedAssetsForReceiver + protocolFees + exitFees; } - function createAtom( - bytes calldata _data, - uint256 msgValue, - uint256 actorIndexSeed - ) public useActor(actorIndexSeed) returns (uint256) { + function createAtom(bytes calldata data, uint256 msgValue, uint256 actorIndexSeed) + public + useActor(actorIndexSeed) + returns (uint256) + { numberOfCalls++; numberOfAtoms++; emit log_named_uint( @@ -107,204 +90,128 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { vm.deal(currentActor, msgValue); } } - emit log_named_uint( - "msg.sender.balance Right before create", - currentActor.balance - ); + emit log_named_uint("msg.sender.balance Right before create", currentActor.balance); emit log_named_address("msg.sender-----", currentActor); uint256 totalAssetsBefore = vaultTotalAssets(ethMultiVault.count() + 1); uint256 totalSharesBefore = vaultTotalShares(ethMultiVault.count() + 1); - uint256 protocolVaultBalanceBefore = address(getProtocolVault()) - .balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; // create atom - uint256 id = actEthMultiVault.createAtom{value: msgValue}(_data); + uint256 id = actEthMultiVault.createAtom{value: msgValue}(data); assertEq(id, actEthMultiVault.count()); - checkDepositOnAtomVaultCreation( - id, - msgValue, - totalAssetsBefore, - totalSharesBefore - ); + checkDepositOnAtomVaultCreation(id, msgValue, totalAssetsBefore, totalSharesBefore); uint256 userDeposit = msgValue - getAtomCost(); - checkProtocolVaultBalanceOnVaultCreation( - id, - userDeposit, - protocolVaultBalanceBefore - ); + checkProtocolVaultBalanceOnVaultCreation(id, userDeposit, protocolVaultBalanceBefore); // logs emit log_named_uint( - "------------------------------------ POST STATE ------------------------------------------", - 6000000009 + "------------------------------------ POST STATE ------------------------------------------", 6000000009 ); emit log_named_uint("msg.sender.balance", currentActor.balance); emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(id)); emit log_named_uint("vaultTAssets------", getVaultTotalShares(id)); emit log_named_uint( - "==================================== ACTOR createAtom END ====================================", - id + "==================================== ACTOR createAtom END ====================================", id ); return id; } function depositAtom( - address _receiver, - uint256 _vaultId, + address receiver, + uint256 vaultId, uint256 msgValue, - bytes calldata _data, + bytes calldata data, uint256 actorIndexSeed ) public useActor(actorIndexSeed) returns (uint256) { numberOfCalls++; numberOfAtomDeposits++; emit log_named_uint( - "==================================== ACTOR depositAtom ====================================", - 6000000009 + "==================================== ACTOR depositAtom ====================================", 6000000009 ); emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); emit log_named_uint("msgValue------------", msgValue); - // bound _receiver to msg.sender always - _receiver = currentActor; + // bound receiver to msg.sender always + receiver = currentActor; uint256 shares; // if no atom exist yet, create and deposit on one if (actEthMultiVault.count() == 0) { vm.deal(currentActor, getAtomCost()); - _vaultId = actEthMultiVault.createAtom{value: getAtomCost()}(_data); - emit log_named_uint( - "vaultTotalAssets----", - getVaultTotalShares(_vaultId) - ); - emit log_named_uint( - "vaultTotalShares----", - getVaultTotalAssets(_vaultId) - ); - emit log_named_uint( - "vaultBalanceOf------", - getVaultBalanceForAddress(_vaultId, currentActor) - ); + vaultId = actEthMultiVault.createAtom{value: getAtomCost()}(data); + emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); msgValue = bound(msgValue, getMinDeposit(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint( - "|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", - 1 - ); + emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); - uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); - uint256 totalSharesBefore = vaultTotalShares(_vaultId); + uint256 totalAssetsBefore = vaultTotalAssets(vaultId); + uint256 totalSharesBefore = vaultTotalShares(vaultId); - uint256 protocolVaultBalanceBefore = address(getProtocolVault()) - .balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - shares = actEthMultiVault.depositAtom{value: msgValue}( - _receiver, - _vaultId - ); + shares = actEthMultiVault.depositAtom{value: msgValue}(receiver, vaultId); checkDepositIntoVault( - msgValue - getProtocolFeeAmount(msgValue, _vaultId), - _vaultId, - totalAssetsBefore, - totalSharesBefore + msgValue - getProtocolFeeAmount(msgValue, vaultId), vaultId, totalAssetsBefore, totalSharesBefore ); - checkProtocolVaultBalance( - _vaultId, - msgValue, - protocolVaultBalanceBefore - ); + checkProtocolVaultBalance(vaultId, msgValue, protocolVaultBalanceBefore); } else { // deposit on existing vault - // bound _vaultId between 1 and count() - if (_vaultId == 0 || _vaultId > actEthMultiVault.count()) { - _vaultId = bound(_vaultId, 1, actEthMultiVault.count()); + // bound vaultId between 1 and count() + if (vaultId == 0 || vaultId > actEthMultiVault.count()) { + vaultId = bound(vaultId, 1, actEthMultiVault.count()); } - emit log_named_uint( - "vaultTotalAssets----", - getVaultTotalShares(_vaultId) - ); - emit log_named_uint( - "vaultTotalShares----", - getVaultTotalAssets(_vaultId) - ); - emit log_named_uint( - "vaultBalanceOf------", - getVaultBalanceForAddress(_vaultId, currentActor) - ); + emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); // bound msgValue to between minDeposit and 10 ether msgValue = bound(msgValue, getAtomCost(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint( - "|||||||||||||||||||||||||||||||||||BRANCH 2|||||||||||||||||||||||||||||||||||", - 2 - ); + emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 2|||||||||||||||||||||||||||||||||||", 2); - uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); - uint256 totalSharesBefore = vaultTotalShares(_vaultId); + uint256 totalAssetsBefore = vaultTotalAssets(vaultId); + uint256 totalSharesBefore = vaultTotalShares(vaultId); - uint256 protocolVaultBalanceBefore = address(getProtocolVault()) - .balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - shares = actEthMultiVault.depositAtom{value: msgValue}( - _receiver, - _vaultId - ); + shares = actEthMultiVault.depositAtom{value: msgValue}(receiver, vaultId); checkDepositIntoVault( - msgValue - getProtocolFeeAmount(msgValue, _vaultId), - _vaultId, - totalAssetsBefore, - totalSharesBefore + msgValue - getProtocolFeeAmount(msgValue, vaultId), vaultId, totalAssetsBefore, totalSharesBefore ); - checkProtocolVaultBalance( - _vaultId, - msgValue, - protocolVaultBalanceBefore - ); + checkProtocolVaultBalance(vaultId, msgValue, protocolVaultBalanceBefore); } // deposit atom emit log_named_uint("balance currentActor", currentActor.balance); - emit log_named_uint( - "balance EthMultiVaultbal-", - address(actEthMultiVault).balance - ); + emit log_named_uint("balance EthMultiVaultbal-", address(actEthMultiVault).balance); emit log_named_uint("balance this--------", address(this).balance); // logs emit log_named_uint( - "------------------------------------ POST STATE -------------------------------------------", - 6000000009 - ); - emit log_named_uint( - "vaultTotalShares----", - getVaultTotalAssets(_vaultId) - ); - emit log_named_uint( - "vaultTAssets--------", - getVaultTotalShares(_vaultId) + "------------------------------------ POST STATE -------------------------------------------", 6000000009 ); + emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultTAssets--------", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); emit log_named_uint( - "vaultBalanceOf------", - getVaultBalanceForAddress(_vaultId, currentActor) - ); - emit log_named_uint( - "==================================== ACTOR depositAtom ====================================", - shares + "==================================== ACTOR depositAtom ====================================", shares ); return shares; } function redeemAtom( - uint256 _shares2Redeem, - address _receiver, - uint256 _vaultId, + uint256 shares2Redeem, + address receiver, + uint256 vaultId, uint256 msgValue, - bytes calldata _data, + bytes calldata data, uint256 actorIndexSeed ) public useActor(actorIndexSeed) returns (uint256) { numberOfCalls++; @@ -319,136 +226,65 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { // if no atom vaults exist create one and deposit on it if (actEthMultiVault.count() == 0) { vm.deal(currentActor, getAtomCost()); - _vaultId = actEthMultiVault.createAtom{value: getAtomCost()}(_data); + vaultId = actEthMultiVault.createAtom{value: getAtomCost()}(data); msgValue = bound(msgValue, getMinDeposit(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint( - "|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", - 1 - ); - _shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}( - currentActor, - 1 - ); + emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); + shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}(currentActor, 1); } else { // vault exists - // bound _vaultId between 1 and count() - if (_vaultId == 0 || _vaultId > actEthMultiVault.count()) { - _vaultId = bound(_vaultId, 1, actEthMultiVault.count()); + // bound vaultId between 1 and count() + if (vaultId == 0 || vaultId > actEthMultiVault.count()) { + vaultId = bound(vaultId, 1, actEthMultiVault.count()); } // if vault balance of the selected vault is 0, deposit minDeposit - if (getVaultBalanceForAddress(_vaultId, currentActor) == 0) { + if (getVaultBalanceForAddress(vaultId, currentActor) == 0) { vm.deal(currentActor, 10 ether); - emit log_named_uint( - "vaultTShares--", - getVaultTotalAssets(_vaultId) - ); - emit log_named_uint( - "vaultTAssets--", - getVaultTotalShares(_vaultId) - ); - emit log_named_uint( - "vaultBalanceOf", - getVaultBalanceForAddress(_vaultId, currentActor) - ); + emit log_named_uint("vaultTShares--", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultTAssets--", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultBalanceOf", getVaultBalanceForAddress(vaultId, currentActor)); msgValue = bound(msgValue, getAtomCost(), 10 ether); - emit log_named_uint( - "REEEE getVaultTotalAssets(_vaultId)", - getVaultTotalAssets(_vaultId) - ); - emit log_named_uint( - "REEEE getVaultTotalShares(_vaultId)", - getVaultTotalShares(_vaultId) - ); - emit log_named_uint( - "|||||||||||||||||||||||||||||||BRANCH 2||||||||||||||||||||||||||||||||||||", - 2 - ); - _shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}( - currentActor, - _vaultId - ); - emit log_named_uint("_shares2Redeem", _shares2Redeem); + emit log_named_uint("REEEE getVaultTotalAssets(vaultId)", getVaultTotalAssets(vaultId)); + emit log_named_uint("REEEE getVaultTotalShares(vaultId)", getVaultTotalShares(vaultId)); + emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 2||||||||||||||||||||||||||||||||||||", 2); + shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}(currentActor, vaultId); + emit log_named_uint("shares2Redeem", shares2Redeem); } else { - emit log_named_uint( - "|||||||||||||||||||||||||||||||BRANCH 3||||||||||||||||||||||||||||||||||||", - 3 - ); - // bound _shares2Redeem to between 1 and vaultBalanceOf - _shares2Redeem = bound( - _shares2Redeem, - 1, - getVaultBalanceForAddress(_vaultId, currentActor) - ); - emit log_named_uint("_shares2Redeem", _shares2Redeem); + emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 3||||||||||||||||||||||||||||||||||||", 3); + // bound shares2Redeem to between 1 and vaultBalanceOf + shares2Redeem = bound(shares2Redeem, 1, getVaultBalanceForAddress(vaultId, currentActor)); + emit log_named_uint("shares2Redeem", shares2Redeem); } } // use the redeemer as the receiver always - _receiver = currentActor; + receiver = currentActor; - emit log_named_uint( - "before vaultTotalShares--", - getVaultTotalAssets(_vaultId) - ); - emit log_named_uint( - "before vaultTAssets------", - getVaultTotalShares(_vaultId) - ); - emit log_named_uint( - "before vaultBalanceOf----", - getVaultBalanceForAddress(_vaultId, currentActor) - ); + emit log_named_uint("before vaultTotalShares--", getVaultTotalAssets(vaultId)); + emit log_named_uint("before vaultTAssets------", getVaultTotalShares(vaultId)); + emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(vaultId, currentActor)); // snapshots before redeem - uint256 protocolVaultBalanceBefore = address(getProtocolVault()) - .balance; - uint256 userSharesBeforeRedeem = getSharesInVault(_vaultId, _receiver); - uint256 userBalanceBeforeRedeem = address(_receiver).balance; - - uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees( - userSharesBeforeRedeem, - _vaultId - ); + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + uint256 userSharesBeforeRedeem = getSharesInVault(vaultId, receiver); + uint256 userBalanceBeforeRedeem = address(receiver).balance; + + uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, vaultId); // redeem atom - uint256 assetsForReceiver = actEthMultiVault.redeemAtom( - _shares2Redeem, - _receiver, - _vaultId - ); + uint256 assetsForReceiver = actEthMultiVault.redeemAtom(shares2Redeem, receiver, vaultId); - checkProtocolVaultBalance( - _vaultId, - assetsForReceiverBeforeFees, - protocolVaultBalanceBefore - ); + checkProtocolVaultBalance(vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); - assertEq( - getSharesInVault(_vaultId, _receiver), - userSharesBeforeRedeem - _shares2Redeem - ); - assertEq( - address(_receiver).balance - userBalanceBeforeRedeem, - assetsForReceiver - ); + assertEq(getSharesInVault(vaultId, receiver), userSharesBeforeRedeem - shares2Redeem); + assertEq(address(receiver).balance - userBalanceBeforeRedeem, assetsForReceiver); // logs emit log_named_uint( - "------------------------------------ POST STATE -------------------------------------------", - 6000000009 - ); - emit log_named_uint( - "vaultTotalShares--", - getVaultTotalAssets(_vaultId) - ); - emit log_named_uint( - "vaultTAssets------", - getVaultTotalShares(_vaultId) - ); - emit log_named_uint( - "vaultBalanceOf----", - getVaultBalanceForAddress(_vaultId, currentActor) + "------------------------------------ POST STATE -------------------------------------------", 6000000009 ); + emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultTAssets------", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(vaultId, currentActor)); emit log_named_uint( "==================================== ACTOR redeemAtom END ====================================", assetsForReceiver @@ -486,86 +322,56 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { vm.deal(currentActor, msgValue); } } - emit log_named_uint( - "msg.sender.balance Right before create", - currentActor.balance - ); + emit log_named_uint("msg.sender.balance Right before create", currentActor.balance); emit log_named_address("msg.sender-----", currentActor); - uint256 vaultId = _createTripleChecks( - msgValue, - subjectId, - predicateId, - objectId - ); + uint256 vaultId = _createTripleChecks(msgValue, subjectId, predicateId, objectId); // logs emit log_named_uint( - "------------------------------------ POST STATE ------------------------------------------", - 6000000009 + "------------------------------------ POST STATE ------------------------------------------", 6000000009 ); emit log_named_uint("msg.sender.balance", currentActor.balance); emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(vaultId)); emit log_named_uint("vaultTAssets------", getVaultTotalShares(vaultId)); emit log_named_uint( - "==================================== ACTOR createTriple END ====================================", - vaultId + "==================================== ACTOR createTriple END ====================================", vaultId ); return vaultId; } - function depositTriple( - address receiver, - uint256 vaultId, - uint256 msgValue, - uint256 actorIndexSeed - ) public useActor(actorIndexSeed) returns (uint256) { + function depositTriple(address receiver, uint256 vaultId, uint256 msgValue, uint256 actorIndexSeed) + public + useActor(actorIndexSeed) + returns (uint256) + { numberOfCalls++; numberOfTripleDeposits++; emit log_named_uint( - "==================================== ACTOR depositTriple ====================================", - 6000000009 + "==================================== ACTOR depositTriple ====================================", 6000000009 ); emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); emit log_named_uint("msgValue------------", msgValue); - // bound _receiver to msg.sender always + // bound receiver to msg.sender always receiver = currentActor; uint256 shares; // if no triple exist yet, create and deposit on one if (actEthMultiVault.count() == 0) { vm.deal(currentActor, getTripleCost()); - vaultId = actEthMultiVault.createTriple{value: getTripleCost()}( - 1, - 2, - 3 - ); - emit log_named_uint( - "vaultTotalAssets----", - getVaultTotalShares(vaultId) - ); - emit log_named_uint( - "vaultTotalShares----", - getVaultTotalAssets(vaultId) - ); - emit log_named_uint( - "vaultBalanceOf------", - getVaultBalanceForAddress(vaultId, currentActor) - ); + vaultId = actEthMultiVault.createTriple{value: getTripleCost()}(1, 2, 3); + emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); msgValue = bound(msgValue, getMinDeposit(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint( - "|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", - 1 - ); + emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); _createTripleChecks(msgValue, 1, 2, 3); } else { // vault exists if (vaultId == 0 || vaultId > actEthMultiVault.count()) { - uint256[] memory tripleVaults = new uint256[]( - actEthMultiVault.count() - ); + uint256[] memory tripleVaults = new uint256[](actEthMultiVault.count()); uint256 tripleVaultsCount = 0; for (uint256 i = 1; i <= actEthMultiVault.count(); i++) { if (actEthMultiVault.isTripleId(i)) { @@ -574,60 +380,32 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { } } - vaultId = tripleVaults[ - bound(actorIndexSeed, 0, tripleVaultsCount - 1) - ]; + vaultId = tripleVaults[bound(actorIndexSeed, 0, tripleVaultsCount - 1)]; } - emit log_named_uint( - "vaultTotalAssets----", - getVaultTotalShares(vaultId) - ); - emit log_named_uint( - "vaultTotalShares----", - getVaultTotalAssets(vaultId) - ); - emit log_named_uint( - "vaultBalanceOf------", - getVaultBalanceForAddress(vaultId, currentActor) - ); + emit log_named_uint("vaultTotalAssets----", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); // bound msgValue to between minDeposit and 10 ether msgValue = bound(msgValue, getTripleCost(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint( - "|||||||||||||||||||||||||||||||||||BRANCH 2|||||||||||||||||||||||||||||||||||", - 2 - ); + emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 2|||||||||||||||||||||||||||||||||||", 2); shares = _depositTripleChecks(vaultId, msgValue, receiver); } // deposit triple emit log_named_uint("balance currentActor", currentActor.balance); - emit log_named_uint( - "balance EthMultiVaultbal-", - address(actEthMultiVault).balance - ); + emit log_named_uint("balance EthMultiVaultbal-", address(actEthMultiVault).balance); emit log_named_uint("balance this--------", address(this).balance); // logs emit log_named_uint( - "------------------------------------ POST STATE -------------------------------------------", - 6000000009 - ); - emit log_named_uint( - "vaultTotalShares----", - getVaultTotalAssets(vaultId) + "------------------------------------ POST STATE -------------------------------------------", 6000000009 ); + emit log_named_uint("vaultTotalShares----", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultTAssets--------", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); emit log_named_uint( - "vaultTAssets--------", - getVaultTotalShares(vaultId) - ); - emit log_named_uint( - "vaultBalanceOf------", - getVaultBalanceForAddress(vaultId, currentActor) - ); - emit log_named_uint( - "==================================== ACTOR depositTriple ====================================", - shares + "==================================== ACTOR depositTriple ====================================", shares ); return shares; } @@ -655,21 +433,12 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { msgValue = bound(msgValue, getMinDeposit(), 10 ether); vm.deal(currentActor, msgValue); - emit log_named_uint( - "|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", - 1 - ); - shares2Redeem = _depositTripleChecks( - vaultId, - msgValue, - currentActor - ); + emit log_named_uint("|||||||||||||||||||||||||||||||||||BRANCH 1|||||||||||||||||||||||||||||||||||", 1); + shares2Redeem = _depositTripleChecks(vaultId, msgValue, currentActor); } else { // vault exists if (vaultId == 0 || vaultId > actEthMultiVault.count()) { - uint256[] memory tripleVaults = new uint256[]( - actEthMultiVault.count() - ); + uint256[] memory tripleVaults = new uint256[](actEthMultiVault.count()); uint256 tripleVaultsCount = 0; for (uint256 i = 1; i <= actEthMultiVault.count(); i++) { if (actEthMultiVault.isTripleId(i)) { @@ -678,92 +447,45 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { } } - vaultId = tripleVaults[ - bound(actorIndexSeed, 0, tripleVaultsCount - 1) - ]; + vaultId = tripleVaults[bound(actorIndexSeed, 0, tripleVaultsCount - 1)]; } // if vault balance of the selected vault is 0, deposit minDeposit if (getVaultBalanceForAddress(vaultId, currentActor) == 0) { vm.deal(currentActor, 10 ether); - emit log_named_uint( - "vaultTShares--", - getVaultTotalAssets(vaultId) - ); - emit log_named_uint( - "vaultTAssets--", - getVaultTotalShares(vaultId) - ); - emit log_named_uint( - "vaultBalanceOf", - getVaultBalanceForAddress(vaultId, currentActor) - ); + emit log_named_uint("vaultTShares--", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultTAssets--", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultBalanceOf", getVaultBalanceForAddress(vaultId, currentActor)); msgValue = bound(msgValue, getTripleCost(), 10 ether); - emit log_named_uint( - "REEEE getVaultTotalAssets(_vaultId)", - getVaultTotalAssets(vaultId) - ); - emit log_named_uint( - "REEEE getVaultTotalShares(_vaultId)", - getVaultTotalShares(vaultId) - ); - emit log_named_uint( - "|||||||||||||||||||||||||||||||BRANCH 2||||||||||||||||||||||||||||||||||||", - 2 - ); - shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}( - currentActor, - vaultId - ); + emit log_named_uint("REEEE getVaultTotalAssets(vaultId)", getVaultTotalAssets(vaultId)); + emit log_named_uint("REEEE getVaultTotalShares(vaultId)", getVaultTotalShares(vaultId)); + emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 2||||||||||||||||||||||||||||||||||||", 2); + shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}(currentActor, vaultId); _depositTripleChecks(vaultId, msgValue, receiver); - emit log_named_uint("_shares2Redeem", shares2Redeem); + emit log_named_uint("shares2Redeem", shares2Redeem); } else { - emit log_named_uint( - "|||||||||||||||||||||||||||||||BRANCH 3||||||||||||||||||||||||||||||||||||", - 3 - ); - // bound _shares2Redeem to between 1 and vaultBalanceOf - shares2Redeem = bound( - shares2Redeem, - 1, - getVaultBalanceForAddress(vaultId, currentActor) - ); - emit log_named_uint("_shares2Redeem", shares2Redeem); + emit log_named_uint("|||||||||||||||||||||||||||||||BRANCH 3||||||||||||||||||||||||||||||||||||", 3); + // bound shares2Redeem to between 1 and vaultBalanceOf + shares2Redeem = bound(shares2Redeem, 1, getVaultBalanceForAddress(vaultId, currentActor)); + emit log_named_uint("shares2Redeem", shares2Redeem); } } // use the redeemer as the receiver always receiver = currentActor; - emit log_named_uint( - "before vaultTotalShares--", - getVaultTotalAssets(vaultId) - ); - emit log_named_uint( - "before vaultTAssets------", - getVaultTotalShares(vaultId) - ); - emit log_named_uint( - "before vaultBalanceOf----", - getVaultBalanceForAddress(vaultId, currentActor) - ); + emit log_named_uint("before vaultTotalShares--", getVaultTotalAssets(vaultId)); + emit log_named_uint("before vaultTAssets------", getVaultTotalShares(vaultId)); + emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(vaultId, currentActor)); - uint256 assetsForReceiver = _redeemTripleChecks( - shares2Redeem, - receiver, - vaultId - ); + uint256 assetsForReceiver = _redeemTripleChecks(shares2Redeem, receiver, vaultId); // logs emit log_named_uint( - "------------------------------------ POST STATE -------------------------------------------", - 6000000009 + "------------------------------------ POST STATE -------------------------------------------", 6000000009 ); emit log_named_uint("vaultTotalShares--", getVaultTotalAssets(vaultId)); emit log_named_uint("vaultTAssets------", getVaultTotalShares(vaultId)); - emit log_named_uint( - "vaultBalanceOf----", - getVaultBalanceForAddress(vaultId, currentActor) - ); + emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(vaultId, currentActor)); emit log_named_uint( "==================================== ACTOR redeemTriple END ====================================", assetsForReceiver @@ -771,51 +493,32 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { return assetsForReceiver; } - function _createTripleChecks( - uint256 msgValue, - uint256 subjectId, - uint256 predicateId, - uint256 objectId - ) internal returns (uint256 vaultId) { + function _createTripleChecks(uint256 msgValue, uint256 subjectId, uint256 predicateId, uint256 objectId) + internal + returns (uint256 vaultId) + { uint256 totalAssetsBefore = vaultTotalAssets(ethMultiVault.count() + 1); uint256 totalSharesBefore = vaultTotalShares(ethMultiVault.count() + 1); - uint256 protocolVaultBalanceBefore = address(getProtocolVault()) - .balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - uint256[3] memory totalAssetsBeforeAtomVaults = [ - vaultTotalAssets(subjectId), - vaultTotalAssets(predicateId), - vaultTotalAssets(objectId) - ]; - uint256[3] memory totalSharesBeforeAtomVaults = [ - vaultTotalShares(subjectId), - vaultTotalShares(predicateId), - vaultTotalShares(objectId) - ]; + uint256[3] memory totalAssetsBeforeAtomVaults = + [vaultTotalAssets(subjectId), vaultTotalAssets(predicateId), vaultTotalAssets(objectId)]; + uint256[3] memory totalSharesBeforeAtomVaults = + [vaultTotalShares(subjectId), vaultTotalShares(predicateId), vaultTotalShares(objectId)]; // create triple - vaultId = actEthMultiVault.createTriple{value: msgValue}( - subjectId, - predicateId, - objectId - ); + vaultId = actEthMultiVault.createTriple{value: msgValue}(subjectId, predicateId, objectId); assertEq(vaultId, actEthMultiVault.count()); - checkDepositOnTripleVaultCreation( - vaultId, - msgValue, - totalAssetsBefore, - totalSharesBefore - ); + checkDepositOnTripleVaultCreation(vaultId, msgValue, totalAssetsBefore, totalSharesBefore); // snapshots after creating a triple assertEq( protocolVaultBalanceBefore, // protocolVaultBalanceAfterLessFees - address(getProtocolVault()).balance - - protocolFeeAmount(msgValue - getTripleCost(), vaultId) - - getTripleCreationProtocolFee() + address(getProtocolVault()).balance - protocolFeeAmount(msgValue - getTripleCost(), vaultId) + - getTripleCreationProtocolFee() ); _checkUnderlyingAtomDepositsOnTripleCreation( @@ -835,14 +538,10 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { uint256 protocolDepositFee = protocolFeeAmount(userDeposit, atomIds[0]); uint256 userDepositAfterProtocolFees = userDeposit - protocolDepositFee; - uint256 atomDepositFraction = atomDepositFractionAmount( - userDepositAfterProtocolFees, - atomIds[0] - ); + uint256 atomDepositFraction = atomDepositFractionAmount(userDepositAfterProtocolFees, atomIds[0]); uint256 distributeAmountPerAtomVault = atomDepositFraction / 3; - uint256 atomDepositFractionOnTripleCreationPerAtom = getAtomDepositFractionOnTripleCreation() / - 3; + uint256 atomDepositFractionOnTripleCreationPerAtom = getAtomDepositFractionOnTripleCreation() / 3; for (uint256 i = 0; i < 3; i++) { checkAtomDepositIntoVaultOnTripleVaultCreation( @@ -855,119 +554,63 @@ contract EthMultiVaultActor is Test, EthMultiVaultHelpers { } } - function _depositTripleChecks( - uint256 vaultId, - uint256 msgValue, - address receiver - ) internal returns (uint256 shares) { + function _depositTripleChecks(uint256 vaultId, uint256 msgValue, address receiver) + internal + returns (uint256 shares) + { uint256 totalAssetsBefore = vaultTotalAssets(vaultId); uint256 totalSharesBefore = vaultTotalShares(vaultId); - uint256 protocolVaultBalanceBefore = address(getProtocolVault()) - .balance; - - ( - uint256 subjectId, - uint256 predicateId, - uint256 objectId - ) = actEthMultiVault.getTripleAtoms(vaultId); - - uint256[3] memory totalAssetsBeforeAtomVaults = [ - vaultTotalAssets(subjectId), - vaultTotalAssets(predicateId), - vaultTotalAssets(objectId) - ]; - uint256[3] memory totalSharesBeforeAtomVaults = [ - vaultTotalShares(subjectId), - vaultTotalShares(predicateId), - vaultTotalShares(objectId) - ]; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; + + (uint256 subjectId, uint256 predicateId, uint256 objectId) = actEthMultiVault.getTripleAtoms(vaultId); + + uint256[3] memory totalAssetsBeforeAtomVaults = + [vaultTotalAssets(subjectId), vaultTotalAssets(predicateId), vaultTotalAssets(objectId)]; + uint256[3] memory totalSharesBeforeAtomVaults = + [vaultTotalShares(subjectId), vaultTotalShares(predicateId), vaultTotalShares(objectId)]; // deposit triple - shares = actEthMultiVault.depositTriple{value: msgValue}( - receiver, - vaultId - ); + shares = actEthMultiVault.depositTriple{value: msgValue}(receiver, vaultId); - uint256 userDepositAfterProtocolFees = msgValue - - getProtocolFeeAmount(msgValue, vaultId); + uint256 userDepositAfterProtocolFees = msgValue - getProtocolFeeAmount(msgValue, vaultId); - checkDepositIntoVault( - userDepositAfterProtocolFees, - vaultId, - totalAssetsBefore, - totalSharesBefore - ); + checkDepositIntoVault(userDepositAfterProtocolFees, vaultId, totalAssetsBefore, totalSharesBefore); - checkProtocolVaultBalance( - vaultId, - msgValue, - protocolVaultBalanceBefore - ); + checkProtocolVaultBalance(vaultId, msgValue, protocolVaultBalanceBefore); - uint256 amountToDistribute = atomDepositFractionAmount( - userDepositAfterProtocolFees, - vaultId - ); + uint256 amountToDistribute = atomDepositFractionAmount(userDepositAfterProtocolFees, vaultId); uint256 distributeAmountPerAtomVault = amountToDistribute / 3; checkDepositIntoVault( - distributeAmountPerAtomVault, - subjectId, - totalAssetsBeforeAtomVaults[0], - totalSharesBeforeAtomVaults[0] + distributeAmountPerAtomVault, subjectId, totalAssetsBeforeAtomVaults[0], totalSharesBeforeAtomVaults[0] ); checkDepositIntoVault( - distributeAmountPerAtomVault, - predicateId, - totalAssetsBeforeAtomVaults[1], - totalSharesBeforeAtomVaults[1] + distributeAmountPerAtomVault, predicateId, totalAssetsBeforeAtomVaults[1], totalSharesBeforeAtomVaults[1] ); checkDepositIntoVault( - distributeAmountPerAtomVault, - objectId, - totalAssetsBeforeAtomVaults[2], - totalSharesBeforeAtomVaults[2] + distributeAmountPerAtomVault, objectId, totalAssetsBeforeAtomVaults[2], totalSharesBeforeAtomVaults[2] ); } - function _redeemTripleChecks( - uint256 shares2Redeem, - address receiver, - uint256 vaultId - ) internal returns (uint256 assetsForReceiver) { + function _redeemTripleChecks(uint256 shares2Redeem, address receiver, uint256 vaultId) + internal + returns (uint256 assetsForReceiver) + { // snapshots before redeem - uint256 protocolVaultBalanceBefore = address(getProtocolVault()) - .balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; uint256 userSharesBeforeRedeem = getSharesInVault(vaultId, receiver); uint256 userBalanceBeforeRedeem = address(receiver).balance; - uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees( - userSharesBeforeRedeem, - vaultId - ); + uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, vaultId); // redeem triple - assetsForReceiver = actEthMultiVault.redeemTriple( - shares2Redeem, - receiver, - vaultId - ); + assetsForReceiver = actEthMultiVault.redeemTriple(shares2Redeem, receiver, vaultId); - checkProtocolVaultBalance( - vaultId, - assetsForReceiverBeforeFees, - protocolVaultBalanceBefore - ); + checkProtocolVaultBalance(vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); - assertEq( - getSharesInVault(vaultId, receiver), - userSharesBeforeRedeem - shares2Redeem - ); - assertEq( - address(receiver).balance - userBalanceBeforeRedeem, - assetsForReceiver - ); + assertEq(getSharesInVault(vaultId, receiver), userSharesBeforeRedeem - shares2Redeem); + assertEq(address(receiver).balance - userBalanceBeforeRedeem, assetsForReceiver); } } diff --git a/test/invariant/actors/EthMultiVaultSingleVaultActor.sol b/test/invariant/actors/EthMultiVaultSingleVaultActor.sol index 348eeeb9..090f214d 100644 --- a/test/invariant/actors/EthMultiVaultSingleVaultActor.sol +++ b/test/invariant/actors/EthMultiVaultSingleVaultActor.sol @@ -58,7 +58,7 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { return calculatedAssetsForReceiver + protocolFees + exitFees; } - function depositAtom(address _receiver, uint256 msgValue, uint256 actorIndexSeed) + function depositAtom(address receiver, uint256 msgValue, uint256 actorIndexSeed) public useActor(actorIndexSeed) returns (uint256) @@ -72,29 +72,29 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); emit log_named_uint("msgValue------------", msgValue); - uint256 _vaultId = 1; - emit log_named_uint("vaultTotalAssets----", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultTotalShares----", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); - // bound _receiver to msg.sender always - _receiver = currentActor; + uint256 vaultId = 1; + emit log_named_uint("vaultTotalAssets----", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultTotalShares----", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); + // bound receiver to msg.sender always + receiver = currentActor; // bound msgValue to between minDeposit and 10 ether msgValue = bound(msgValue, getAtomCost(), 10 ether); vm.deal(currentActor, msgValue); - uint256 totalAssetsBefore = vaultTotalAssets(_vaultId); - uint256 totalSharesBefore = vaultTotalShares(_vaultId); + uint256 totalAssetsBefore = vaultTotalAssets(vaultId); + uint256 totalSharesBefore = vaultTotalShares(vaultId); uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; // deposit atom - uint256 shares = actEthMultiVault.depositAtom{value: msgValue}(_receiver, _vaultId); + uint256 shares = actEthMultiVault.depositAtom{value: msgValue}(receiver, vaultId); checkDepositIntoVault( - msgValue - getProtocolFeeAmount(msgValue, _vaultId), _vaultId, totalAssetsBefore, totalSharesBefore + msgValue - getProtocolFeeAmount(msgValue, vaultId), vaultId, totalAssetsBefore, totalSharesBefore ); - checkProtocolVaultBalance(_vaultId, msgValue, protocolVaultBalanceBefore); + checkProtocolVaultBalance(vaultId, msgValue, protocolVaultBalanceBefore); // logs emit log_named_uint( @@ -103,16 +103,16 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { emit log_named_uint("balance currentActor", currentActor.balance); emit log_named_uint("balance EthMultiVaultbal-", address(actEthMultiVault).balance); emit log_named_uint("balance this--------", address(this).balance); - emit log_named_uint("vaultTotalShares----", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultTAssets--------", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint("vaultTotalShares----", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultTAssets--------", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); emit log_named_uint( "==================================== ACTOR depositAtom END ====================================", shares ); return shares; } - function redeemAtom(uint256 _shares2Redeem, address _receiver, uint256 msgValue, uint256 actorIndexSeed) + function redeemAtom(uint256 shares2Redeem, address receiver, uint256 msgValue, uint256 actorIndexSeed) public useActor(actorIndexSeed) returns (uint256) @@ -126,51 +126,51 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { emit log_named_address("currentActor-----", currentActor); emit log_named_uint("currentActor.balance", currentActor.balance); emit log_named_uint("msgValue------------", msgValue); - uint256 _vaultId = 1; + uint256 vaultId = 1; // if vault balance of the selected vault is 0, deposit minDeposit - if (getVaultBalanceForAddress(_vaultId, currentActor) == 0) { + if (getVaultBalanceForAddress(vaultId, currentActor) == 0) { vm.deal(currentActor, 10 ether); msgValue = bound(msgValue, getAtomCost(), 10 ether); - _shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}(currentActor, _vaultId); - emit log_named_uint("_shares2Redeem", _shares2Redeem); + shares2Redeem = actEthMultiVault.depositAtom{value: msgValue}(currentActor, vaultId); + emit log_named_uint("shares2Redeem", shares2Redeem); } else { - // bound _shares2Redeem to between 1 and vaultBalanceOf - _shares2Redeem = bound(_shares2Redeem, 1, getVaultBalanceForAddress(_vaultId, currentActor)); - emit log_named_uint("_shares2Redeem", _shares2Redeem); + // bound shares2Redeem to between 1 and vaultBalanceOf + shares2Redeem = bound(shares2Redeem, 1, getVaultBalanceForAddress(vaultId, currentActor)); + emit log_named_uint("shares2Redeem", shares2Redeem); } // use the redeemer as the receiver always - _receiver = currentActor; + receiver = currentActor; - emit log_named_uint("before vaultTotalShares--", getVaultTotalShares(_vaultId)); - emit log_named_uint("before vaultTAssets------", getVaultTotalAssets(_vaultId)); - emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint("before vaultTotalShares--", getVaultTotalShares(vaultId)); + emit log_named_uint("before vaultTAssets------", getVaultTotalAssets(vaultId)); + emit log_named_uint("before vaultBalanceOf----", getVaultBalanceForAddress(vaultId, currentActor)); // snapshots before redeem uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - uint256 userSharesBeforeRedeem = getSharesInVault(_vaultId, _receiver); - uint256 userBalanceBeforeRedeem = address(_receiver).balance; + uint256 userSharesBeforeRedeem = getSharesInVault(vaultId, receiver); + uint256 userBalanceBeforeRedeem = address(receiver).balance; - uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, _vaultId); + uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, vaultId); // redeem atom - uint256 assetsForReceiver = actEthMultiVault.redeemAtom(_shares2Redeem, _receiver, _vaultId); + uint256 assetsForReceiver = actEthMultiVault.redeemAtom(shares2Redeem, receiver, vaultId); - checkProtocolVaultBalance(_vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); + checkProtocolVaultBalance(vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); // snapshots after redeem - uint256 userSharesAfterRedeem = getSharesInVault(_vaultId, _receiver); - uint256 userBalanceAfterRedeem = address(_receiver).balance; + uint256 userSharesAfterRedeem = getSharesInVault(vaultId, receiver); + uint256 userBalanceAfterRedeem = address(receiver).balance; - assertEq(userSharesAfterRedeem, userSharesBeforeRedeem - _shares2Redeem); + assertEq(userSharesAfterRedeem, userSharesBeforeRedeem - shares2Redeem); assertEq(userBalanceAfterRedeem - userBalanceBeforeRedeem, assetsForReceiver); // logs emit log_named_uint( "------------------------------------ POST STATE -------------------------------------------", 6000000009 ); - emit log_named_uint("vaultTotalShares--", getVaultTotalShares(_vaultId)); - emit log_named_uint("vaultTAssets------", getVaultTotalAssets(_vaultId)); - emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(_vaultId, currentActor)); + emit log_named_uint("vaultTotalShares--", getVaultTotalShares(vaultId)); + emit log_named_uint("vaultTAssets------", getVaultTotalAssets(vaultId)); + emit log_named_uint("vaultBalanceOf----", getVaultBalanceForAddress(vaultId, currentActor)); emit log_named_uint( "==================================== ACTOR redeemAtom END ====================================", assetsForReceiver @@ -178,7 +178,7 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { return assetsForReceiver; } - function depositTriple(address receiver, uint256 msgValue, uint256 actorIndexSeed) + function depositTriple(address receiver, uint256 msgValue, uint256 actorIndexSeed) public useActor(actorIndexSeed) returns (uint256) @@ -196,7 +196,7 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { emit log_named_uint("vaultTotalAssets----", getVaultTotalAssets(vaultId)); emit log_named_uint("vaultTotalShares----", getVaultTotalShares(vaultId)); emit log_named_uint("vaultBalanceOf------", getVaultBalanceForAddress(vaultId, currentActor)); - // bound _receiver to msg.sender always + // bound receiver to msg.sender always receiver = currentActor; // bound msgValue to between minDeposit and 10 ether msgValue = bound(msgValue, getTripleCost(), 10 ether); @@ -241,11 +241,11 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { vm.deal(currentActor, 10 ether); msgValue = bound(msgValue, getTripleCost(), 10 ether); shares2Redeem = actEthMultiVault.depositTriple{value: msgValue}(currentActor, vaultId); - emit log_named_uint("_shares2Redeem", shares2Redeem); + emit log_named_uint("shares2Redeem", shares2Redeem); } else { - // bound _shares2Redeem to between 1 and vaultBalanceOf + // bound shares2Redeem to between 1 and vaultBalanceOf shares2Redeem = bound(shares2Redeem, 1, getVaultBalanceForAddress(vaultId, currentActor)); - emit log_named_uint("_shares2Redeem", shares2Redeem); + emit log_named_uint("shares2Redeem", shares2Redeem); } // use the redeemer as the receiver always receiver = currentActor; @@ -256,7 +256,7 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { // redeem triple uint256 assetsForReceiver = _redeemTripleChecks(shares2Redeem, receiver, vaultId); - + // logs emit log_named_uint( "------------------------------------ POST STATE -------------------------------------------", 6000000009 @@ -271,118 +271,62 @@ contract EthMultiVaultSingleVaultActor is Test, EthMultiVaultHelpers { return assetsForReceiver; } - function _depositTripleChecks( - uint256 vaultId, - uint256 msgValue, - address receiver - ) internal returns (uint256 shares) { + function _depositTripleChecks(uint256 vaultId, uint256 msgValue, address receiver) + internal + returns (uint256 shares) + { uint256 totalAssetsBefore = vaultTotalAssets(vaultId); uint256 totalSharesBefore = vaultTotalShares(vaultId); - uint256 protocolVaultBalanceBefore = address(getProtocolVault()) - .balance; - - ( - uint256 subjectId, - uint256 predicateId, - uint256 objectId - ) = actEthMultiVault.getTripleAtoms(vaultId); - - uint256[3] memory totalAssetsBeforeAtomVaults = [ - vaultTotalAssets(subjectId), - vaultTotalAssets(predicateId), - vaultTotalAssets(objectId) - ]; - uint256[3] memory totalSharesBeforeAtomVaults = [ - vaultTotalShares(subjectId), - vaultTotalShares(predicateId), - vaultTotalShares(objectId) - ]; - - shares = actEthMultiVault.depositTriple{value: msgValue}( - receiver, - vaultId - ); + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; - uint256 userDepositAfterProtocolFees = msgValue - - getProtocolFeeAmount(msgValue, vaultId); + (uint256 subjectId, uint256 predicateId, uint256 objectId) = actEthMultiVault.getTripleAtoms(vaultId); - checkDepositIntoVault( - userDepositAfterProtocolFees, - vaultId, - totalAssetsBefore, - totalSharesBefore - ); + uint256[3] memory totalAssetsBeforeAtomVaults = + [vaultTotalAssets(subjectId), vaultTotalAssets(predicateId), vaultTotalAssets(objectId)]; + uint256[3] memory totalSharesBeforeAtomVaults = + [vaultTotalShares(subjectId), vaultTotalShares(predicateId), vaultTotalShares(objectId)]; - checkProtocolVaultBalance( - vaultId, - msgValue, - protocolVaultBalanceBefore - ); + shares = actEthMultiVault.depositTriple{value: msgValue}(receiver, vaultId); - uint256 amountToDistribute = atomDepositFractionAmount( - userDepositAfterProtocolFees, - vaultId - ); + uint256 userDepositAfterProtocolFees = msgValue - getProtocolFeeAmount(msgValue, vaultId); + + checkDepositIntoVault(userDepositAfterProtocolFees, vaultId, totalAssetsBefore, totalSharesBefore); + + checkProtocolVaultBalance(vaultId, msgValue, protocolVaultBalanceBefore); + + uint256 amountToDistribute = atomDepositFractionAmount(userDepositAfterProtocolFees, vaultId); uint256 distributeAmountPerAtomVault = amountToDistribute / 3; checkDepositIntoVault( - distributeAmountPerAtomVault, - subjectId, - totalAssetsBeforeAtomVaults[0], - totalSharesBeforeAtomVaults[0] + distributeAmountPerAtomVault, subjectId, totalAssetsBeforeAtomVaults[0], totalSharesBeforeAtomVaults[0] ); checkDepositIntoVault( - distributeAmountPerAtomVault, - predicateId, - totalAssetsBeforeAtomVaults[1], - totalSharesBeforeAtomVaults[1] + distributeAmountPerAtomVault, predicateId, totalAssetsBeforeAtomVaults[1], totalSharesBeforeAtomVaults[1] ); checkDepositIntoVault( - distributeAmountPerAtomVault, - objectId, - totalAssetsBeforeAtomVaults[2], - totalSharesBeforeAtomVaults[2] + distributeAmountPerAtomVault, objectId, totalAssetsBeforeAtomVaults[2], totalSharesBeforeAtomVaults[2] ); } - function _redeemTripleChecks( - uint256 shares2Redeem, - address receiver, - uint256 vaultId - ) internal returns (uint256 assetsForReceiver) { + function _redeemTripleChecks(uint256 shares2Redeem, address receiver, uint256 vaultId) + internal + returns (uint256 assetsForReceiver) + { // snapshots before redeem - uint256 protocolVaultBalanceBefore = address(getProtocolVault()) - .balance; + uint256 protocolVaultBalanceBefore = address(getProtocolVault()).balance; uint256 userSharesBeforeRedeem = getSharesInVault(vaultId, receiver); uint256 userBalanceBeforeRedeem = address(receiver).balance; - uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees( - userSharesBeforeRedeem, - vaultId - ); + uint256 assetsForReceiverBeforeFees = getAssetsForReceiverBeforeFees(userSharesBeforeRedeem, vaultId); // redeem triple - assetsForReceiver = actEthMultiVault.redeemTriple( - shares2Redeem, - receiver, - vaultId - ); + assetsForReceiver = actEthMultiVault.redeemTriple(shares2Redeem, receiver, vaultId); - checkProtocolVaultBalance( - vaultId, - assetsForReceiverBeforeFees, - protocolVaultBalanceBefore - ); + checkProtocolVaultBalance(vaultId, assetsForReceiverBeforeFees, protocolVaultBalanceBefore); - assertEq( - getSharesInVault(vaultId, receiver), - userSharesBeforeRedeem - shares2Redeem - ); - assertEq( - address(receiver).balance - userBalanceBeforeRedeem, - assetsForReceiver - ); + assertEq(getSharesInVault(vaultId, receiver), userSharesBeforeRedeem - shares2Redeem); + assertEq(address(receiver).balance - userBalanceBeforeRedeem, assetsForReceiver); } }