Inital Commit of the Project

Author: Napcalx

.github/workflows/test.yml

@@ -0,0 +1,45 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+env:
+  FOUNDRY_PROFILE: ci
+
+jobs:
+  check:
+    strategy:
+      fail-fast: true
+
+    name: Foundry project
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+        with:
+          version: nightly
+
+      - name: Show Forge version
+        run: |
+          forge --version
+
+      - name: Run Forge fmt
+        run: |
+          forge fmt --check
+        id: fmt
+
+      - name: Run Forge build
+        run: |
+          forge build --sizes
+        id: build
+
+      - name: Run Forge tests
+        run: |
+          forge test -vvv
+        id: test

.gitignore

@@ -0,0 +1,14 @@
+# Compiler files
+cache/
+out/
+
+# Ignores development broadcast logs
+!/broadcast
+/broadcast/*/31337/
+/broadcast/**/dry-run/
+
+# Docs
+docs/
+
+# Dotenv file
+.env

README.md

@@ -0,0 +1,11 @@
+# Cross-chain Rebase Token
+
+1. A protocl that allows users to deposit into a vault and in return, receive rebase tokens that represent their underlying balance.
+2. Rebase token -> balanceOf function that is dynamic to show the changing balance with time.
+   - Balance increases linearly with time
+   - mint tokens to our users every time they perform an action (mintin, burning, transferrring, or ... bridging)
+3. Interest Rate 
+   - Individually set an interest rate of each user based on some global interest rate of the protocol at the time the user deposits into the vault.
+   - This global interest rate can only decrease to incentivize /  reward the early adotpers.
+   - Increase Token Adoption
+   - 

foundry.toml

@@ -0,0 +1,7 @@
+[profile.default]
+src = "src"
+out = "out"
+libs = ["lib"]
+remappings = ["@openzeppelin/=lib/openzeppelin-contracts/"]
+
+# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

lib/forge-std

@@ -0,0 +1 @@
+Subproject commit 77041d2ce690e692d6e03cc812b57d1ddaa4d505

lib/openzeppelin-contracts

@@ -0,0 +1 @@
+Subproject commit e4f70216d759d8e6a64144a9e1f7bbeed78e7079

src/RebaseToken.sol

@@ -0,0 +1,198 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
+
+/**
+ * @title Rebase Token
+ * @author CX
+ * @notice This is a cross-chain rebase token that incentivizes users to deposit into a vault
+ * @notice The interest rate in the smart contract can only decrease
+ * @notice Each user will have their own interest rate which is the global inteste rate at
+ */
+
+contract RebaseToken is ERC20, Ownable, AccessControl {
+    error RebaseToken__InterestRateCanOnlyDecrease(
+        uint256 s_interestRate,
+        uint256 _newInterestRate
+    );
+
+    uint256 private constant PRECISION_FACTOR = 1e18;
+    bytes32 private constant MINT_AND_BURN_ROLE =
+        keccak256("MINT_AND_BURN_ROLE");
+    uint256 private s_interestRate = (5 * PRECISION_FACTOR) / 1e8;
+    mapping(address => uint256) private s_userInterestRate;
+    mapping(address => uint256) private s_userLastUpdatedTimeStamp;
+
+    event InterestRateSet(uint256 _newInterestRate);
+
+    constructor() ERC20("Rebase Token", "RBT") Ownable(msg.sender) {}
+
+    function grantMintAndBurnRole(address _account) external onlyOwner {
+        _grantRole(MINT_AND_BURN_ROLE, _account);
+    }
+
+    /**
+     * @notice Set the interest rate in the contract
+     * @param _newInterestRate The new interest rate to set
+     * @dev The interest rate can only decrease
+     */
+    function setInterestRate(uint256 _newInterestRate) external onlyOwner {
+        // set interest rate
+        if (_newInterestRate >= s_interestRate) {
+            revert RebaseToken__InterestRateCanOnlyDecrease(
+                s_interestRate,
+                _newInterestRate
+            );
+        }
+        s_interestRate = _newInterestRate;
+        emit InterestRateSet(_newInterestRate);
+    }
+
+    /**
+     * @notice Get the principle balance of a user, This is the number of tokens that have currently been minted to the user, not including any interest that has accrued since the last time the user interated with the protocl
+     * @param _user The user whose princple balance is been fetched
+     * @return The principle balance of the user
+     */
+    function getPrincipleBalanceOf(
+        address _user
+    ) external view returns (uint256) {
+        return super.balanceOf(_user);
+    }
+
+    /**
+     * @notice Mint the user tokens when they deposit into the vault
+     * @param _to The user to mint the tokens to
+     * @param amount The amount of tokens to mint
+     */
+    function mint(
+        address _to,
+        uint256 amount
+    ) external onlyRole(MINT_AND_BURN_ROLE) {
+        _mintAccruedInterest(_to);
+        s_userInterestRate[_to] = s_interestRate;
+        _mint(_to, amount);
+    }
+
+    /**
+     * @notice Burn the user tokens when they withdraw from the vault
+     * @param _from The user to burn the tokens from
+     * @param _amount The amount of tokens to burn
+     */
+    function burn(
+        address _from,
+        uint256 _amount
+    ) external onlyRole(MINT_AND_BURN_ROLE) {
+        _mintAccruedInterest(_from);
+        _burn(_from, _amount);
+    }
+
+    function balanceOf(address _user) public view override returns (uint256) {
+        // get the current principle balance of the user (the number of tokens that have actually been minted to the user)
+        // multiply the principle balance of the interest that has accumulated in the times since the balance was last updated
+        return
+            (super.balanceOf(_user) *
+                _calculateUserAccumulatedInterestSinceUpdate(_user)) /
+            PRECISION_FACTOR;
+    }
+
+    /**
+     * @notice Transfer tokens from one user to another
+     * @param _recipient The user to transfer the tokens to
+     * @param _amount The amount of tokens to transfer to the user
+     * @return True if the transfer succeeds
+     */
+    function transfer(
+        address _recipient,
+        uint256 _amount
+    ) public override returns (bool) {
+        _mintAccruedInterest(msg.sender);
+        _mintAccruedInterest(_recipient);
+        if (_amount == type(uint256).max) {
+            _amount = balanceOf(msg.sender);
+        }
+        if (balanceOf(_recipient) == 0) {
+            s_userInterestRate[_recipient] = s_userInterestRate[msg.sender];
+        }
+        return super.transfer(_recipient, _amount);
+    }
+
+    /**
+     * @notice Transfer tokens on behalf of the sender to the recipient
+     * @param _sender The user on whose behalf the tokens are being transfered
+     * @param _recipient The user thats receiving the transferred tokens
+     * @param _amount The amount of tokens that are to be transfered
+     * @return True is the token is transferred successfully
+     */
+    function transferFrom(
+        address _sender,
+        address _recipient,
+        uint256 _amount
+    ) public override returns (bool) {
+        _mintAccruedInterest(_sender);
+        _mintAccruedInterest(_recipient);
+        if (_amount == type(uint256).max) {
+            _amount = balanceOf(_sender);
+        }
+        if (balanceOf(_recipient) == 0) {
+            s_userInterestRate[_recipient] = s_userInterestRate[_sender];
+        }
+        return super.transferFrom(_sender, _recipient, _amount);
+    }
+
+    /**
+     * @notice Calculate the interest that has accumulated since the last update
+     * @param _user The user to calculate the interest accumulated for
+     * @return linearInterest The interest that has been accumulated since the last update
+     */
+    function _calculateUserAccumulatedInterestSinceUpdate(
+        address _user
+    ) internal view returns (uint256 linearInterest) {
+        // we need to calculate the interest that has accumulated since the last update
+        // this is going to be linear growth with time
+        // 1. calculate the time since the last update
+        // 2. calculate the amount of linear growth
+        uint256 timeElapsed = block.timestamp -
+            s_userLastUpdatedTimeStamp[_user];
+        linearInterest = (PRECISION_FACTOR +
+            (s_userInterestRate[_user] * timeElapsed));
+    }
+
+    /**
+     * @notice Mint the accrued interest to the user since the last time they interacted woth the protocl (e.g burn, mint, transfer)
+     * @param _user The user to which the accrued interest is being minted to
+     */
+    function _mintAccruedInterest(address _user) internal {
+        // (1) find their current balance of rebase tokens that have been minted to the user -> Principal
+        uint256 previousPrincipleBalance = super.balanceOf(_user);
+        // (2) calculate their current balance including any interest -> balanceOf
+        uint256 currentBalance = balanceOf(_user);
+        // calculate the number of tokens that need to be minted to the user -> (2) - (1)
+        uint256 balanceIncrease = currentBalance - previousPrincipleBalance;
+        // set the users last updated timestamp
+        s_userLastUpdatedTimeStamp[_user] = block.timestamp;
+        // call _mint to mint the tokens to the user
+        _mint(_user, balanceIncrease);
+    }
+
+    /**
+     * @notice Get the contract's current interest rate, to which any new depostior would get
+     * @return The interest rate of the contract
+     */
+    function getInterestRate() external view returns (uint256) {
+        return s_interestRate;
+    }
+
+    /**
+     * @notice Get the interest rate for the user
+     * @param _user The user to ge the interest rate for
+     * @return The Interest rate for the user
+     */
+    function getUserInterestrate(
+        address _user
+    ) external view returns (uint256) {
+        return s_userInterestRate[_user];
+    }
+}

src/Vault.sol

@@ -0,0 +1,59 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {IRebaseToken} from "./interface/IRebaseToken.sol";
+
+contract Vault {
+    // We need to pass the token address to the constructor
+    // create a deposit function that mints token to the user equal to the amount of ETH the user transfers in
+    // create a redeem function that burns tokens from the user and sends the user ETH
+    // create a way to add rewards to the vault
+
+    IRebaseToken private immutable i_rebaseToken;
+
+    event Deposit(address indexed user, uint256 indexed amount);
+    event Redeem(address indexed user, uint256 indexed amount);
+
+    error Vault__RedeemFailed();
+
+    constructor(IRebaseToken _rebaseToken) {
+        i_rebaseToken = _rebaseToken;
+    }
+
+    receive() external payable {}
+
+    /**
+     *@notice Allows users to deposit ETH into the vault and mint rebase tokens in return
+     */
+    function deposit() external payable {
+        // we need to use the amount of Eth the user has sent to mint tokens to the user
+        i_rebaseToken.mint(msg.sender, msg.value);
+        emit Deposit(msg.sender, msg.value);
+    }
+
+    /**
+     * @notice Enables users to redeem their rebase tokens from the vault for Eth
+     * @param _amount The is the amount of Rebase tokens to redeem
+     */
+    function redeem(uint256 _amount) external {
+        if (_amount == type(uint256).max) {
+            _amount = i_rebaseToken.balanceOf(msg.sender);
+        }
+        // 1. burn the tokens from the user
+        i_rebaseToken.burn(msg.sender, _amount);
+        // 2. we need to send the user Eth
+        (bool success, ) = payable(msg.sender).call{value: _amount}("");
+        if (!success) {
+            revert Vault__RedeemFailed();
+        }
+        emit Redeem(msg.sender, _amount);
+    }
+
+    /**
+     * @notice To retrive the rebase token address
+     * @return The address of the rebase token
+     */
+    function getRebaseTokenAddress() external view returns (address) {
+        return address(i_rebaseToken);
+    }
+}

src/interface/IRebaseToken.sol

@@ -0,0 +1,10 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+interface IRebaseToken {
+    function mint(address _to, uint256 _amount) external;
+
+    function burn(address _from, uint256 _amount) external;
+
+    function balanceOf(address _user) external view returns (uint256);
+}