Allow PAs to set cancellation fees

contracts/Pool.sol

@@ -482,9 +482,10 @@ contract Pool is IPool, ERC20 {
             maxRequestCancellation(owner) >= shares,
             "Pool: InsufficientBalance"
         );
-        withdrawController.performRequestCancellation(owner, shares);
-        uint256 feeShares = (shares);
+        uint256 feeShares = poolController.requestCancellationFee(shares);
         _burn(owner, feeShares);
+        withdrawController.performRequestCancellation(owner, shares);
+
         emit WithdrawRequestCancelled(owner, assets, shares);
     }
 

contracts/controllers/PoolController.sol

@@ -143,6 +143,31 @@ contract PoolController is IPoolController {
         );
     }
 
+    /**
+     * @inheritdoc IPoolController
+     */
+    function setRequestCancellationFee(uint256 feeBps)
+        external
+        onlyAdmin
+        atState(IPoolLifeCycleState.Initialized)
+    {
+        _settings.requestCancellationFeeBps = feeBps;
+    }
+
+    /**
+     * @inheritdoc IPoolController
+     */
+    function requestCancellationFee(uint256 sharesOrAssets)
+        public
+        view
+        returns (uint256 feeShares)
+    {
+        feeShares = PoolLib.calculateCancellationFee(
+            sharesOrAssets,
+            _settings.requestCancellationFeeBps
+        );
+    }
+
     /**
      * @inheritdoc IPoolController
      */

contracts/controllers/interfaces/IPoolController.sol

@@ -83,6 +83,18 @@ interface IPoolController {
      */
     function requestFee(uint256) external view returns (uint256);
 
+    /**
+     * @dev Allow the current pool admin to update the pool cancellation fees
+     * before the pool has been activated.
+     */
+    function setRequestCancellationFee(uint256) external;
+
+    /**
+     * @dev Returns the cancellation fee for a given withdrawal request at the
+     * current block. The fee is the number of shares that will be charged.
+     */
+    function requestCancellationFee(uint256) external view returns (uint256);
+
     /**
      * @dev Allow the current pool admin to update the withdraw gate at any
      * time if the pool is Initialized or Active

test/controllers/PoolController.test.ts

@@ -135,6 +135,57 @@ describe("PoolController", () => {
     });
   });
 
+  describe("setRequestCancellationFee()", () => {
+    it("sets the request fee in Bps", async () => {
+      const { poolController, poolAdmin } = await loadFixture(loadPoolFixture);
+
+      const originalSettings = await poolController.settings();
+      expect(originalSettings.requestCancellationFeeBps).to.equal(100);
+
+      await poolController.connect(poolAdmin).setRequestCancellationFee(1000);
+
+      const settings = await poolController.settings();
+      expect(settings.requestCancellationFeeBps).to.equal(1000);
+    });
+
+    it("does not let anyone except the admin to set the fee", async () => {
+      const { poolController, otherAccount } = await loadFixture(
+        loadPoolFixture
+      );
+
+      const originalSettings = await poolController.settings();
+      expect(originalSettings.requestCancellationFeeBps).to.equal(100);
+
+      await expect(
+        poolController.connect(otherAccount).setRequestCancellationFee(10)
+      ).to.be.revertedWith("Pool: caller is not admin");
+    });
+
+    it("does not allow setting the request fee once the pool is active", async () => {
+      const { pool, poolController, poolAdmin, liquidityAsset } =
+        await loadFixture(loadPoolFixture);
+
+      const originalSettings = await poolController.settings();
+      expect(originalSettings.requestCancellationFeeBps).to.equal(100);
+
+      await activatePool(pool, poolAdmin, liquidityAsset);
+
+      await expect(
+        poolController.connect(poolAdmin).setRequestCancellationFee(10)
+      ).to.be.revertedWith("Pool: FunctionInvalidAtThisLifeCycleState");
+    });
+  });
+
+  describe("requestCancellationFee()", () => {
+    it("returns the number of shares that will be charged to make this request", async () => {
+      const { poolController, poolAdmin } = await loadFixture(loadPoolFixture);
+
+      await poolController.connect(poolAdmin).setRequestCancellationFee(500); // 5%
+
+      expect(await poolController.requestCancellationFee(1_000)).to.equal(50);
+    });
+  });
+
   describe("setWithdrawGate()", () => {
     it("sets the withdraw gate in Bps", async () => {
       const { pool, poolController, poolAdmin, liquidityAsset } =

test/scenarios/pool/withdraw-request.test.ts

@@ -156,7 +156,11 @@ describe("Withdraw Requests", () => {
     expect(await pool.maxRequestCancellation(bobLender.address)).to.equal(3);
 
     // Cancel Bob's request
+    const bobBalance = await pool.balanceOf(bobLender.address);
     expect(await pool.connect(bobLender).cancelRedeemRequest(3));
+
+    // Expect a fee to be paid
+    expect(await pool.balanceOf(bobLender.address)).to.equal(bobBalance.sub(1));
     expect(await pool.maxRequestCancellation(bobLender.address)).to.equal(0);
   });
 });