Staking

core/.solhint.json

@@ -1,5 +1,7 @@
 {
   "extends": "thesis",
   "plugins": [],
-  "rules": {}
+  "rules": {
+    "func-visibility": ["off", { "ignoreConstructors": true }]
+  }
 }

core/contracts/Acre.sol

@@ -1,9 +1,49 @@
 // SPDX-License-Identifier: GPL-3.0-only
 pragma solidity ^0.8.21;
 
-// Uncomment this line to use console.log
-// import "hardhat/console.sol";
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
+import "@thesis/solidity-contracts/contracts/token/IReceiveApproval.sol";
 
-contract Acre {
-    // TODO: add your implementation
+contract Acre is ERC4626, IReceiveApproval {
+    constructor(IERC20 _token) ERC4626(_token) ERC20("Staking BTC", "stBTC") {}
+
+    /// @notice Receives approval of token transfer and stakes the approved
+    ///         amount.
+    /// @dev Requires that the provided token contract be the same one linked to
+    ///      this contract.
+    /// @param from The owner of the tokens who approved them to transfer.
+    /// @param amount Approved amount for the transfer and stake.
+    /// @param _token Token contract address.
+    /// @param extraData Extra data for stake. This byte array must have the
+    ///        following values concatenated:
+    ///        - referrer ID (32 bytes)
+    function receiveApproval(
+        address from,
+        uint256 amount,
+        address _token,
+        bytes calldata extraData
+    ) external override {
+        require(_token == super.asset(), "Unrecognized token");
+        // TODO: Decide on the format of the `extradata` variable.
+        require(extraData.length == 32, "Corrupted stake data");
+
+        this.stake(amount, from, bytes32(extraData));
+    }
+
+    /// @notice Stakes a given amount of underlying token and mints shares to a
+    ///         receiver.
+    /// @dev This function calls `deposit` function from `ERC4626` contract.
+    /// @param assets Approved amount for the transfer and stake.
+    /// @param receiver The address to which the shares will be minted.
+    /// @param referrer Data used for refferal program.
+    /// @return shares Minted shares.
+    function stake(
+        uint256 assets,
+        address receiver,
+        bytes32 referrer
+    ) external returns (uint256 shares) {
+        require(referrer != bytes32(0), "Referrer can not be empty");
+
+        return super.deposit(assets, receiver);
+    }
 }

core/contracts/test/TestToken.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.21;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import "@thesis/solidity-contracts/contracts/token/IApproveAndCall.sol";
+import "@thesis/solidity-contracts/contracts/token/IReceiveApproval.sol";
+
+contract TestToken is ERC20, IApproveAndCall {
+    constructor() ERC20("Test Token", "TEST") {}
+
+    function mint(address account, uint256 value) external {
+        _mint(account, value);
+    }
+
+    function approveAndCall(
+        address spender,
+        uint256 amount,
+        bytes memory extraData
+    ) external returns (bool) {
+        if (approve(spender, amount)) {
+            IReceiveApproval(spender).receiveApproval(
+                msg.sender,
+                amount,
+                address(this),
+                extraData
+            );
+            return true;
+        }
+        return false;
+    }
+}

core/package.json

@@ -55,5 +55,9 @@
     "ts-node": "^10.9.1",
     "typechain": "^8.3.2",
     "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^5.0.0",
+    "@thesis/solidity-contracts": "github:thesis/solidity-contracts#c315b9d"
   }
 }

core/test/Acre.test.ts

@@ -1,5 +1,118 @@
+import { loadFixture } from "@nomicfoundation/hardhat-toolbox/network-helpers"
+import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers"
+import { ethers } from "hardhat"
+import { expect } from "chai"
+import { WeiPerEther } from "ethers"
+import type { TestToken, Acre } from "../typechain"
+
+async function acreFixture() {
+  const [_, tokenHolder] = await ethers.getSigners()
+  const Token = await ethers.getContractFactory("TestToken")
+  const token = await Token.deploy()
+
+  const amountToMint = WeiPerEther * 10000n
+
+  token.mint(tokenHolder, amountToMint)
+
+  const Acre = await ethers.getContractFactory("Acre")
+  const acre = await Acre.deploy(await token.getAddress())
+
+  return { acre, token, tokenHolder }
+}
+
 describe("Acre", () => {
-  describe("Add your tests", () => {
-    it("Should validate something", async () => {})
+  let acre: Acre
+  let token: TestToken
+  let tokenHolder: HardhatEthersSigner
+
+  beforeEach(async () => {
+    ;({ acre, token, tokenHolder } = await loadFixture(acreFixture))
+  })
+
+  describe("Staking", () => {
+    const referrer = ethers.encodeBytes32String("referrer")
+
+    context("when staking via Acre contract", () => {
+      beforeEach(async () => {
+        // Infinite approval for staking contract.
+        await token
+          .connect(tokenHolder)
+          .approve(await acre.getAddress(), ethers.MaxUint256)
+      })
+
+      it("should stake tokens and receive shares", async () => {
+        const tokenHolderAddress = tokenHolder.address
+        const amountToStake = await token.balanceOf(tokenHolderAddress)
+
+        await expect(
+          acre
+            .connect(tokenHolder)
+            .stake(amountToStake, tokenHolderAddress, referrer),
+        )
+          .to.emit(acre, "Deposit")
+          .withArgs(
+            // Caller.
+            tokenHolderAddress,
+            // Receiver.
+            tokenHolderAddress,
+            // Staked tokens.
+            amountToStake,
+            // Received shares. In this test case there is only one staker and
+            // the token vault has not earned anythig yet so received shares are
+            // equal to staked tokens amount.
+            amountToStake,
+          )
+        expect(await acre.balanceOf(tokenHolderAddress)).to.be.eq(amountToStake)
+        expect(await token.balanceOf(tokenHolderAddress)).to.be.eq(0)
+      })
+
+      it("should revert if the referrer is zero valu", async () => {
+        const emptyReferrer = ethers.encodeBytes32String("")
+
+        await expect(
+          acre
+            .connect(tokenHolder)
+            .stake(1, tokenHolder.address, emptyReferrer),
+        ).to.be.revertedWith("Referrer can not be empty")
+      })
+    })
+
+    context(
+      "when staking via staking token using approve and call pattern",
+      () => {
+        it("should stake tokens", () => {
+          // TODO: The `ERC4626.deposit` sets the owner as `msg.sender` under
+          // the hood. Using the approve and call pattern the `msg.sender` is
+          // token address, so we are actually trying to send tokens from the
+          // token contract to the receiver, which is impossible. We need to
+          // decide if we want to override the `deposit` function to allow
+          // staking via approve and call pattern.
+        })
+
+        it("should revert when called not for linked token", async () => {
+          const FakeToken = await ethers.getContractFactory("TestToken")
+          const fakeToken = await FakeToken.deploy()
+          const acreAddress = await acre.getAddress()
+
+          await expect(
+            fakeToken.connect(tokenHolder).approveAndCall(acreAddress, 1, "0x"),
+          ).to.be.revertedWith("Unrecognized token")
+        })
+
+        it("should revert when extra data is invalid", async () => {
+          const acreAddress = await acre.getAddress()
+          const invalidExtraData = ethers.AbiCoder.defaultAbiCoder().encode(
+            ["bytes32", "address"],
+            [referrer, tokenHolder.address],
+          )
+
+          await expect(
+            token
+              .connect(tokenHolder)
+              .approveAndCall(acreAddress, 1, invalidExtraData),
+          ).to.be.revertedWith("Corrupted stake data")
+        })
+      },
+    )
   })
 })

core/yarn.lock

@@ -874,6 +874,16 @@
     table "^6.8.0"
     undici "^5.14.0"
 
+"@openzeppelin/contracts@^4.1.0":
+  version "4.9.3"
+  resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.9.3.tgz#00d7a8cf35a475b160b3f0293a6403c511099364"
+  integrity sha512-He3LieZ1pP2TNt5JbkPA4PNT9WC3gOTOlDcFGJW4Le4QKqwmiNJCRt44APfxMxvq7OugU/cqYuPcSBzOw38DAg==
+
+"@openzeppelin/contracts@^5.0.0":
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-5.0.0.tgz#ee0e4b4564f101a5c4ee398cd4d73c0bd92b289c"
+  integrity sha512-bv2sdS6LKqVVMLI5+zqnNrNU/CA+6z6CmwFXm/MzmOPBRSO5reEJN7z0Gbzvs0/bv/MZZXNklubpwy3v2+azsw==
+
 "@openzeppelin/defender-admin-client@^1.48.0":
   version "1.49.0"
   resolved "https://registry.yarnpkg.com/@openzeppelin/defender-admin-client/-/defender-admin-client-1.49.0.tgz#ed07318ccba10ac8a8a33cf594fc18b7ab5889f9"
@@ -1107,6 +1117,12 @@
   version "0.0.2"
   resolved "https://codeload.github.com/thesis/prettier-config/tar.gz/daeaac564056a7885e4366ce12bfde6fd823fc90"
 
+"@thesis/solidity-contracts@github:thesis/solidity-contracts#c315b9d":
+  version "0.0.1-pre"
+  resolved "https://codeload.github.com/thesis/solidity-contracts/tar.gz/c315b9d5f0c39253428898474e97552f5e5b9046"
+  dependencies:
+    "@openzeppelin/contracts" "^4.1.0"
+
 "@tsconfig/node10@^1.0.7":
   version "1.0.9"
   resolved "https://registry.yarnpkg.com/@tsconfig/node10/-/node10-1.0.9.tgz#df4907fc07a886922637b15e02d4cebc4c0021b2"