tests(Flashloan,Flashlend): add tests for flash lending functionality

Author: fubuloubu

pyproject.toml

@@ -10,7 +10,6 @@ readme = "README.md"
 requires-python = ">=3.9"
 dependencies = [
     "eth-ape>=0.8.32",
-    "snekmate>=0.0.1",
 ]
 
 [[project.authors]]
@@ -24,6 +23,14 @@ packages = ["purse"]
 
 [[tool.ape.plugins]]
 name = "vyper"
+[tool.ape.compile]
+exclude = [
+    "accessories/*.storageLayout.json",
+]
+
+[[tool.ape.dependencies]]
+pypi = "snekmate"
+version = "0.1.2"
 
 [[tool.ape.plugins]]
 name = "foundry"

tests/conftest.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 import pytest
 from ape.contracts import ContractInstance, ContractMethodHandler
 
@@ -17,6 +19,21 @@ def singleton(project, owner):
     return owner.deploy(project.Purse)
 
 
+@pytest.fixture(scope="session")
+def mocks():
+    from ape import Project
+
+    return Project(
+        Path(__file__).parent,
+        config_override=dict(contracts_folder="mocks"),
+    )
+
+
+@pytest.fixture(scope="session")
+def token(mocks, owner):
+    return owner.deploy(mocks.MockToken)
+
+
 @pytest.fixture()
 def purse(singleton, owner):
     with owner.delegate_to(singleton) as purse:

tests/mocks/MockFlashReceiver.vy

@@ -0,0 +1,27 @@
+from ethereum.ercs import IERC20
+
+
+interface IERC3156FlashBorrower:
+    def onFlashLoan(
+        initiator: address,
+        token: IERC20,
+        amount: uint256,
+        fee: uint256,
+        data: Bytes[65535],
+    ) -> bytes32: nonpayable
+
+
+implements: IERC3156FlashBorrower
+
+
+@external
+def onFlashLoan(
+    initiator: address,
+    token: IERC20,
+    amount: uint256,
+    fee: uint256,
+    data: Bytes[65535],
+) -> bytes32:
+    # NOTE: Make sure this contract has enough balance prior to calling
+    extcall token.approve(msg.sender, amount + fee)
+    return keccak256("ERC3156FlashBorrower.onFlashLoan")

tests/mocks/MockToken.vy

@@ -0,0 +1,113 @@
+from ethereum.ercs import IERC20
+
+implements: IERC20
+
+totalSupply: public(uint256)
+balanceOf: public(HashMap[address, uint256])
+allowance: public(HashMap[address, HashMap[address, uint256]])
+
+
+@deploy
+def __init__():
+    self.totalSupply = 100 * 10 ** 18
+    self.balanceOf[msg.sender] = 100 * 10 ** 18
+
+
+@external
+def transfer(receiver: address, amount: uint256) -> bool:
+    self.balanceOf[msg.sender] -= amount
+    self.balanceOf[receiver] += amount
+    log IERC20.Transfer(sender=msg.sender, receiver=receiver, value=amount)
+    return True
+
+
+@external
+def approve(spender: address, amount: uint256) -> bool:
+    self.allowance[msg.sender][spender] = amount
+    log IERC20.Approval(owner=msg.sender, spender=spender, value=amount)
+    return True
+
+
+@external
+def transferFrom(owner: address, receiver: address, amount: uint256) -> bool:
+    self.allowance[owner][msg.sender] -= amount
+    self.balanceOf[owner] -= amount
+    self.balanceOf[receiver] += amount
+    log IERC20.Transfer(sender=owner, receiver=receiver, value=amount)
+    return True
+
+
+@external
+def mint(receiver: address, amount: uint256):
+    self.totalSupply += amount
+    self.balanceOf[receiver] += amount
+    log IERC20.Transfer(sender=empty(address), receiver=receiver, value=amount)
+
+
+interface IERC3156FlashBorrower:
+    def onFlashLoan(
+        initiator: address,
+        token: IERC20,
+        amount: uint256,
+        fee: uint256,
+        data: Bytes[65535],
+    ) -> bytes32: nonpayable
+
+
+interface IERC3156:
+    def maxFlashLoan(token: IERC20) -> uint256: view
+    def flashFee(token: IERC20, amount: uint256) -> uint256: view
+    def flashLoan(
+        receiver: IERC3156FlashBorrower,
+        token: IERC20,
+        amount: uint256,
+        data: Bytes[65535],
+    ) -> bool: nonpayable
+
+
+implements: IERC3156
+
+
+@view
+@external
+def maxFlashLoan(token: IERC20) -> uint256:
+    if token.address == self:
+        return max_value(uint256) - self.totalSupply
+
+    return 0
+
+
+@view
+@external
+def flashFee(token: IERC20, amount: uint256) -> uint256:
+    return 0
+
+
+@external
+def flashLoan(
+    receiver: IERC3156FlashBorrower,
+    token: IERC20,
+    amount: uint256,
+    data: Bytes[65535],
+) -> bool:
+    assert token.address == self
+
+    # Send our tokens to receiver
+    self.totalSupply += amount
+    self.balanceOf[receiver.address] += amount
+    log IERC20.Transfer(sender=empty(address), receiver=receiver.address, value=amount)
+
+    assert (
+        # NOTE: `msg.sender` is original caller of delegatecall
+        extcall receiver.onFlashLoan(msg.sender, IERC20(self), amount, 0, data)
+        # NOTE: Magic value per ERC-3156
+        == keccak256("ERC3156FlashBorrower.onFlashLoan")
+    ), "Flashloan receiver not valid"
+
+    # Get our tokens back (mimic a real flash lender)
+    self.allowance[receiver.address][self] -= amount
+    self.totalSupply -= amount
+    self.balanceOf[receiver.address] -= amount
+    log IERC20.Transfer(sender=receiver.address, receiver=empty(address), value=amount)
+
+    return True

tests/test_flashloans.py

@@ -0,0 +1,86 @@
+import ape
+from ape.utils.misc import ZERO_ADDRESS
+import pytest
+
+from eth_abi import abi
+
+
+@pytest.fixture(scope="module")
+def flashloan(project, owner):
+    return owner.deploy(project.Flashloan)
+
+
+@pytest.fixture(scope="module")
+def flashlend(project, owner):
+    return owner.deploy(project.Flashlend)
+
+
+@pytest.fixture()
+def purse(singleton, owner, flashloan, flashlend, encode_accessory_data):
+    with owner.delegate_to(
+        singleton,
+        # NOTE: Add multicall as an accessory at the same time
+        data=singleton.update_accessories.encode_input(
+            encode_accessory_data(
+                # ERC3156Receiver method
+                flashloan.onFlashLoan,
+                # ERC3156 methods
+                flashlend.maxFlashLoan,
+                flashlend.flashFee,
+                flashlend.flashLoan,
+                # Custom flashlend methods
+                flashlend.setFlashFee,
+            )
+        ),
+    ) as purse:
+        purse.contract_type.abi.extend(flashloan.contract_type.abi)
+        purse.contract_type.abi.extend(flashlend.contract_type.abi)
+        yield purse
+
+
+def test_flashloan(purse, token, other):
+    assert token.allowance(purse, other) == 0
+    with ape.reverts("Flashloan:!authorized"):
+        purse.onFlashLoan(purse, token, 1_000, 0, b"", sender=other)
+    assert token.allowance(purse, other) == 0
+
+    tx = token.flashLoan(
+        purse,
+        token,
+        1_000,
+        # NOTE: View call is a no-op, should work
+        abi.encode(["address","uint256"], [purse.address, 0]) + purse.maxFlashLoan.encode_input(token),
+        sender=purse,
+    )
+    assert tx.events == [
+        token.Transfer(sender=ZERO_ADDRESS, receiver=purse, value=1_000),
+        token.Approval(owner=purse, spender=token, value=1_000),
+        token.Transfer(sender=purse, receiver=ZERO_ADDRESS, value=1_000),
+    ]
+
+
+@pytest.fixture(scope="module")
+def flash_receiver(mocks, owner):
+    return owner.deploy(mocks.MockFlashReceiver)
+
+
+def test_flashlend(purse, token, flash_receiver):
+    assert purse.maxFlashLoan(token) == 0
+    assert purse.flashFee(token, 1_000_000) == 0
+
+    with ape.reverts("Flashlend:!token-allowed"):
+        purse.flashLoan(flash_receiver, token, token.balanceOf(purse) // 100, b"")
+
+    purse.setFlashFee(token, 1_000)
+
+    assert purse.maxFlashLoan(token) == token.balanceOf(purse)
+    assert purse.flashFee(token, 1_000_000) == 1_000
+
+    token.mint(flash_receiver, int(1e18), sender=purse)
+    purse.flashLoan(
+        flash_receiver,
+        token,
+        prev_bal := token.balanceOf(purse),
+        b"",
+    )
+    assert token.balanceOf(purse) == prev_bal + int(prev_bal * (1_000 / 1_000_000))