Merge pull request #39 from keep-network/signer-bonds-escrow

pdyraga · web-flow · commit 42a416d2785f · 2021-05-19T16:59:25.000+02:00
Signer bonds escrow

ETH purchased by the risk manager from tBTC signer bonds needs to be
swapped and deposited back to the coverage pool as collateral.
In the case it can not be done automatically, the governance has
the power to ask the risk manager to deposit ETH from purchased
signer bonds into an escrow the governance can later withdraw from
and do the swap manually. SignerBondsEscrow is a simple escrow
implementation allowing the risk manager to store purchased ETH
signer bonds so that governance can later swap them manually and
deposit as coverage pool collateral.
diff --git a/contracts/RiskManagerV1.sol b/contracts/RiskManagerV1.sol
@@ -23,6 +23,17 @@ interface IDeposit {
     function currentState() external view returns (uint256);
 
     function lotSizeTbtc() external view returns (uint256);
+
+    function withdrawableAmount() external view returns (uint256);
+}
+
+/// @title ISignerBondsSwapStrategy
+/// @notice Represents a signer bonds swap strategy.
+/// @dev This interface is meant to abstract the underlying signer bonds
+///      swap strategy and make it interchangeable for the governance.
+interface ISignerBondsSwapStrategy {
+    /// @notice Swaps signer bonds.
+    function swapSignerBonds() external payable;
 }
 
 /// @title RiskManagerV1 for tBTCv1
@@ -41,6 +52,9 @@ contract RiskManagerV1 is Auctioneer, Ownable {
 
     IERC20 public tbtcToken;
 
+    // TODO: should be possible to change by the governance.
+    ISignerBondsSwapStrategy public signerBondsSwapStrategy;
+
     // deposit in liquidation => opened coverage pool auction
     mapping(address => address) public depositToAuction;
     // opened coverage pool auction => deposit in liquidation
@@ -69,10 +83,12 @@ contract RiskManagerV1 is Auctioneer, Ownable {
     constructor(
         IERC20 _tbtcToken,
         CoveragePool _coveragePool,
+        ISignerBondsSwapStrategy _signerBondsSwapStrategy,
         address _masterAuction,
         uint256 _auctionLength
     ) Auctioneer(_coveragePool, _masterAuction) {
         tbtcToken = _tbtcToken;
+        signerBondsSwapStrategy = _signerBondsSwapStrategy;
         auctionLength = _auctionLength;
     }
 
@@ -191,9 +207,11 @@ contract RiskManagerV1 is Auctioneer, Ownable {
         // Purchase signers bonds ETH with TBTC acquired from the auction
         deposit.purchaseSignerBondsAtAuction();
 
-        // TODO: Once ETH is received, funds need to be processed further, so
-        //       they won't be locked in this contract.
+        uint256 withdrawableAmount = deposit.withdrawableAmount();
         deposit.withdrawFunds();
+
+        // slither-disable-next-line arbitrary-send
+        signerBondsSwapStrategy.swapSignerBonds{value: withdrawableAmount}();
     }
 
     /// @notice Get the time remaining until the function parameter timer
diff --git a/contracts/SignerBondsEscrow.sol b/contracts/SignerBondsEscrow.sol
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity <0.9.0;
+
+import "./RiskManagerV1.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+/// @title SignerBondsEscrow
+/// @notice ETH purchased by the risk manager from tBTC signer bonds needs to be
+///         swapped and deposited back to the coverage pool as collateral.
+///         In the case it can not be done automatically, the governance has
+///         the power to ask the risk manager to deposit ETH from purchased
+///         signer bonds into an escrow the governance can later withdraw from
+///         and do the swap manually. SignerBondsEscrow is a simple escrow
+///         implementation allowing the risk manager to store purchased ETH
+///         signer bonds so that governance can later swap them manually and
+///         deposit as coverage pool collateral.
+contract SignerBondsEscrow is ISignerBondsSwapStrategy, Ownable {
+    /// @notice Swaps signer bonds.
+    /// @dev Adds incoming bonds to the overall contract balance.
+    function swapSignerBonds() external payable override {}
+
+    /// @notice Withdraws collected bonds to the given target address.
+    /// @dev Can be called by the governance only.
+    /// @param recipient Arbitrary recipient address chosen by the governance
+    ///        that will be responsible for swapping ETH and depositing
+    ///        collateral to the coverage pool.
+    function withdraw(address payable recipient) external onlyOwner {
+        require(recipient != address(0), "Invalid recipient address");
+        /* solhint-disable avoid-low-level-calls */
+        // slither-disable-next-line low-level-calls,arbitrary-send
+        (bool success, ) = recipient.call{value: address(this).balance}("");
+        require(success, "Failed to send Ether");
+        /* solhint-enable avoid-low-level-calls */
+    }
+}
diff --git a/contracts/test/DepositStub.sol b/contracts/test/DepositStub.sol
@@ -68,4 +68,8 @@ contract DepositStub is IDeposit {
     function notifyUndercollateralizedLiquidation() external {
         currentState = uint256(States.LIQUIDATION_IN_PROGRESS);
     }
+
+    function withdrawableAmount() external view override returns (uint256) {
+        return address(this).balance;
+    }
 }
diff --git a/test/RiskManagerV1.test.js b/test/RiskManagerV1.test.js
@@ -17,6 +17,7 @@ const auctionLength = 86400 // 24h
 
 describe("RiskManagerV1", () => {
   let testToken
+  let signerBondsSwapStrategy
   let owner
   let notifier
   let riskManagerV1
@@ -27,6 +28,12 @@ describe("RiskManagerV1", () => {
     testToken = await TestToken.deploy()
     await testToken.deployed()
 
+    const SignerBondsSwapStrategy = await ethers.getContractFactory(
+      "SignerBondsEscrow"
+    )
+    signerBondsSwapStrategy = await SignerBondsSwapStrategy.deploy()
+    await signerBondsSwapStrategy.deployed()
+
     const Auction = await ethers.getContractFactory("Auction")
     const CoveragePoolStub = await ethers.getContractFactory("CoveragePoolStub")
     const coveragePoolStub = await CoveragePoolStub.deploy()
@@ -39,6 +46,7 @@ describe("RiskManagerV1", () => {
     riskManagerV1 = await RiskManagerV1.deploy(
       testToken.address,
       coveragePoolStub.address,
+      signerBondsSwapStrategy.address,
       masterAuction.address,
       auctionLength
     )
diff --git a/test/SignerBondsEscrow.test.js b/test/SignerBondsEscrow.test.js
@@ -0,0 +1,95 @@
+const chai = require("chai")
+const expect = chai.expect
+
+const { ZERO_ADDRESS } = require("./helpers/contract-test-helpers")
+
+describe("SignerBondsEscrow", () => {
+  let governance
+  let riskManager
+  let signerBondsEscrow
+
+  beforeEach(async () => {
+    governance = await ethers.getSigner(0)
+    riskManager = await ethers.getSigner(1)
+
+    const SignerBondsEscrow = await ethers.getContractFactory(
+      "SignerBondsEscrow"
+    )
+    signerBondsEscrow = await SignerBondsEscrow.deploy()
+    await signerBondsEscrow.deployed()
+  })
+
+  describe("swapSignerBonds", () => {
+    let tx
+
+    beforeEach(async () => {
+      tx = await signerBondsEscrow
+        .connect(riskManager)
+        .swapSignerBonds({ value: ethers.utils.parseEther("10") })
+    })
+
+    it("should add the processed signer bonds to the contract balance", async () => {
+      await expect(tx).to.changeEtherBalance(
+        signerBondsEscrow,
+        ethers.utils.parseEther("10")
+      )
+    })
+  })
+
+  describe("withdraw", () => {
+    context(
+      "when the caller is the governance, target address is non-zero, " +
+        "and there are available funds",
+      () => {
+        let tx
+
+        beforeEach(async () => {
+          await signerBondsEscrow
+            .connect(riskManager)
+            .swapSignerBonds({ value: ethers.utils.parseEther("10") })
+
+          tx = await signerBondsEscrow
+            .connect(governance)
+            .withdraw(riskManager.address)
+        })
+
+        it("transfer all funds to the target account", async () => {
+          await expect(tx).to.changeEtherBalance(
+            signerBondsEscrow,
+            ethers.utils.parseEther("10").mul(-1)
+          )
+          await expect(tx).to.changeEtherBalance(
+            riskManager,
+            ethers.utils.parseEther("10")
+          )
+        })
+      }
+    )
+
+    context("when the caller is not the governance", () => {
+      it("should revert", async () => {
+        await expect(
+          signerBondsEscrow.connect(riskManager).withdraw(riskManager.address)
+        ).to.be.revertedWith("Ownable: caller is not the owner")
+      })
+    })
+
+    context("when the target address is zero", () => {
+      it("should revert", async () => {
+        await expect(
+          signerBondsEscrow.connect(governance).withdraw(ZERO_ADDRESS)
+        ).to.be.revertedWith("Invalid recipient address")
+      })
+    })
+
+    context("when there are no available funds", () => {
+      it("should not transfer any funds", async () => {
+        const tx = await signerBondsEscrow
+          .connect(governance)
+          .withdraw(riskManager.address)
+        await expect(tx).to.changeEtherBalance(signerBondsEscrow, 0)
+        await expect(tx).to.changeEtherBalance(riskManager, 0)
+      })
+    })
+  })
+})
diff --git a/test/liquidation/liquidation.test.js b/test/liquidation/liquidation.test.js
@@ -8,6 +8,7 @@ describe("Integration -- liquidation happy path", () => {
   const bondedAmount = to1e18(150)
 
   let tbtcToken
+  let signerBondsSwapStrategy
   let coveragePool
   let riskManagerV1
   let tbtcDeposit
@@ -19,6 +20,12 @@ describe("Integration -- liquidation happy path", () => {
     tbtcToken = await TestToken.deploy()
     await tbtcToken.deployed()
 
+    const SignerBondsSwapStrategy = await ethers.getContractFactory(
+      "SignerBondsEscrow"
+    )
+    signerBondsSwapStrategy = await SignerBondsSwapStrategy.deploy()
+    await signerBondsSwapStrategy.deployed()
+
     const Auction = await ethers.getContractFactory("Auction")
 
     const masterAuction = await Auction.deploy()
@@ -32,6 +39,7 @@ describe("Integration -- liquidation happy path", () => {
     riskManagerV1 = await RiskManagerV1.deploy(
       tbtcToken.address,
       coveragePool.address,
+      signerBondsSwapStrategy.address,
       masterAuction.address,
       auctionLength
     )
@@ -72,13 +80,19 @@ describe("Integration -- liquidation happy path", () => {
       expect(await auction.isOpen()).to.be.false
     })
 
-    it("should purchase and withdraw signer bonds from deposit", async () => {
-      // Risk Manager has all ETH bonds at their disposal
-      await expect(tx).to.changeEtherBalance(riskManagerV1, bondedAmount)
+    it("should liquidate the deposit", async () => {
       // Auction bidder has spend their TBTC
       expect(await tbtcToken.balanceOf(bidder.address)).to.equal(0)
       // Deposit has been liquidated
       expect(await tbtcDeposit.currentState()).to.equal(11) // LIQUIDATED
     })
+
+    it("should swap signer bonds", async () => {
+      await expect(tx).to.changeEtherBalance(riskManagerV1, 0)
+      await expect(tx).to.changeEtherBalance(
+        signerBondsSwapStrategy,
+        bondedAmount
+      )
+    })
   })
 })

Original file line number	Diff line number	Diff line change
`@@ -68,4 +68,8 @@ contract DepositStub is IDeposit {`
`68`	`68`	`function notifyUndercollateralizedLiquidation() external {`
`69`	`69`	`currentState = uint256(States.LIQUIDATION_IN_PROGRESS);`
`70`	`70`	`}`
	`71`	`+`
	`72`	`+ function withdrawableAmount() external view override returns (uint256) {`
	`73`	`+ return address(this).balance;`
	`74`	`+ }`
`71`	`75`	`}`