fix: only change in logic

.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,227 @@
+// SPDX-License-Identifier: MIT
+
+import "openzeppelin-contracts/contracts/access/Ownable.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 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) {
+        voter = _voter;
+        wBribe = _wBribe;
+        nextWeek = block.timestamp;
+        _transferOwnership(_team);
+        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,7 +1,7 @@
 // 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';
@@ -16,8 +16,6 @@ contract ExternalBribe is IBribe {
     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;
@@ -292,7 +290,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;

contracts/Velo.sol → contracts/Flow.sol

@@ -1,29 +1,26 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.13;
 
-import "contracts/interfaces/IVelo.sol";
+import "contracts/interfaces/IFlow.sol";
 
-contract Velo is IVelo {
+contract Flow is IFlow {
 
-    string public constant name = "Velodrome";
-    string public constant symbol = "VELO";
+    string public constant name = "Velocimeter";
+    string public constant symbol = "FLOW";
     uint8 public constant decimals = 18;
     uint public totalSupply = 0;
 
     mapping(address => uint) public balanceOf;
     mapping(address => mapping(address => uint)) public allowance;
 
-    bool public initialMinted;
     address public minter;
-    address public redemptionReceiver;
-    address public merkleClaim;
 
     event Transfer(address indexed from, address indexed to, uint value);
     event Approval(address indexed owner, address indexed spender, uint value);
 
-    constructor() {
+    constructor(address initialSupplyRecipient) {
         minter = msg.sender;
-        _mint(msg.sender, 0);
+        _mint(initialSupplyRecipient, 82800140034502500000000000);
     }
 
     // No checks as its meant to be once off to set minting rights to BaseV1 Minter
@@ -32,26 +29,6 @@ contract Velo is IVelo {
         minter = _minter;
     }
 
-    function setRedemptionReceiver(address _receiver) external {
-        require(msg.sender == minter);
-        redemptionReceiver = _receiver;
-    }
-
-    function setMerkleClaim(address _merkleClaim) external {
-        require(msg.sender == minter);
-        merkleClaim = _merkleClaim;
-    }
-
-    // Initial mint: total 82M
-    //  4M for "Genesis" pools
-    // 30M for liquid team allocation (40M excl init veNFT)
-    // 48M for future partners
-    function initialMint(address _recipient) external {
-        require(msg.sender == minter && !initialMinted);
-        initialMinted = true;
-        _mint(_recipient, 82 * 1e6 * 1e18);
-    }
-
     function approve(address _spender, uint _value) external returns (bool) {
         allowance[msg.sender][_spender] = _value;
         emit Approval(msg.sender, _spender, _value);
@@ -93,10 +70,4 @@ contract Velo is IVelo {
         _mint(account, amount);
         return true;
     }
-
-    function claim(address account, uint amount) external returns (bool) {
-        require(msg.sender == redemptionReceiver || msg.sender == merkleClaim);
-        _mint(account, amount);
-        return true;
-    }
 }