test env up

Author: Logic-gate-sys

.gitmodules

@@ -7,3 +7,6 @@
 [submodule "lib/ccip"]
 	path = lib/ccip
 	url = https://github.com/smartcontractkit/ccip
+[submodule "lib/chainlink-local"]
+	path = lib/chainlink-local
+	url = https://github.com/smartcontractkit/chainlink-local

foundry.toml

@@ -5,10 +5,16 @@ libs = ["lib"]
 
 remappings = [
     "@openzeppelin/=lib/openzeppelin-contracts/",
-    '@ccip/=lib/ccip/'
+    '@ccip/=lib/ccip/',
+    '@chainlink-local/=lib/chainlink-local/'
 ]
 [fuzz]
 run=250
+
+rpc_endpoints = { sepolia = "YOUR_SEPOLIA_RPC_URL_HERE", arb-sepolia = "YOUR_ARB_SEPOLIA_RPC_URL_HERE" }
+# ... remappings​
+# Ensure you replace YOUR_SEPOLIA_RPC_URL_HERE and YOUR_ARB_SEPOLIA_RPC_URL_HERE
+# with your actual RPC provider URLs.
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options
 
 

lib/chainlink-local

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {Script} from "forge-std/Script.sol";
+import {TokenPool} from "@ccip/contracts/src/v0.8/ccip/pools/TokenPool.sol";
+import {RateLimiter} from "@ccip/contracts/src/v0.8/ccip/libraries/RateLimiter.sol";
+
+
+contract ConfigurePoolScript is Script {
+    function run(
+        address localPool,
+        uint64 remoteChainSelector,
+        address remotePool,
+        address remoteToken,
+        bool outboundRateLimiterIsEnabled,
+        uint128 outboundRateLimiterCapacity,
+        uint128 outboundRateLimiterRate,
+        bool inboundRateLimiterIsEnabled,
+        uint128 inboundRateLimiterCapacity,
+        uint128 inboundRateLimiterRate
+    ) public {
+        vm.startBroadcast();
+
+        // Prepare remotePoolAddresses (needs to be bytes[])
+        bytes[] memory remotePoolAddresses_ = new bytes[](1);
+        remotePoolAddresses_[0] = abi.encode(remotePool);​
+        // Prepare remoteTokenAddress (needs to be bytes)
+        bytes memory remoteTokenAddress_ = abi.encode(remoteToken);​
+        TokenPool.ChainUpdate[] memory chainsToAdd = new TokenPool.ChainUpdate[](1);​
+        chainsToAdd[0] = TokenPool.ChainUpdate({
+            chainSelector: remoteChainSelector,
+            remotePoolAddresses: remotePoolAddresses_,
+            remoteTokenAddress: remoteTokenAddress_,
+            outboundRateLimiterConfig: RateLimiter.Config({
+                isEnabled: outboundRateLimiterIsEnabled,
+                capacity: outboundRateLimiterCapacity,
+                rate: outboundRateLimiterRate
+            }),
+            inboundRateLimiterConfig: RateLimiter.Config({
+                isEnabled: inboundRateLimiterIsEnabled,
+                capacity: inboundRateLimiterCapacity,
+                rate: inboundRateLimiterRate
+            })
+        });
+
+        // Cast localPool address to TokenPool contract type
+        TokenPool(localPool).applyChainUpdates(
+            new uint64[](0), // Chains to remove (empty array)
+            chainsToAdd      // Chains to add/update
+        );
+        vm.stopBroadcast();
+    }
+}

script/ConfigurePool.s.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+
+import {Script} from "forge-std/Script.sol";
+import {RebaseToken} from "../src/RebaseToken.sol";
+import {RebaseTokenPool} from "../src/RebaseTokenPool.sol";
+import {Vault} from "../src/Vault.sol";
+// import {IRebaseToken} from "../src/interfaces/IRebaseToken.sol";
+import {CCIPLocalSimulatorFork, Register} from "@chainlink-local/src/ccip/CCIPLocalSimulatorFork.sol";
+import {IERC20} from "@ccip/contracts/src/v0.8/vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/IERC20.sol";
+import {RegistryModuleOwnerCustom} from "@ccip/contracts/src/v0.8/ccip/RegistryModuleOwnerCustom.sol";
+import {TokenAdminRegistry} from "@ccip/contracts/src/v0.8/ccip/TokenAdminRegistry.sol";
+
+
+
+contract TokenAndPoolDeployer is Script {
+    
+    // Implementation for RebaseToken and RebaseTokenPool deployment will be added here.
+    function run() public returns (RebaseToken token, RebaseTokenPool pool) {
+        CCIPLocalSimulatorFork ccipLocalSimulatorFork = new CCIPLocalSimulatorFork();
+       Register.NetworkDetails memory networkDetails = ccipLocalSimulatorFork.getNetworkDetails(block.chainid);
+        // Deployment and configuration logic
+         vm.startBroadcast();
+          token = new RebaseToken();
+          pool = new RebaseTokenPool(
+            IERC20(address(token)),            // The deployed token address
+            new address[](0),                  // Empty allowlist
+            networkDetails.rmnProxyAddress,    // RMN Proxy address from simulator
+            networkDetails.routerAddress       // Router address from simulator
+        );
+
+        token.grantMintAndBurnRole(address(pool));
+        //------------- CCIP CONFIGURATIONS  -----------------------
+        //register admin 
+        RegistryModuleOwnerCustom(networkDetails.registryModuleOwnerCustomAddress)
+        .registerAdminViaOwner(address(token));
+        //accept admin role 
+         TokenAdminRegistry(networkDetails.tokenAdminRegistryAddress)
+        .acceptAdminRole(address(token));
+        //set pool 
+         TokenAdminRegistry(networkDetails.tokenAdminRegistryAddress)
+        .setPool(address(token), address(pool));
+        vm.stopBroadcast();
+
+    }
+}
+
+
+contract VaultDeployer is Script {
+    // Implementation for Vault deployment will be detailed below.
+    function run(address _rebaseToken) public returns (Vault vault) {
+        vm.startBroadcast();
+        vault = new Vault(IRebaseToken(_rebaseToken)); // 'vault' is now assigned to the return variable
+        IRebaseToken(_rebaseToken).grantMintAndBurnRole(address(vault));
+        vm.stopBroadcast();
+        // Foundry implicitly returns the 'vault' instance here
+    }
+}

script/Deployer.s.sol

@@ -137,6 +137,14 @@ contract RebaseToken is ERC20, Ownable, AccessControl {
         return super.transfer(_spender, _amount);
     }
 
+    /**
+     *
+     * @param _account account of contract / user to be given acess to mint and burm
+     */
+    function grantMintAndBurnRole(address _account) external onlyOwner {
+        _grantRole(MINT_AND_BURN_ROLE, _account); // MINT_AND_BURN_ROLE is a bytes32 identifier
+    }
+
     /**
      * @notice Returns the current balance of an account, including accrued interest.
      * @param _user The address of the account.
@@ -186,8 +194,6 @@ contract RebaseToken is ERC20, Ownable, AccessControl {
     }
 
     //------------- getters, views and pure functions ---------------------------------------
-    
-  
 
     /**
      * @notice Gets the principle balance of a user (tokens actually minted to them), excluding any accrued interest.
@@ -206,8 +212,8 @@ contract RebaseToken is ERC20, Ownable, AccessControl {
         return s_interestRate;
     }
 
-    //get user's interets rate 
-    function getUserInterestRate(address _user) external returns (uint256){
+    //get user's interets rate
+    function getUserInterestRate(address _user) external returns (uint256) {
         return s_userInterestRate[_user];
     }
 }

src/RebaseToken.sol

@@ -1,61 +1,58 @@
 //SPDX-License-Identifier:MIT
-pragma solidity^0.8.24;
+pragma solidity ^0.8.24;
 
 import {TokenPool} from "@ccip/contracts/src/v0.8/ccip/pools/TokenPool.sol";
 import {IERC20} from "@ccip/contracts/src/v0.8/vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/IERC20.sol";
 import {IRebaseToken} from "./interfaces/IRebaseToken.sol"; // Adjust path if your interface is elsewhere
 import {Pool} from "@ccip/contracts/src/v0.8/ccip/libraries/Pool.sol"; // For CCIP structs
 
-contract RebaseTokenPool is TokenPool{
-    
-  /*** The TokenPool base constructor requires:
-    * @_token: The address of the rebase token this pool will manage.
-    * @
-    * @localTokenDecimals: The decimals of the token. Here, it's hardcoded to 18.
-    * @
-    * @_allowlist: An array of addresses permitted to send tokens through this pool.
-    * @
-    * @_rnmProxy: The address of the CCIP Risk Management Network (RMN) proxy.
-    * @
-    * @_router: The address of the CCIP router contract.
-   */
-  constructor (
-    IERC20 _token,
-    address[] memory _allowList,
-    address i_rmnProxy,
-    address _router
-  )TokenPool(_token,_allowList,i_rmnProxy,_router){
-    //constructor body
-  }
-
+contract RebaseTokenPool is TokenPool {
+    /**
+     * The TokenPool base constructor requires:
+     * @_token: The address of the rebase token this pool will manage.
+     * @
+     * @localTokenDecimals: The decimals of the token. Here, it's hardcoded to 18.
+     * @
+     * @_allowlist: An array of addresses permitted to send tokens through this pool.
+     * @
+     * @_rnmProxy: The address of the CCIP Risk Management Network (RMN) proxy.
+     * @
+     * @_router: The address of the CCIP router contract.
+     */
+    constructor(IERC20 _token, address[] memory _allowList, address i_rmnProxy, address _router)
+        TokenPool(_token, _allowList, i_rmnProxy, _router)
+    {
+        //constructor body
+    }
 
-  // lockorburn function to process burning upon transfering
-  function lockOrBurn(Pool.LockOrBurnInV1 calldata lockOrBurnIn) external returns (Pool.LockOrBurnOutV1 memory lockOrBurnOut) {
+    // lockorburn function to process burning upon transfering
+    function lockOrBurn(Pool.LockOrBurnInV1 calldata lockOrBurnIn)
+        external
+        override
+        returns (Pool.LockOrBurnOutV1 memory lockOrBurnOut)
+    {
         _validateLockOrBurn(lockOrBurnIn);
-        // Decode the original sender's address
-        address originalSender = abi.decode(lockOrBurnIn.originalSender, (address));
-        
-        // Fetch the user's current interest rate from the rebase token
-        uint256 userInterestRate = IRebaseToken(address(i_token)).getUserInterestRate(originalSender);
-        // Burn the specified amount of tokens from this pool contract
-        // CCIP transfers tokens to the pool before lockOrBurn is called
+        // Burn the tokens on the source chain. This returns their userAccumulatedInterest before the tokens were burned (in case all tokens were burned, we don't want to send 0 cross-chain)
+        uint256 userInterestRate = IRebaseToken(address(i_token)).getUserInterestRate(lockOrBurnIn.originalSender);
         IRebaseToken(address(i_token)).burn(address(this), lockOrBurnIn.amount);
-        // Prepare the output data for CCIP
+        // encode a function call to pass the caller's info to the destination pool and update it
         lockOrBurnOut = Pool.LockOrBurnOutV1({
             destTokenAddress: getRemoteToken(lockOrBurnIn.remoteChainSelector),
-            destPoolData: abi.encode(userInterestRate) // Encode the interest rate to send cross-chain
+            destPoolData: abi.encode(userInterestRate)
         });
-        // No explicit return statement is needed due to the named return variable
+        // because of named return variable in the function signature : no explicit return statement is needed
     }
 
     // when tokens are beign receive on the chain where this RebaseTokenPool is deployed
-    function releaseOrMint(
-        Pool.ReleaseOrMintInV1 calldata releaseOrMintIn
-    ) external override returns (Pool.ReleaseOrMintOutV1 memory /* releaseOrMintOut */) { // Named return optional
+    function releaseOrMint(Pool.ReleaseOrMintInV1 calldata releaseOrMintIn)
+        external
+        override
+        returns (Pool.ReleaseOrMintOutV1 memory /* releaseOrMintOut */ )
+    {
+        // Named return optional
         _validateReleaseOrMint(releaseOrMintIn);
         // Decode the user interest rate sent from the source pool
         uint256 userInterestRate = abi.decode(releaseOrMintIn.sourcePoolData, (uint256));
-        
         // The receiver address is directly available
         address receiver = releaseOrMintIn.receiver;
         // Mint tokens to the receiver, applying the propagated interest rate
@@ -64,9 +61,6 @@ contract RebaseTokenPool is TokenPool{
             releaseOrMintIn.amount,
             userInterestRate // Pass the interest rate to the rebase token's mint function
         );
-        return Pool.ReleaseOrMintOutV1({
-            destinationAmount: releaseOrMintIn.amount
-        });
+        return Pool.ReleaseOrMintOutV1({destinationAmount: releaseOrMintIn.amount});
     }
-
-}
+}

src/RebaseTokenPool.sol

@@ -29,8 +29,10 @@ contract Vault {
         if (amountToDeposite == 0) {
             revert Vault_NotEthSent();
         }
+        // get interest rete
+        uint256 interestRate = i_rebaseToken.getUserInterestRate(msg.sender);
         //  give mint
-        i_rebaseToken.mint(msg.sender, amountToDeposite);
+        i_rebaseToken.mint(msg.sender, amountToDeposite, interestRate);
 
         emit Vault_EthDeposited(msg.sender, amountToDeposite);
     }

src/Vault.sol

@@ -8,7 +8,7 @@ interface IRebaseToken {
      * @param _to The address to mint tokens to.
      * @param _amount The amount of tokens to mint.
      */
-    function mint(address _to, uint256 _amount) external;
+    function mint(address _to, uint256 _amount, uint256 _interestRate) external;
     /**
      * @notice Burns tokens from a specified address.
      * @param _from The address to burn tokens from.
@@ -17,4 +17,11 @@ interface IRebaseToken {
     function burn(address _from, uint256 _amount) external;
     // Note: We only include functions that the Vault contract will call.
     // Other functions from the actual RebaseToken.sol are not needed here.
+
+    function grantMintAndBurnRole(address _user) external;
+    /**
+     * @param _account the user whose locked interest rate is to be retrieved
+     * @return uint256 the locked interest rate
+     */
+    function getUserInterestRate(address _account) external view returns (uint256);
 }