[DO NOT MERGE] Diff check

.env.example

@@ -1,4 +1,3 @@
 PRIVATE_KEY=
 OP_SCAN_API_KEY=
-FTM_SCAN_API_KEY=
 ALCHEMY_API_KEY=

.gitignore

@@ -27,4 +27,7 @@ abi
 build
 scripts/xbribes
 # for verify
-Flattened.sol
+Flattened.sol
+lib/openzeppelin-contracts
+lib/forge-std
+lib/ds-test

.gitmodules

@@ -4,12 +4,11 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+	branch = v1.5.0
 [submodule "lib/solmate"]
 	path = lib/solmate
-	url = https://github.com/Rari-Capital/solmate
+	url = https://github.com/transmissions11/solmate
 [submodule "lib/openzeppelin-contracts"]
 	path = lib/openzeppelin-contracts
-	url = https://github.com/OpenZeppelin/openzeppelin-contracts
-[submodule "lib/LayerZero"]
-	path = lib/LayerZero
-	url = https://github.com/LayerZero-Labs/LayerZero
+	url = https://github.com/Openzeppelin/openzeppelin-contracts
+	branch = v4.8.2

contracts/AutoBribe.sol

@@ -0,0 +1,237 @@
+// SPDX-License-Identifier: MIT
+
+import "openzeppelin-contracts/contracts/access/Ownable.sol";
+import "contracts/interfaces/ITurnstile.sol";
+import "contracts/interfaces/IERC20.sol";
+import "contracts/interfaces/IVoter.sol";
+import "contracts/WrappedBribe.sol";
+
+pragma solidity ^0.8.13;
+
+// the purpose of this contract is to allow the projects to deposit bribes that will bribe their pools for a period of time
+// they will need to set up a public keeper, anyone can send the bribes
+// bribes are divided evenly into the amount of weeks designated when they deposit
+// each new deposit will NOT make a bribe immediately!
+// calling the bribe function is public and is rewarded with a share of the bribe token
+// !!!!!!!!!!!this contract handles multiple bribe tokens, and a single bribe contract!!!!!!!!!
+
+contract AutoBribe is Ownable {
+    address public constant TURNSTILE =
+        0xEcf044C5B4b867CFda001101c617eCd347095B44;
+    address public immutable voter;
+    address public immutable wBribe;
+
+    address public project;
+    bool public depositSealed;
+    bool public initialized;
+    uint256 public nextWeek;
+    address[] public bribeTokens;
+    mapping(address => bool) public bribeTokensDeposited;
+    mapping(address => uint256) public bribeTokenToWeeksLeft;
+    string public bribeName;
+
+    event Deposited(
+        address indexed _bribeToken,
+        uint256 _amount,
+        uint256 _weeks
+    );
+    event Bribed(uint256 indexed _timestamp, address _briber);
+    event EmptiedOut(uint256 indexed _timestamp, address project);
+    event Sealed(uint256 indexed _timestamp);
+    event UnSealed(uint256 indexed _timestamp);
+
+    constructor(
+        address _voter,
+        address _wBribe,
+        address _team,
+        string memory _name,
+        uint256 _csrNftId
+    ) {
+        voter = _voter;
+        wBribe = _wBribe;
+        nextWeek = block.timestamp;
+        _transferOwnership(_team);
+        ITurnstile(TURNSTILE).assign(_csrNftId);
+        bribeName = _name;
+    }
+
+    //########################################
+    //###########PUBLIC FUNCTIONS#############
+    //########################################
+
+    //This public function allows anyone to send the weekly allocation to the bribe contract
+    //There is a small reward for calling this function
+    //It can only be called once a week
+    function bribe() public {
+        require(block.timestamp >= nextWeek, "already bribed this week");
+        uint256 length = bribeTokens.length;
+        address _bribeToken;
+        for (uint256 i = 0; i < length; ) {
+            _bribeToken = bribeTokens[i];
+            uint256 weeksLeft = bribeTokenToWeeksLeft[_bribeToken];
+            uint256 bribeAmount = balance(_bribeToken) / weeksLeft;
+            uint256 gasReward = bribeAmount / 200;
+            _safeTransfer(_bribeToken, msg.sender, gasReward);
+            WrappedBribe(wBribe).notifyRewardAmount(
+                _bribeToken,
+                bribeAmount - gasReward
+            );
+            bribeTokenToWeeksLeft[_bribeToken] = weeksLeft - 1;
+            unchecked {
+                ++i;
+            }
+        }
+        nextWeek = nextWeek + 604800;
+        emit Bribed(nextWeek, msg.sender);
+    }
+
+    //This just returns the balance of bribe tokens in the contract
+    function balance(address _bribeToken) public view returns (uint) {
+        return IERC20(_bribeToken).balanceOf(address(this));
+    }
+
+    //########################################
+    //########PROJECT ADMIN FUNCTIONS#########
+    //########################################
+
+    //Allows project to deposit bribe tokens and set the weeks of which they are divided up into
+    function deposit(
+        address _bribeToken,
+        uint256 _amount,
+        uint256 _weeks
+    ) public {
+        require(msg.sender == project, "only the project can bribe");
+        require(_amount > 0, "Why are you depositing 0 tokens?");
+        require(_weeks > 0, "You have to put at least 1 week");
+        require(
+            IVoter(voter).isWhitelisted(_bribeToken),
+            "Bribe Token is not whitelisted"
+        );
+        _safeTransferFrom(_bribeToken, msg.sender, address(this), _amount);
+        uint256 allowance = IERC20(_bribeToken).allowance(
+            address(this),
+            wBribe
+        );
+        _safeApprove(_bribeToken, wBribe, allowance + _amount);
+        if (!bribeTokensDeposited[_bribeToken]) {
+            bribeTokensDeposited[_bribeToken] = true;
+            bribeTokens.push(_bribeToken);
+        }
+        bribeTokenToWeeksLeft[_bribeToken] += _weeks;
+
+        emit Deposited(_bribeToken, _amount, _weeks);
+    }
+
+    //Allows the project to retrieve their bribe tokens
+    function emptyOut() public {
+        require(msg.sender == project, "only project can empty out");
+        require(!depositSealed, "deposit is sealed");
+        uint256 length = bribeTokens.length;
+        uint256 amount;
+
+        for (uint256 i = 0; i < length; ) {
+            address bribeToken = bribeTokens[i];
+            amount = balance(bribeToken);
+            bribeTokenToWeeksLeft[bribeToken] = 0;
+            _safeTransfer(bribeToken, msg.sender, amount);
+
+            unchecked {
+                ++i;
+            }
+        }
+
+        emit EmptiedOut(block.timestamp, project);
+    }
+
+    //Allows project to seal the vault making it not possible for them to withdraw their tokens
+    function seal() public {
+        require(msg.sender == project, "only project can seal");
+        depositSealed = true;
+
+        emit Sealed(block.timestamp);
+    }
+
+    //Allows project to change their controlling wallet
+    function setProject(address _newWallet) public {
+        require(msg.sender == project);
+        project = _newWallet;
+    }
+
+    //########################################
+    //#######VELOCIMETER ADMIN FUNCTIONS######
+    //########################################
+
+    //Allows Velocimeter to re allow project to withdraw their tokens
+    function unSeal() public onlyOwner {
+        depositSealed = false;
+
+        emit UnSealed(block.timestamp);
+    }
+
+    function initProject(address _newWallet) public onlyOwner {
+        require(!initialized, "project wallet can only be set once by team");
+        if (!initialized) {
+            initialized = true;
+        }
+        project = _newWallet;
+    }
+
+    function inCaseTokensGetStuck(address _token) external onlyOwner {
+        require(!bribeTokensDeposited[_token], "!bribeToken");
+        uint256 amount = IERC20(_token).balanceOf(address(this));
+        _safeTransfer(_token, msg.sender, amount);
+    }
+
+    //########################################
+    //############RECLOCK FUNCTION############
+    //########################################
+
+    // Allows project or Velocimeter to reset the week to the current block
+    // This should only be called with consideration as it can allow for double bribes in a single week.
+    // Best use is to call it BEFORE, bribe() is called in a given week
+    function reclockBribeToNow() external {
+        require(
+            msg.sender == project || msg.sender == owner(),
+            "you can't call this"
+        );
+        nextWeek = block.timestamp;
+    }
+
+    //########################################
+    //############INTERNAL FUNCTIONS##########
+    //########################################
+
+    function _safeTransfer(address token, address to, uint256 value) internal {
+        require(token.code.length > 0);
+        (bool success, bytes memory data) = token.call(
+            abi.encodeWithSelector(IERC20.transfer.selector, to, value)
+        );
+        require(success && (data.length == 0 || abi.decode(data, (bool))));
+    }
+
+    function _safeTransferFrom(
+        address token,
+        address from,
+        address to,
+        uint256 value
+    ) internal {
+        require(token.code.length > 0);
+        (bool success, bytes memory data) = token.call(
+            abi.encodeWithSelector(
+                IERC20.transferFrom.selector,
+                from,
+                to,
+                value
+            )
+        );
+        require(success && (data.length == 0 || abi.decode(data, (bool))));
+    }
+
+    function _safeApprove(address token, address spender, uint value) internal {
+        require(token.code.length > 0);
+        (bool success, bytes memory data) = token.call(
+            abi.encodeWithSelector(IERC20.approve.selector, spender, value)
+        );
+        require(success && (data.length == 0 || abi.decode(data, (bool))));
+    }
+}

contracts/ExternalBribe.sol

@@ -1,23 +1,23 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.13;
 
-import 'contracts/libraries/Math.sol';
+import "openzeppelin-contracts/contracts/utils/math/Math.sol";
 import 'contracts/interfaces/IBribe.sol';
 import 'contracts/interfaces/IERC20.sol';
 import 'contracts/interfaces/IGauge.sol';
 import 'contracts/interfaces/IVoter.sol';
 import 'contracts/interfaces/IVotingEscrow.sol';
+import 'contracts/interfaces/ITurnstile.sol';
 
 // Bribes pay out rewards for a given pool based on the votes that were received from the user (goes hand in hand with Voter.vote())
 contract ExternalBribe is IBribe {
+    address public constant TURNSTILE = 0xEcf044C5B4b867CFda001101c617eCd347095B44;
     address public immutable voter; // only voter can modify balances (since it only happens on vote())
     address public immutable _ve; // 天使のたまご
 
     uint internal constant DURATION = 7 days; // rewards are released over the voting period
     uint internal constant MAX_REWARD_TOKENS = 16;
 
-    uint internal constant PRECISION = 10 ** 18;
-
     uint public totalSupply;
     mapping(uint => uint) public balanceOf;
     mapping(address => mapping(uint => uint)) public tokenRewardsPerEpoch;
@@ -53,7 +53,7 @@ contract ExternalBribe is IBribe {
     event NotifyReward(address indexed from, address indexed reward, uint epoch, uint amount);
     event ClaimRewards(address indexed from, address indexed reward, uint amount);
 
-    constructor(address _voter, address[] memory _allowedRewardTokens) {
+    constructor(address _voter, address[] memory _allowedRewardTokens, uint256 _csrNftId) {
         voter = _voter;
         _ve = IVoter(_voter)._ve();
 
@@ -63,6 +63,8 @@ contract ExternalBribe is IBribe {
                 rewards.push(_allowedRewardTokens[i]);
             }
         }
+
+        ITurnstile(TURNSTILE).assign(_csrNftId);
     }
 
     // simple re-entrancy check
@@ -292,7 +294,12 @@ contract ExternalBribe is IBribe {
         uint adjustedTstamp = getEpochStart(block.timestamp);
         uint epochRewards = tokenRewardsPerEpoch[token][adjustedTstamp];
 
+        uint256 balanceBefore = IERC20(token).balanceOf(address(this));
         _safeTransferFrom(token, msg.sender, address(this), amount);
+        uint256 balanceAfter = IERC20(token).balanceOf(address(this));
+
+        amount = balanceAfter - balanceBefore;
+
         tokenRewardsPerEpoch[token][adjustedTstamp] = epochRewards + amount;
 
         periodFinish[token] = adjustedTstamp + DURATION;