Add initial impl of the unstaking

Add `unstake` function to the `TokenStaking` contract - this function
reduces stake amount by the provided amount and withdraws tokens to the
owner.

core/contracts/staking/TokenStaking.sol

@@ -14,6 +14,7 @@ contract TokenStaking is IReceiveApproval {
     using SafeERC20 for IERC20;
 
     event Staked(address indexed staker, uint256 amount);
+    event Unstaked(address indexed staker, uint256 amount);
 
     IERC20 internal immutable token;
 
@@ -58,14 +59,29 @@ contract TokenStaking is IReceiveApproval {
         // governable params.
         return 1;
     }
-
+    
     /// @notice Returns maximum amount of staking tokens.
     function maximumStake() public pure returns (uint256) {
         // TODO: Fetch this param from "parameters" contract that stores
         // governable params.
         return 100 ether;
     }
 
+    /// @notice Reduces stake amount by the provided amount and
+    ///         withdraws tokens to the owner.
+    /// @param amount Amount to unstake and withdraw.
+    function unstake(uint256 amount) external {
+        require((amount > 0), "Amount can not be zero");
+
+        uint256 balance = balanceOf[msg.sender];
+        require(balance >= amount, "Insufficient funds");
+
+        balanceOf[msg.sender] -= amount;
+
+        emit Unstaked(msg.sender, amount);
+        token.safeTransfer(msg.sender, amount);
+    }
+
     function _stake(address staker, uint256 amount) private {
         require(amount >= minimumStake(), "Amount is less than minimum");
         require(amount <= maximumStake(), "Amount is greater than maxium");

core/contracts/test/TestToken.sol

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-pragma solidity 0.8.20;
+pragma solidity ^0.8.20;
 
 import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "../shared/IReceiveApproval.sol";

core/test/staking/TokenStaking.test.ts

@@ -102,4 +102,45 @@ describe("TokenStaking", () => {
       })
     })
   })
+
+  describe("unstaking", () => {
+    const amountToStake = WeiPerEther * 10n
+
+    beforeEach(async () => {
+      // Stake tokens.
+      await token
+        .connect(tokenHolder)
+        .approveAndCall(await tokenStaking.getAddress(), amountToStake, "0x")
+    })
+
+    it("should unstake tokens", async () => {
+      const staker = await tokenHolder.getAddress()
+      const stakingBalance = await tokenStaking.balanceOf(staker)
+      const balanceBeforeUnstaking = await token.balanceOf(staker)
+
+      await expect(tokenStaking.connect(tokenHolder).unstake(stakingBalance))
+        .to.emit(tokenStaking, "Unstaked")
+        .withArgs(staker, stakingBalance)
+
+      expect(await token.balanceOf(staker)).to.be.equal(
+        balanceBeforeUnstaking + stakingBalance,
+      )
+      expect(await tokenStaking.balanceOf(staker)).to.be.eq(0)
+    })
+
+    it("should revert if the unstaked amount is equal 0", async () => {
+      await expect(
+        tokenStaking.connect(tokenHolder).unstake(0),
+      ).to.be.revertedWith("Amount can not be zero")
+    })
+
+    it("should revert if the user wants to unstake more tokens than currently staked", async () => {
+      const staker = await tokenHolder.getAddress()
+      const stakingBalance = await tokenStaking.balanceOf(staker)
+
+      await expect(
+        tokenStaking.connect(tokenHolder).unstake(stakingBalance + 10n),
+      ).to.be.revertedWith("Insufficient funds")
+    })
+  })
 })