TokenGrant is able to compute unlocked amount

Author: pdyraga

contracts/grant/GrantStakingPolicy.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.4;
+
+interface IGrantStakingPolicy {
+    function getStakeableAmount(
+        uint256 _now,
+        uint256 grantedAmount,
+        uint256 duration,
+        uint256 start,
+        uint256 cliff,
+        uint256 withdrawn) external view returns (uint256);
+}
+
+// TODO: add more policies

contracts/grant/TokenGrant.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.4;
+
+import "./GrantStakingPolicy.sol";
+
+contract TokenGrant {
+
+    address public grantee;
+    bool public revocable;
+    uint256 public amount;
+    uint256 public duration;
+    uint256 public start;
+    uint256 public cliff;
+    
+    uint256 public withdrawn;
+    uint256 public staked;
+
+    uint256 public revokedAt;
+    uint256 public revokedAmount;
+    uint256 public revokedWithdrawn;
+
+    IGrantStakingPolicy public stakingPolicy;
+
+    function initialize(
+        address _grantee,
+        bool _revocable,
+        uint256 _amount,
+        uint256 _duration,
+        uint256 _start,
+        uint256 _cliff,
+        IGrantStakingPolicy _stakingPolicy
+    ) public {
+        grantee = _grantee;
+        revocable = _revocable;
+        amount = _amount;
+        duration = _duration;
+        start = _start;
+        cliff = _cliff;
+        stakingPolicy = _stakingPolicy;
+    }
+
+    function unlockedAmount() public view returns (uint256) {
+        if (block.timestamp < start) { // start reached?
+            return 0;
+        }
+
+        if (block.timestamp < cliff) { // cliff reached?
+            return 0; 
+        }
+
+        uint256 timeElapsed = block.timestamp - start;
+
+        bool unlockingPeriodFinished = timeElapsed >= duration;
+        if (unlockingPeriodFinished) { return amount; }
+
+        return amount * timeElapsed / duration;
+    }
+}

test/grant/TokenGrant.test.js

@@ -0,0 +1,123 @@
+const { expect } = require("chai")
+const {
+  ZERO_ADDRESS,
+  to1e18,
+  lastBlockTime,
+} = require("../helpers/contract-test-helpers")
+
+describe("TokenGrant", () => {
+  let grantee
+
+  beforeEach(async () => {
+    ;[grantee] = await ethers.getSigners()
+  })
+
+  describe("unlockedAmount", () => {
+    const assertionPrecision = to1e18(1) // +- 1 token
+
+    const amount = to1e18(100000) // 100k tokens
+    const duration = 15552000 // 180 days
+
+    let now
+
+    beforeEach(async () => {
+      now = await lastBlockTime()
+    })
+
+    context("before the schedule start", () => {
+      it("should return no tokens unlocked", async () => {
+        const start = now + 60
+        const cliff = now
+        const grant = await createGrant(false, amount, duration, start, cliff)
+        expect(await grant.unlockedAmount()).to.equal(0)
+      })
+    })
+
+    context("before the cliff ended", () => {
+      it("should return no tokens unlocked", async () => {
+        const start = now - 60
+        const cliff = now + 60
+        const grant = await createGrant(false, amount, duration, start, cliff)
+        expect(await grant.unlockedAmount()).to.equal(0)
+      })
+    })
+
+    context("after the cliff ended", () => {
+      it("should return token amount unlocked from the start", async () => {
+        const start = now - duration / 2
+        const cliff = now - 1
+        const grant = await createGrant(false, amount, duration, start, cliff)
+        expect(await grant.unlockedAmount()).is.closeTo(
+          to1e18(50000),
+          assertionPrecision
+        )
+      })
+    })
+
+    context("with no cliff", () => {
+      it("should return token amount unlocked so far", async () => {
+        const start = now - duration / 4
+        const cliff = now - duration / 4
+        const grant = await createGrant(false, amount, duration, start, cliff)
+        expect(await grant.unlockedAmount()).is.closeTo(
+          to1e18(25000),
+          assertionPrecision
+        )
+      })
+    })
+
+    context("when unlocking period finished", () => {
+      it("should return all tokens", async () => {
+        const start = now - duration - 1
+        const cliff = now - duration - 1
+        const grant = await createGrant(false, amount, duration, start, cliff)
+        expect(await grant.unlockedAmount()).is.closeTo(
+          to1e18(100000),
+          assertionPrecision
+        )
+      })
+    })
+
+    context("when in the middle of unlocking period", () => {
+      it("should return token amount unlocked from the start", async () => {
+        const start = now - duration / 2
+        const cliff = now - duration / 2
+        const grant = await createGrant(false, amount, duration, start, cliff)
+        expect(await grant.unlockedAmount()).is.closeTo(
+          to1e18(50000),
+          assertionPrecision
+        )
+      })
+    })
+
+    context("when the unlocking period just started", () => {
+      it("should return token amount unlocked so far", async () => {
+        const start = now - 3600 // one hour earlier
+        const cliff = now - 3600
+        const grant = await createGrant(false, amount, duration, start, cliff)
+        expect(await grant.unlockedAmount()).is.closeTo(
+          to1e18(23), // 3600 / 15552000 * 100k = ~23 tokens
+          assertionPrecision
+        )
+      })
+    })
+  })
+
+  async function createGrant(revocable, amount, duration, start, cliff) {
+    const TokenGrant = await ethers.getContractFactory("TokenGrant")
+    const tokenGrant = await TokenGrant.deploy()
+    await tokenGrant.deployed()
+
+    await tokenGrant.initialize(
+      grantee.address,
+      revocable,
+      amount,
+      duration,
+      start,
+      cliff,
+      ZERO_ADDRESS
+    )
+
+    return tokenGrant
+  }
+})

test/helpers/contract-test-helpers.js

@@ -12,8 +12,13 @@ async function getBlockTime(blockNumber) {
   return (await ethers.provider.getBlock(blockNumber)).timestamp
 }
 
+async function lastBlockTime() {
+  return (await ethers.provider.getBlock("latest")).timestamp
+}
+
 module.exports.to1e18 = to1e18
 module.exports.to1ePrecision = to1ePrecision
 module.exports.getBlockTime = getBlockTime
+module.exports.lastBlockTime = lastBlockTime
 
 module.exports.ZERO_ADDRESS = "0x0000000000000000000000000000000000000000"