fix: events and docs

Author: MathisGD

src/PublicAllocator.sol

@@ -66,14 +66,14 @@ contract PublicAllocator is IPublicAllocatorStaticTyping {
     function setOwner(address vault, address newOwner) external onlyOwner(vault) {
         if (owner[vault] == newOwner) revert ErrorsLib.AlreadySet();
         owner[vault] = newOwner;
-        emit EventsLib.SetOwner(vault, newOwner);
+        emit EventsLib.SetOwner(msg.sender, vault, newOwner);
     }
 
     /// @inheritdoc IPublicAllocatorBase
     function setFee(address vault, uint256 newFee) external onlyOwner(vault) {
         if (fee[vault] == newFee) revert ErrorsLib.AlreadySet();
         fee[vault] = newFee;
-        emit EventsLib.SetFee(vault, newFee);
+        emit EventsLib.SetFee(msg.sender, vault, newFee);
     }
 
     /// @inheritdoc IPublicAllocatorBase
@@ -85,15 +85,15 @@ contract PublicAllocator is IPublicAllocatorStaticTyping {
             flowCaps[vault][config[i].id] = config[i].caps;
         }
 
-        emit EventsLib.SetFlowCaps(vault, config);
+        emit EventsLib.SetFlowCaps(msg.sender, vault, config);
     }
 
     /// @inheritdoc IPublicAllocatorBase
     function transferFee(address vault, address payable feeRecipient) external onlyOwner(vault) {
         uint256 claimed = accruedFee[vault];
         accruedFee[vault] = 0;
         feeRecipient.transfer(claimed);
-        emit EventsLib.TransferFee(vault, claimed, feeRecipient);
+        emit EventsLib.TransferFee(msg.sender, vault, claimed, feeRecipient);
     }
 
     /* PUBLIC */
@@ -132,7 +132,7 @@ contract PublicAllocator is IPublicAllocatorStaticTyping {
 
             totalWithdrawn += withdrawnAssets;
 
-            emit EventsLib.PublicWithdrawal(vault, id, withdrawnAssets);
+            emit EventsLib.PublicWithdrawal(msg.sender, vault, id, withdrawnAssets);
         }
 
         if (flowCaps[vault][supplyMarketId].maxIn < totalWithdrawn) revert ErrorsLib.MaxInflowExceeded(supplyMarketId);

src/interfaces/IPublicAllocator.sol

@@ -9,9 +9,10 @@ import {
     MarketParams
 } from "../../lib/metamorpho/src/interfaces/IMetaMorpho.sol";
 
-/// @dev Equal to type(uint128).max/2, so flow caps can always be stored on 128 bits.
+/// @dev Max settable flow cap, such that they can always be stored on 128 bits.
 /// @dev The actual max possible flow cap is type(uint128).max-1.
-uint128 constant MAX_SETTABLE_FLOW_CAP = 170141183460469231731687303715884105727;
+/// @dev Equals to 170141183460469231731687303715884105727;
+uint128 constant MAX_SETTABLE_FLOW_CAP = type(uint128).max / 2;
 
 struct FlowCaps {
     /// @notice The maximum allowed inflow in a market.
@@ -21,7 +22,9 @@ struct FlowCaps {
 }
 
 struct FlowCapsConfig {
+    /// @notice Market for which to change flow caps.
     Id id;
+    /// @notice New flow caps for this market.
     FlowCaps caps;
 }
 
@@ -53,7 +56,7 @@ interface IPublicAllocatorBase {
     /// @param withdrawals The markets to withdraw from,and the amounts to withdraw.
     /// @param supplyMarketParams The market receiving total withdrawn to.
     /// @dev Will call MetaMorpho's `reallocate`.
-    /// @dev Checks that the public allocator constraints (flows, caps) are respected.
+    /// @dev Checks that the flow caps are respected.
     /// @dev Will revert when `withdrawals` contains a duplicate or is not sorted.
     /// @dev Will revert if `withdrawals` contains the supply market.
     /// @dev Will revert if a withdrawal amount is larger than available liquidity.

src/libraries/EventsLib.sol

@@ -9,20 +9,20 @@ import {FlowCapsConfig, Id} from "../interfaces/IPublicAllocator.sol";
 /// @notice Library exposing events.
 library EventsLib {
     /// @notice Emitted during a public reallocation for each withdrawn-from market.
-    event PublicWithdrawal(address indexed vault, Id id, uint256 withdrawnAssets);
+    event PublicWithdrawal(address indexed sender, address indexed vault, Id id, uint256 withdrawnAssets);
 
     /// @notice Emitted at the end of a public reallocation.
-    event PublicReallocateTo(address indexed vault, address sender, Id supplyMarketId, uint256 suppliedAssets);
+    event PublicReallocateTo(address indexed sender, address indexed vault, Id supplyMarketId, uint256 suppliedAssets);
 
     /// @notice Emitted when the owner is set for a vault.
-    event SetOwner(address indexed vault, address owner);
+    event SetOwner(address indexed sender, address indexed vault, address indexed owner);
 
     /// @notice Emitted when the owner changes the `fee` for a vault.
-    event SetFee(address indexed vault, uint256 fee);
+    event SetFee(address indexed sender, address indexed vault, uint256 fee);
 
     /// @notice Emitted when the owner transfers the fee for a vault.
-    event TransferFee(address indexed vault, uint256 amount, address indexed feeRecipient);
+    event TransferFee(address indexed sender, address indexed vault, uint256 amount, address indexed feeRecipient);
 
     /// @notice Emitted when the owner updates some flow caps for a vault.
-    event SetFlowCaps(address indexed vault, FlowCapsConfig[] config);
+    event SetFlowCaps(address indexed sender, address indexed vault, FlowCapsConfig[] config);
 }

test/PublicAllocatorTest.sol

@@ -141,7 +141,7 @@ contract PublicAllocatorTest is IntegrationTest {
         vm.assume(fee != publicAllocator.fee(address(vault)));
         vm.prank(OWNER);
         vm.expectEmit(address(publicAllocator));
-        emit EventsLib.SetFee(address(vault), fee);
+        emit EventsLib.SetFee(OWNER, address(vault), fee);
         publicAllocator.setFee(address(vault), fee);
         assertEq(publicAllocator.fee(address(vault)), fee);
     }
@@ -165,7 +165,7 @@ contract PublicAllocatorTest is IntegrationTest {
         flowCaps.push(FlowCapsConfig(allMarkets[0].id(), FlowCaps(in1, out1)));
 
         vm.expectEmit(address(publicAllocator));
-        emit EventsLib.SetFlowCaps(address(vault), flowCaps);
+        emit EventsLib.SetFlowCaps(OWNER, address(vault), flowCaps);
 
         vm.prank(OWNER);
         publicAllocator.setFlowCaps(address(vault), flowCaps);
@@ -202,9 +202,9 @@ contract PublicAllocatorTest is IntegrationTest {
         withdrawals.push(Withdrawal(allMarkets[1], flow));
 
         vm.expectEmit(address(publicAllocator));
-        emit EventsLib.PublicWithdrawal(address(vault), idleParams.id(), flow);
-        emit EventsLib.PublicWithdrawal(address(vault), allMarkets[1].id(), flow);
-        emit EventsLib.PublicReallocateTo(address(vault), sender, allMarkets[0].id(), 2 * flow);
+        emit EventsLib.PublicWithdrawal(sender, address(vault), idleParams.id(), flow);
+        emit EventsLib.PublicWithdrawal(sender, address(vault), allMarkets[1].id(), flow);
+        emit EventsLib.PublicReallocateTo(sender, address(vault), allMarkets[0].id(), 2 * flow);
 
         vm.prank(sender);
         publicAllocator.reallocateTo(address(vault), withdrawals.sort(), allMarkets[0]);
@@ -380,7 +380,7 @@ contract PublicAllocatorTest is IntegrationTest {
     }
 
     function testMaxFlowCapValue() public {
-        assertEq(MAX_SETTABLE_FLOW_CAP, type(uint128).max / 2);
+        assertEq(MAX_SETTABLE_FLOW_CAP, 170141183460469231731687303715884105727);
     }
 
     function testMaxFlowCapLimit(uint128 cap) public {