feat(flash-loan): add flash loan

src/Blue.sol

@@ -3,6 +3,8 @@ pragma solidity 0.8.20;
 
 import {IIrm} from "src/interfaces/IIrm.sol";
 import {IERC20} from "src/interfaces/IERC20.sol";
+import {IERC3156FlashLender} from "src/interfaces/IERC3156FlashLender.sol";
+import {IERC3156FlashBorrower, FLASH_BORROWER_SUCCESS_HASH} from "src/interfaces/IERC3156FlashBorrower.sol";
 
 import {Errors} from "./libraries/Errors.sol";
 import {SharesMath} from "src/libraries/SharesMath.sol";
@@ -14,7 +16,7 @@ uint256 constant WAD = 1e18;
 uint256 constant MAX_FEE = 0.2e18;
 uint256 constant ALPHA = 0.5e18;
 
-contract Blue {
+contract Blue is IERC3156FlashLender {
     using SharesMath for uint256;
     using FixedPointMathLib for uint256;
     using SafeTransferLib for IERC20;
@@ -245,6 +247,33 @@ contract Blue {
         market.borrowableAsset.safeTransferFrom(msg.sender, address(this), repaid);
     }
 
+    // Flash Loans.
+
+    /// @inheritdoc IERC3156FlashLender
+    function maxFlashLoan(address token) external view returns (uint256) {
+        return IERC20(token).balanceOf(address(this));
+    }
+
+    /// @inheritdoc IERC3156FlashLender
+    function flashFee(address, uint256) external pure returns (uint256) {
+        return 0;
+    }
+
+    /// @inheritdoc IERC3156FlashLender
+    function flashLoan(IERC3156FlashBorrower receiver, address token, uint256 amount, bytes calldata data)
+        external
+        returns (bool)
+    {
+        IERC20(token).safeTransfer(address(receiver), amount);
+
+        bytes32 successHash = receiver.onFlashLoan(msg.sender, token, amount, 0, data);
+        require(successHash == FLASH_BORROWER_SUCCESS_HASH, Errors.INVALID_SUCCESS_HASH);
+
+        IERC20(token).safeTransferFrom(address(receiver), address(this), amount);
+
+        return true;
+    }
+
     // Position management.
 
     function setApproval(address manager, bool isAllowed) external {

src/interfaces/IERC20.sol

@@ -3,4 +3,6 @@ pragma solidity >=0.5.0;
 
 /// @dev Empty because we only call functions in assembly. It prevents calling
 /// transfer (transferFrom) instead of safeTransfer (safeTransferFrom).
-interface IERC20 {}
+interface IERC20 {
+    function balanceOf(address owner) external view returns (uint256);
+}

src/interfaces/IERC3156FlashBorrower.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.5.0;
+
+/// @dev The expected success hash returned by the FlashBorrower.
+bytes32 constant FLASH_BORROWER_SUCCESS_HASH = keccak256("ERC3156FlashBorrower.onFlashLoan");
+
+interface IERC3156FlashBorrower {
+    /**
+     * @dev Receives a flash loan.
+     * @param initiator The initiator of the loan.
+     * @param token The token lent.
+     * @param amount The amount of tokens lent.
+     * @param fee The additional amount of tokens to repay.
+     * @param data Arbitrary data structure, intended to contain user-defined parameters.
+     * @return The keccak256 hash of "ERC3156FlashBorrower.onFlashLoan"
+     */
+    function onFlashLoan(address initiator, address token, uint256 amount, uint256 fee, bytes calldata data)
+        external
+        returns (bytes32);
+}

src/interfaces/IERC3156FlashLender.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.5.0;
+
+import {IERC3156FlashBorrower} from "src/interfaces/IERC3156FlashBorrower.sol";
+
+interface IERC3156FlashLender {
+    /**
+     * @dev The amount of currency available to be lent.
+     * @param token The token lent.
+     * @return The amount of `token` that can be borrowed.
+     */
+    function maxFlashLoan(address token) external view returns (uint256);
+
+    /**
+     * @dev The fee to be charged for a given loan.
+     * @param token The token lent.
+     * @param amount The amount of tokens lent.
+     * @return The amount of `token` to be charged for the loan, on top of the returned principal.
+     */
+    function flashFee(address token, uint256 amount) external view returns (uint256);
+
+    /**
+     * @dev Initiate a flash loan.
+     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.
+     * @param token The token lent.
+     * @param amount The amount of tokens lent.
+     * @param data Arbitrary data structure, intended to contain user-defined parameters.
+     */
+    function flashLoan(IERC3156FlashBorrower receiver, address token, uint256 amount, bytes calldata data)
+        external
+        returns (bool);
+}

src/libraries/Errors.sol

@@ -25,4 +25,6 @@ library Errors {
     string internal constant INSUFFICIENT_LIQUIDITY = "insufficient liquidity";
 
     string internal constant HEALTHY_POSITION = "position is healthy";
+
+    string internal constant INVALID_SUCCESS_HASH = "invalid success hash";
 }

src/libraries/SafeTransferLib.sol

@@ -66,4 +66,33 @@ library SafeTransferLib {
 
         require(success, "TRANSFER_FAILED");
     }
+
+    function safeApprove(IERC20 token, address to, uint256 amount) internal {
+        bool success;
+
+        /// @solidity memory-safe-assembly
+        assembly {
+            // Get a pointer to some free memory.
+            let freeMemoryPointer := mload(0x40)
+
+            // Write the abi-encoded calldata into memory, beginning with the function selector.
+            mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
+            mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument.
+            mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type.
+
+            success :=
+                and(
+                    // Set success to whether the call reverted, if not we check it either
+                    // returned exactly 1 (can't just be non-zero data), or had no return data.
+                    or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
+                    // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
+                    // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
+                    // Counterintuitively, this call must be positioned second to the or() call in the
+                    // surrounding and() call or else returndatasize() will be zero during the computation.
+                    call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
+                )
+        }
+
+        require(success, "APPROVE_FAILED");
+    }
 }

src/mocks/FlashBorrowerMock.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.0;
+
+import {IERC20} from "src/interfaces/IERC20.sol";
+import {IERC3156FlashLender} from "src/interfaces/IERC3156FlashLender.sol";
+import {IERC3156FlashBorrower, FLASH_BORROWER_SUCCESS_HASH} from "src/interfaces/IERC3156FlashBorrower.sol";
+
+import {SafeTransferLib} from "src/libraries/SafeTransferLib.sol";
+
+contract FlashBorrowerMock is IERC3156FlashBorrower {
+    using SafeTransferLib for IERC20;
+
+    IERC3156FlashLender private immutable _LENDER;
+
+    constructor(IERC3156FlashLender lender) {
+        _LENDER = lender;
+    }
+
+    /* EXTERNAL */
+
+    /// @inheritdoc IERC3156FlashBorrower
+    function onFlashLoan(address, address token, uint256 amount, uint256 fee, bytes calldata)
+        external
+        returns (bytes32)
+    {
+        require(msg.sender == address(_LENDER), "invalid lender");
+
+        IERC20(token).safeApprove(address(_LENDER), amount + fee);
+
+        return FLASH_BORROWER_SUCCESS_HASH;
+    }
+}

test/forge/Blue.t.sol

@@ -8,6 +8,7 @@ import "src/Blue.sol";
 import {ERC20Mock as ERC20} from "src/mocks/ERC20Mock.sol";
 import {OracleMock as Oracle} from "src/mocks/OracleMock.sol";
 import {IrmMock as Irm} from "src/mocks/IrmMock.sol";
+import {FlashBorrowerMock} from "src/mocks/FlashBorrowerMock.sol";
 
 contract BlueTest is Test {
     using FixedPointMathLib for uint256;
@@ -25,6 +26,7 @@ contract BlueTest is Test {
     Irm private irm;
     Market public market;
     Id public id;
+    FlashBorrowerMock internal flashBorrower;
 
     function setUp() public {
         // Create Blue.
@@ -35,6 +37,7 @@ contract BlueTest is Test {
         collateralAsset = new ERC20("collateral", "C", 18);
         borrowableOracle = new Oracle();
         collateralOracle = new Oracle();
+        flashBorrower = new FlashBorrowerMock(blue);
 
         irm = new Irm(blue);
         market = Market(
@@ -685,6 +688,15 @@ contract BlueTest is Test {
 
         vm.stopPrank();
     }
+
+    function testFlashLoan(uint256 amount) public {
+        amount = bound(amount, 1, 2 ** 64);
+
+        borrowableAsset.setBalance(address(this), amount);
+        blue.supply(market, amount, address(this));
+
+        blue.flashLoan(flashBorrower, address(borrowableAsset), amount, bytes(""));
+    }
 }
 
 function neq(Market memory a, Market memory b) pure returns (bool) {

test/hardhat/Blue.spec.ts

@@ -5,6 +5,7 @@ import { expect } from "chai";
 import { BigNumber, constants, utils } from "ethers";
 import hre from "hardhat";
 import { Blue, OracleMock, ERC20Mock, IrmMock } from "types";
+import { FlashBorrowerMock } from "types/src/mocks/FlashBorrowerMock";
 
 const closePositions = false;
 const initBalance = constants.MaxUint256.div(2);
@@ -45,6 +46,7 @@ describe("Blue", () => {
   let borrowableOracle: OracleMock;
   let collateralOracle: OracleMock;
   let irm: IrmMock;
+  let flashBorrower: FlashBorrowerMock;
 
   let market: Market;
   let id: Buffer;
@@ -110,6 +112,10 @@ describe("Blue", () => {
 
     await borrowable.setBalance(liquidator.address, initBalance);
     await borrowable.connect(liquidator).approve(blue.address, constants.MaxUint256);
+
+    const FlashBorrowerFactory = await hre.ethers.getContractFactory("FlashBorrowerMock", admin);
+
+    flashBorrower = await FlashBorrowerFactory.deploy(blue.address);
   });
 
   it("should simulate gas cost [main]", async () => {
@@ -185,4 +191,13 @@ describe("Blue", () => {
       await borrowableOracle.setPrice(BigNumber.WAD);
     }
   });
+
+  it("should simuate gas cost [flashloan]", async () => {
+    const user = signers[0];
+    const amount = BigNumber.WAD;
+
+    await blue.connect(user).supply(market, amount, user.address);
+
+    await blue.flashLoan(flashBorrower.address, borrowable.address, amount.div(2), []);
+  });
 });