Voting Multipliers

script/deploy/DeployNFTMultiplier.s.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import {Script} from "forge-std/Script.sol";
+import {NFTMultiplier} from "src/multipliers/NFTMultiplier.sol";
+import {TransparentUpgradeableProxy} from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {console} from "forge-std/console.sol";
+
+contract DeployNFTMultiplier is Script {
+    function run() external {
+        uint256 deployerPrivateKey;
+        address nftContractAddress;
+        uint256 initialMultiplyingFactor;
+        uint256 validUntilBlock;
+
+        string memory configPath = "deploy_config.json";
+        string memory jsonData;
+        // Try to read the JSON file, if it doesn't exist or can't be read, catch the error
+        try vm.readFile(configPath) returns (string memory data) {
+            jsonData = data;
+        } catch {
+            console.log("Config file not found or couldn't be read. Falling back to environment variables.");
+            jsonData = "";
+        }
+
+        if (bytes(jsonData).length > 0) {
+            // Read from JSON if file exists
+            deployerPrivateKey = vm.parseJsonUint(jsonData, ".deployerPrivateKey");
+            nftContractAddress = vm.parseJsonAddress(jsonData, ".nftContractAddress");
+            initialMultiplyingFactor = vm.parseJsonUint(jsonData, ".initialMultiplyingFactor");
+            validUntilBlock = vm.parseJsonUint(jsonData, ".validUntilBlock");
+        } else {
+            // Fall back to environment variables
+            deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+            nftContractAddress = vm.envAddress("NFT_CONTRACT_ADDRESS");
+            initialMultiplyingFactor = vm.envUint("INITIAL_MULTIPLYING_FACTOR");
+            validUntilBlock = vm.envUint("VALID_UNTIL_BLOCK");
+        }
+
+        // Check if all required variables are set
+        require(deployerPrivateKey != 0, "Deployer private key not set");
+        require(nftContractAddress != address(0), "NFT contract address not set");
+        require(initialMultiplyingFactor != 0, "Initial multiplying factor not set");
+        require(validUntilBlock != 0, "Valid until block not set");
+
+        vm.startBroadcast(deployerPrivateKey);
+
+        NFTMultiplier implementation = new NFTMultiplier();
+
+        bytes memory initData = abi.encodeWithSelector(
+            NFTMultiplier.initialize.selector, IERC721(nftContractAddress), initialMultiplyingFactor, validUntilBlock
+        );
+
+        TransparentUpgradeableProxy proxy =
+            new TransparentUpgradeableProxy(address(implementation), vm.addr(deployerPrivateKey), initData);
+
+        NFTMultiplier nftMultiplier = NFTMultiplier(address(proxy));
+
+        vm.stopBroadcast();
+
+        console.log("NFTMultiplier deployed at:", address(nftMultiplier));
+    }
+}

script/deploy/config/deployNFTMul.json

@@ -0,0 +1,6 @@
+{
+    "deployerPrivateKey": "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+    "nftContractAddress": "0x1234567890123456789012345678901234567890",
+    "initialMultiplyingFactor": 100,
+    "validUntilBlock": 1000000
+}

src/VotingMultipliers.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import {IVotingMultipliers, IMultiplier} from "src/interfaces/IVotingMultipliers.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+
+/// @title VotingMultipliers
+/// @notice A contract for managing voting multipliers
+/// @dev Implements IVotingMultipliers interface
+contract VotingMultipliers is OwnableUpgradeable, IVotingMultipliers {
+    /// @notice Array of whitelisted multiplier contracts
+    IMultiplier[] public whitelistedMultipliers;
+
+    /// @notice Calculates the total multiplier for a given user
+    /// @param user The address of the user
+    /// @return The total multiplier value for the user
+    function getTotalMultipliers(address user) external view returns (uint256) {
+        uint256 totalMultiplier = 0;
+        for (uint256 i = 0; i < whitelistedMultipliers.length; i++) {
+            IMultiplier multiplier = whitelistedMultipliers[i];
+            if (block.number <= multiplier.validUntil(user)) {
+                totalMultiplier += multiplier.getMultiplyingFactor(user);
+            }
+        }
+        return totalMultiplier;
+    }
+
+    /// @notice Adds a multiplier to the whitelist
+    /// @param _multiplier The multiplier contract to be added
+    function addMultiplier(IMultiplier _multiplier) external onlyOwner {
+        // Check if the multiplier is already whitelisted
+        for (uint256 i = 0; i < whitelistedMultipliers.length; i++) {
+            if (whitelistedMultipliers[i] == _multiplier) {
+                revert MultiplierAlreadyWhitelisted();
+            }
+        }
+        whitelistedMultipliers.push(_multiplier);
+        emit MultiplierAdded(_multiplier);
+    }
+
+    /// @notice Removes a multiplier from the whitelist
+    /// @param _multiplier The multiplier contract to be removed
+    function removeMultiplier(IMultiplier _multiplier) external onlyOwner {
+        bool isWhitelisted = false;
+        for (uint256 i = 0; i < whitelistedMultipliers.length; i++) {
+            if (whitelistedMultipliers[i] == _multiplier) {
+                whitelistedMultipliers[i] = whitelistedMultipliers[whitelistedMultipliers.length - 1];
+                whitelistedMultipliers.pop();
+                isWhitelisted = true;
+                emit MultiplierRemoved(_multiplier);
+                break;
+            }
+        }
+        if (!isWhitelisted) {
+            revert MultiplierNotWhitelisted();
+        }
+    }
+}

src/YieldDistributor.sol

@@ -9,6 +9,7 @@ import {ERC20VotesUpgradeable} from
 import {Bread} from "bread-token/src/Bread.sol";
 
 import {IYieldDistributor} from "src/interfaces/IYieldDistributor.sol";
+import {VotingMultipliers} from "src/VotingMultipliers.sol";
 
 /**
  * @title Breadchain Yield Distributor
@@ -20,7 +21,7 @@ import {IYieldDistributor} from "src/interfaces/IYieldDistributor.sol";
  * @custom:coauthor kassandra.eth
  * @custom:coauthor theblockchainsocialist.eth
  */
-contract YieldDistributor is IYieldDistributor, OwnableUpgradeable {
+contract YieldDistributor is IYieldDistributor, OwnableUpgradeable, VotingMultipliers {
     /// @notice The address of the $BREAD token contract
     Bread public BREAD;
     /// @notice The precision to use for calculations
@@ -108,12 +109,13 @@ contract YieldDistributor is IYieldDistributor, OwnableUpgradeable {
      * @return uint256 The voting power of the user
      */
     function getCurrentVotingPower(address _account) public view returns (uint256) {
-        return this.getVotingPowerForPeriod(
-            BREAD, lastClaimedBlockNumber - cycleLength, lastClaimedBlockNumber, _account
-        )
-            + this.getVotingPowerForPeriod(
-                BUTTERED_BREAD, lastClaimedBlockNumber - cycleLength, lastClaimedBlockNumber, _account
-            );
+        uint256 lastCycleStart = lastClaimedBlockNumber - cycleLength;
+        uint256 multiplier = this.getTotalMultipliers(_account);
+        multiplier = multiplier == 0 ? 1e18 : multiplier;
+        uint256 breadVotingPower = this.getVotingPowerForPeriod(BREAD, lastCycleStart, lastClaimedBlockNumber, _account);
+        uint256 butteredBreadVotingPower =
+            this.getVotingPowerForPeriod(BUTTERED_BREAD, lastCycleStart, lastClaimedBlockNumber, _account);
+        return (breadVotingPower + butteredBreadVotingPower) * multiplier / PRECISION;
     }
 
     /**

src/interfaces/IVotingMultipliers.sol

@@ -0,0 +1,35 @@
+pragma solidity ^0.8.22;
+
+import {IMultiplier} from "./multipliers/IMultiplier.sol";
+
+/// @title IVotingMultipliers
+/// @notice Interface for the VotingMultipliers contract
+/// @dev This interface defines the structure and functions for managing voting multipliers
+interface IVotingMultipliers {
+    /// @notice Thrown when attempting to add a multiplier that is already whitelisted
+    error MultiplierAlreadyWhitelisted();
+    /// @notice Thrown when attempting to remove a multiplier that is not whitelisted
+    error MultiplierNotWhitelisted();
+    /// @notice Emitted when a new multiplier is added to the whitelist
+    /// @param multiplier The address of the added multiplier
+
+    event MultiplierAdded(IMultiplier indexed multiplier);
+    /// @notice Emitted when a multiplier is removed from the whitelist
+    /// @param multiplier The address of the removed multiplier
+    event MultiplierRemoved(IMultiplier indexed multiplier);
+    /// @notice Returns the multiplier at the specified index in the whitelist
+    /// @param index The index of the multiplier in the whitelist
+    /// @return The multiplier contract at the specified index
+
+    function whitelistedMultipliers(uint256 index) external view returns (IMultiplier);
+    /// @notice Calculates the total multiplier for a given user
+    /// @param user The address of the user
+    /// @return The total multiplier value for the user
+    function getTotalMultipliers(address user) external view returns (uint256);
+    /// @notice Adds a multiplier to the whitelist
+    /// @param _multiplier The multiplier contract to be added
+    function addMultiplier(IMultiplier _multiplier) external;
+    /// @notice Removes a multiplier from the whitelist
+    /// @param _multiplier The multiplier contract to be removed
+    function removeMultiplier(IMultiplier _multiplier) external;
+}

src/interfaces/multipliers/ICrossChainProveableMultiplier.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import {IProveableMultiplier} from "src/interfaces/multipliers/IProveableMultiplier.sol";
+
+/// @title Cross-Chain Proveable Multiplier Interface
+/// @notice Interface for contracts that provide a cross-chain proveable multiplying factor
+
+interface ICrossChainProveableMultiplier is IProveableMultiplier {
+    /// @notice Get the address of the bridge contract
+    /// @return The address of the contract used for cross-chain communication
+    function bridge() external view returns (address);
+}

src/interfaces/multipliers/IDynamicNFTMultiplier.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import {INFTMultiplier} from "src/interfaces/multipliers/INFTMultiplier.sol";
+/// @title Dynamic NFT Multiplier Interface
+/// @notice Interface for contracts that provide a dynamic multiplying factor for users based on NFT ownership
+/// @dev Extends the INFTMultiplier interface with dynamic multiplier functionality
+
+interface IDynamicNFTMultiplier is INFTMultiplier {
+    /// @notice Get the multiplying factor for a user
+    /// @param user The address of the user
+    /// @return The multiplying factor for the user
+    function userToFactor(address user) external view returns (uint256);
+
+    /// @notice Get the validity period for a user's factor
+    /// @param user The address of the user
+    /// @return The timestamp until which the user's factor is valid
+    function userToValidity(address user) external view returns (uint256);
+}

src/interfaces/multipliers/IMultiplier.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IMultiplier {
+    /// @notice Returns the voting multiplier for `user`.
+    function getMultiplyingFactor(address user) external view returns (uint256);
+
+    /// @notice Returns the validity period of the multiplier for `user`.
+    function validUntil(address user) external view returns (uint256);
+}

src/interfaces/multipliers/INFTMultiplier.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IMultiplier} from "src/interfaces/multipliers/IMultiplier.sol";
+
+/// @title NFT Multiplier Interface
+/// @notice Interface for contracts that provide multiplying factors based on NFT ownership
+/// @dev Extends the IMultiplier interface with NFT-specific functionality
+interface INFTMultiplier is IMultiplier {
+    /// @notice Get the address of the NFT contract
+    /// @return The address of the NFT contract used for checking ownership
+    function NFTAddress() external view returns (IERC721);
+
+    /// @notice Check if a user owns an NFT
+    /// @param user The address of the user to check
+    /// @return True if the user owns at least one NFT, false otherwise
+    function hasNFT(address user) external view returns (bool);
+}

src/interfaces/multipliers/IOffChainProveableMultiplier.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import {IProveableMultiplier} from "src/interfaces/multipliers/IProveableMultiplier.sol";
+
+/// @title Off-Chain Proveable Multiplier Interface
+/// @notice Interface for contracts that provide an off-chain proveable multiplying factor
+interface IOffChainProveableMultiplier is IProveableMultiplier {
+    /// @notice Get the address of the pull oracle
+    /// @return The address of the oracle used for off-chain data verification
+    function oracle() external view returns (address);
+}

src/interfaces/multipliers/IOnChainProveableMultiplier.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import {IProveableMultiplier} from "src/interfaces/multipliers/IProveableMultiplier.sol";
+/// @title On-Chain Proveable Multiplier Interface
+/// @notice Interface for contracts that provide an on-chain proveable multiplying factor
+
+interface IOnChainProveableMultiplier is IProveableMultiplier {
+    /// @notice Get the address of the activity contract
+    /// @return The address of the contract used for verifying on-chain activities
+    function activityContract() external view returns (address);
+}

src/interfaces/multipliers/IProveableMultiplier.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {IDynamicNFTMultiplier} from "src/interfaces/multipliers/IDynamicNFTMultiplier.sol";
+/// @title Proveable Multiplier Interface
+/// @notice Interface for contracts that provide a proveable multiplying factor based on user activities
+
+interface IProveableMultiplier is IERC721, IDynamicNFTMultiplier {
+    /// @notice Submit activities to potentially earn or upgrade an NFT
+    /// @param data Encoded data representing the activities
+    function submitActivities(bytes calldata data) external;
+}

src/multipliers/NFTMultiplier.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.22;
+
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+import {INFTMultiplier} from "src/interfaces/multipliers/INFTMultiplier.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+/// @title NFT Multiplier
+/// @notice Implementation of INFTMultiplier interface
+/// @dev Provides multiplying factors based on NFT ownership
+contract NFTMultiplier is INFTMultiplier, Initializable, OwnableUpgradeable {
+    IERC721 public nftContract;
+    uint256 public multiplyingFactor;
+    uint256 public validUntilBlock;
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice Initializer function to set the NFT contract address and initial multiplying factor
+    /// @param _nftContract Address of the NFT contract
+    /// @param _initialMultiplyingFactor Initial multiplying factor
+    /// @param _validUntilBlock Block number until which the multiplier is valid
+    function initialize(IERC721 _nftContract, uint256 _initialMultiplyingFactor, uint256 _validUntilBlock)
+        public
+        initializer
+    {
+        __Ownable_init(msg.sender);
+
+        nftContract = _nftContract;
+        multiplyingFactor = _initialMultiplyingFactor;
+        validUntilBlock = _validUntilBlock;
+    }
+
+    /// @notice Get the address of the NFT contract
+    /// @return The address of the NFT contract used for checking ownership
+    function NFTAddress() external view override returns (IERC721) {
+        return nftContract;
+    }
+
+    /// @notice Check if a user owns an NFT
+    /// @param user The address of the user to check
+    /// @return True if the user owns at least one NFT, false otherwise
+    function hasNFT(address user) public view override returns (bool) {
+        return nftContract.balanceOf(user) > 0;
+    }
+
+    /// @notice Get the multiplying factor for a given user
+    /// @param user The address of the user
+    /// @return The multiplying factor if the user owns an NFT, 0 otherwise
+    function getMultiplyingFactor(address user) external view override returns (uint256) {
+        return hasNFT(user) ? multiplyingFactor : 0;
+    }
+
+    /// @notice Get the block number until which the multiplier is valid
+    /// @return The block number until which the multiplier is valid
+    function validUntil(address /* user */ ) external view override returns (uint256) {
+        return validUntilBlock;
+    }
+
+    /// @notice Update the multiplying factor
+    /// @param _newMultiplyingFactor New multiplying factor (in basis points)
+    function updateMultiplyingFactor(uint256 _newMultiplyingFactor) external onlyOwner {
+        multiplyingFactor = _newMultiplyingFactor;
+    }
+
+    /// @notice Update the valid until block
+    /// @param _newValidUntilBlock New block number until which the multiplier is valid
+    function updateValidUntilBlock(uint256 _newValidUntilBlock) external onlyOwner {
+        validUntilBlock = _newValidUntilBlock;
+    }
+
+    /// @notice Update the NFT contract address
+    /// @param _newNFTContract New NFT contract address
+    function updateNFTContract(IERC721 _newNFTContract) external onlyOwner {
+        nftContract = _newNFTContract;
+    }
+}