Add Talent Vault base contract

.tool-versions

@@ -1 +1,2 @@
 nodejs 20.12.2
+solidity 0.8.24

contracts/talent/TalentRewardClaim.sol

@@ -7,13 +7,15 @@ import "@openzeppelin/contracts/utils/math/Math.sol";
 import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
 import "./TalentProtocolToken.sol";
 import "../passport/PassportBuilderScore.sol";
+import "../passport/PassportWalletRegistry.sol";
 import "../merkle/MerkleProof.sol";
 
 contract TalentRewardClaim is Ownable, ReentrancyGuard {
   using Math for uint256;
 
   TalentProtocolToken public talentToken;
   PassportBuilderScore public passportBuilderScore;
+  PassportWalletRegistry public passportWalletRegistry;
   address public holdingWallet;
   uint256 public constant WEEKLY_CLAIM_AMOUNT = 2000 ether;
   uint256 public constant WEEK_DURATION = 7 days;
@@ -36,13 +38,15 @@ contract TalentRewardClaim is Ownable, ReentrancyGuard {
   constructor(
     TalentProtocolToken _talentToken,
     PassportBuilderScore _passportBuilderScore,
+    PassportWalletRegistry _passportWalletRegistry,
     address _holdingWallet,
     address initialOwner,
     bytes32 _merkleRoot
   ) Ownable(initialOwner) {
     merkleRoot = _merkleRoot;
     talentToken = _talentToken;
     passportBuilderScore = _passportBuilderScore;
+    passportWalletRegistry = _passportWalletRegistry;
     holdingWallet = _holdingWallet;
   }
 
@@ -80,6 +84,7 @@ contract TalentRewardClaim is Ownable, ReentrancyGuard {
     uint256 amountAllocated
   ) external nonReentrant {
     require(startTime > 0, "Start time not set");
+    require(block.timestamp >= startTime, "Claiming has not started yet");
 
     verify(merkleProof, amountAllocated);
 
@@ -89,7 +94,7 @@ contract TalentRewardClaim is Ownable, ReentrancyGuard {
     UserInfo storage user = userInfo[msg.sender];
     require(amountToClaim > 0, "No tokens owed");
 
-    uint256 passportId = passportBuilderScore.passportRegistry().passportId(beneficiary);
+    uint256 passportId = passportWalletRegistry.passportId(beneficiary);
     uint256 builderScore = passportBuilderScore.getScore(passportId);
 
     uint256 claimMultiplier = (builderScore > 40) ? 5 : 1;

contracts/talent/TalentTGEUnlock.sol

@@ -61,12 +61,11 @@ contract TalentTGEUnlock is Ownable {
         verifyAmount(merkleProofClaim, amountAllocated);
 
         address beneficiary = msg.sender;
-        uint256 amountToClaim = calculate(beneficiary, amountAllocated);
 
-        claimed[beneficiary] += amountToClaim;
-        IERC20(token).safeTransfer(beneficiary, amountToClaim);
+        claimed[beneficiary] += amountAllocated;
+        IERC20(token).safeTransfer(beneficiary, amountAllocated);
 
-        emit Claimed(beneficiary, amountToClaim, 0);
+        emit Claimed(beneficiary, amountAllocated, 0);
     }
 
     function verifyAmount(
@@ -84,15 +83,6 @@ contract TalentTGEUnlock is Ownable {
         );
     }
 
-    function calculate(
-        address beneficiary,
-        uint256 amountAllocated
-    ) internal view returns (uint256 amountToClaim) {
-        uint256 amountClaimed = claimed[beneficiary];
-        assert(amountClaimed <= amountAllocated);
-        amountToClaim = amountAllocated - amountClaimed;
-    }
-
     function setMerkleRoot(bytes32 nextMerkleRoot) external onlyOwner {
         merkleRoot = nextMerkleRoot;
     }

contracts/talent/TalentTGEUnlockTimestamp.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: MIT
+// Based on: https://github.com/gnosis/safe-token-distribution/blob/master/tooling/contracts/MerkleDistribution.sol
+pragma solidity ^0.8.24;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import "../merkle/MerkleProof.sol";
+
+contract TalentTGEUnlockTimestamp is Ownable {
+    using SafeERC20 for IERC20;
+
+    event Claimed(address indexed claimer, uint256 amount, uint256 burned);
+
+    address public immutable token;
+    bytes32 public merkleRoot;
+    bool public isContractEnabled;
+    uint256 public unlockTimestamp;
+    mapping(address => uint256) public claimed;
+
+    constructor(
+        address _token,
+        bytes32 _merkleRoot,
+        address owner,
+        uint256 _unlockTimestamp
+    ) Ownable(owner) {
+        token = _token;
+        merkleRoot = _merkleRoot;
+        isContractEnabled = false;
+        unlockTimestamp = _unlockTimestamp;
+    }
+
+    function setUnlockTimestamp(uint256 _unlockTimestamp) external onlyOwner {
+        unlockTimestamp = _unlockTimestamp;
+    }
+
+    function disableContract() external onlyOwner {
+        isContractEnabled = false;
+    }
+
+    function enableContract() external onlyOwner {
+        isContractEnabled = true;
+    }
+
+    function claim(
+        bytes32[] calldata merkleProofClaim,
+        uint256 amountAllocated
+    ) external {
+        require(isContractEnabled, "Contracts are disabled");
+        require(block.timestamp >= unlockTimestamp, "Unlock period not started");
+        require(claimed[msg.sender] == 0, "Already claimed");
+        verifyAmount(merkleProofClaim, amountAllocated);
+
+        address beneficiary = msg.sender;
+        uint256 amountToClaim = calculate(beneficiary, amountAllocated);
+
+        claimed[beneficiary] += amountToClaim;
+        IERC20(token).safeTransfer(beneficiary, amountToClaim);
+
+        emit Claimed(beneficiary, amountToClaim, 0);
+    }
+
+    function verifyAmount(
+        bytes32[] calldata proof,
+        uint256 amountAllocated
+    ) internal view {
+        bytes32 root = merkleRoot;
+        bytes32 leaf = keccak256(
+            bytes.concat(keccak256(abi.encode(msg.sender, amountAllocated)))
+        );
+
+        require(
+            MerkleProof.verify(proof, root, leaf),
+            "Invalid Allocation Proof"
+        );
+    }
+
+    function calculate(
+        address beneficiary,
+        uint256 amountAllocated
+    ) internal view returns (uint256 amountToClaim) {
+        uint256 amountClaimed = claimed[beneficiary];
+        assert(amountClaimed <= amountAllocated);
+        amountToClaim = amountAllocated - amountClaimed;
+    }
+
+    function setMerkleRoot(bytes32 nextMerkleRoot) external onlyOwner {
+        merkleRoot = nextMerkleRoot;
+    }
+
+    function withdraw() external onlyOwner {
+        IERC20(token).transfer(owner(), IERC20(token).balanceOf(address(this)));
+    }
+}