Multi-Layer Staking Governance Model Solidity, JavaScript, Web3

Okay, here's a program example implementing a simplified multi-layer staking governance model using Solidity, JavaScript, and Web3.js.  This example provides a basic framework. Keep in mind that a production-ready implementation would require significantly more robust error handling, security audits, and gas optimization.

**Solidity (Smart Contract): `MultiLayerStaking.sol`**

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

contract MultiLayerStaking is Ownable {
    using SafeMath for uint256;

    IERC20 public stakingToken;  // The token being staked
    IERC20 public rewardToken;   // The token distributed as rewards

    uint256 public totalStaked;  // Total amount of stakingToken staked

    uint256 public rewardRatePerSecond;  // Rewards distributed per second per staked token

    uint256 public lastRewardTimestamp;  // Last time rewards were updated

    mapping(address => uint256) public stakedBalances; // User staking balances
    mapping(address => uint256) public pendingRewards;  // User pending rewards

    // Governance Layer 1:  Simple Voting (Stake-Weighted)
    struct Proposal {
        string description;
        uint256 startTime;
        uint256 endTime;
        uint256 yesVotes;
        uint256 noVotes;
        bool executed;
    }

    mapping(uint256 => Proposal) public proposals;
    uint256 public proposalCount;

    event Staked(address indexed user, uint256 amount);
    event Unstaked(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);
    event ProposalCreated(uint256 proposalId, string description, uint256 startTime, uint256 endTime);
    event Voted(uint256 proposalId, address indexed voter, bool vote); // True for Yes, False for No
    event ProposalExecuted(uint256 proposalId);

    constructor(address _stakingToken, address _rewardToken) {
        stakingToken = IERC20(_stakingToken);
        rewardToken = IERC20(_rewardToken);
        lastRewardTimestamp = block.timestamp;
        rewardRatePerSecond = 0; // Initially, no rewards
    }

    // **** Staking Functionality ****

    function stake(uint256 amount) public {
        require(amount > 0, "Amount must be greater than 0");

        // Transfer staking tokens from user to contract
        require(stakingToken.transferFrom(msg.sender, address(this), amount), "Transfer failed");

        _updateRewards(msg.sender); // Update rewards before staking
        stakedBalances[msg.sender] = stakedBalances[msg.sender].add(amount);
        totalStaked = totalStaked.add(amount);

        emit Staked(msg.sender, amount);
    }

    function unstake(uint256 amount) public {
        require(amount > 0, "Amount must be greater than 0");
        require(stakedBalances[msg.sender] >= amount, "Insufficient balance");

        _updateRewards(msg.sender); // Update rewards before unstaking

        stakedBalances[msg.sender] = stakedBalances[msg.sender].sub(amount);
        totalStaked = totalStaked.sub(amount);

        // Transfer staking tokens from contract to user
        require(stakingToken.transfer(msg.sender, amount), "Transfer failed");

        emit Unstaked(msg.sender, amount);
    }

    function claimRewards() public {
        _updateRewards(msg.sender);
        uint256 reward = pendingRewards[msg.sender];
        require(reward > 0, "No rewards to claim");

        pendingRewards[msg.sender] = 0;

        // Transfer reward tokens from contract to user
        require(rewardToken.transfer(msg.sender, reward), "Reward transfer failed");

        emit RewardPaid(msg.sender, reward);
    }

    // **** Governance Functionality (Layer 1: Simple Voting) ****

    function createProposal(string memory _description, uint256 _startTime, uint256 _endTime) public onlyOwner {
        require(_startTime >= block.timestamp, "Start time must be in the future");
        require(_endTime > _startTime, "End time must be after start time");

        proposalCount++;
        proposals[proposalCount] = Proposal({
            description: _description,
            startTime: _startTime,
            endTime: _endTime,
            yesVotes: 0,
            noVotes: 0,
            executed: false
        });

        emit ProposalCreated(proposalCount, _description, _startTime, _endTime);
    }

    function vote(uint256 _proposalId, bool _vote) public {
        require(_proposalId > 0 && _proposalId <= proposalCount, "Invalid proposal ID");
        require(block.timestamp >= proposals[_proposalId].startTime && block.timestamp <= proposals[_proposalId].endTime, "Voting period is not active");
        require(stakedBalances[msg.sender] > 0, "Must have staked tokens to vote");
        require(!proposals[_proposalId].executed, "Proposal has already been executed");  //prevent voting on executed proposal

        if (_vote) {
            proposals[_proposalId].yesVotes = proposals[_proposalId].yesVotes.add(stakedBalances[msg.sender]);
        } else {
            proposals[_proposalId].noVotes = proposals[_proposalId].noVotes.add(stakedBalances[msg.sender]);
        }

        emit Voted(_proposalId, msg.sender, _vote);
    }

    function executeProposal(uint256 _proposalId) public onlyOwner {
        require(_proposalId > 0 && _proposalId <= proposalCount, "Invalid proposal ID");
        require(block.timestamp > proposals[_proposalId].endTime, "Voting period has not ended");
        require(!proposals[_proposalId].executed, "Proposal has already been executed");

        Proposal storage proposal = proposals[_proposalId];

        if (proposal.yesVotes > proposal.noVotes) {
            // In a real application, you would implement the logic to execute the proposal here.
            // This could involve calling other contracts, changing contract state variables, etc.
            // For this example, we simply emit an event.

            proposal.executed = true;
            emit ProposalExecuted(_proposalId);
        } else {
            // Proposal failed.  You might want to emit a different event here.
            proposal.executed = true; // Mark as executed even if failed to prevent re-execution
        }
    }

    // **** Admin Functionality ****

    function setRewardRate(uint256 _rewardRatePerSecond) public onlyOwner {
        _updateAllRewards(); // Update rewards for all users before changing the rate
        rewardRatePerSecond = _rewardRatePerSecond;
    }

    function recoverERC20(address _tokenAddress, uint256 _amount) public onlyOwner {
        IERC20 token = IERC20(_tokenAddress);
        uint256 balance = token.balanceOf(address(this));
        require(_amount <= balance, "Amount exceeds contract balance");
        require(token.transfer(owner(), _amount), "Transfer failed");
    }

    // **** Internal Helper Functions ****

    function _updateRewards(address user) internal {
        if (block.timestamp > lastRewardTimestamp) {
            uint256 timePassed = block.timestamp.sub(lastRewardTimestamp);
            uint256 rewardToBeDistributed = timePassed.mul(rewardRatePerSecond).mul(totalStaked);  // Corrected: rewardRatePerSecond * totalStaked
            if (rewardToBeDistributed > 0 && totalStaked > 0) {
                 rewardToken.transferFrom(owner(), address(this), rewardToBeDistributed);
            }
            lastRewardTimestamp = block.timestamp;
        }


        if (stakedBalances[user] > 0) {
            uint256 reward = _calculateRewards(user);
            pendingRewards[user] = pendingRewards[user].add(reward);
        }
    }

    function _updateAllRewards() internal {
        for (uint256 i = 0; i < 100; i++) {  // Iterate over the first 100 users.  In a real implementation, you need a more sophisticated way to iterate over all stakers efficiently.
            if (stakedBalances[address(uint160(i))] > 0) {  // This is a very naive way to iterate addresses.  DO NOT USE THIS IN PRODUCTION.
                _updateRewards(address(uint160(i)));
            }
        }
    }

    function _calculateRewards(address user) internal view returns (uint256) {
        if (block.timestamp > lastRewardTimestamp) {
            uint256 timePassed = block.timestamp.sub(lastRewardTimestamp);
            return timePassed.mul(rewardRatePerSecond).mul(stakedBalances[user]); //Corrected: rewardRatePerSecond * stakedBalances[user]
        }
        return 0;
    }
}
```

**Explanation (Solidity):**

*   **Imports:** Uses OpenZeppelin's `IERC20`, `Ownable`, and `SafeMath` for token interaction, access control, and safe arithmetic.
*   **State Variables:**
    *   `stakingToken`, `rewardToken`:  Addresses of the ERC20 tokens used for staking and rewards.
    *   `totalStaked`: Total amount of tokens staked in the contract.
    *   `rewardRatePerSecond`: The amount of reward tokens distributed per staked token *per second*.  This is crucial for controlling the emission rate.
    *   `lastRewardTimestamp`:  The last time rewards were updated.  Used to calculate how long it's been since rewards were last distributed.
    *   `stakedBalances`: Mapping of user address to their staked token balance.
    *   `pendingRewards`: Mapping of user address to their accumulated, unclaimed rewards.
    *   `Proposal`: struct used for the Governance part.
    *   `proposals`: mapping to save the proposals.
    *   `proposalCount`: number of existing proposals.
*   **Events:**  Emitted for key actions (staking, unstaking, reward claims, proposals, votes, execution).  Important for off-chain monitoring and UI updates.
*   **`constructor`:** Initializes the contract with the addresses of the staking and reward tokens.
*   **`stake(uint256 amount)`:**
    *   Transfers staking tokens from the user to the contract.
    *   Updates rewards for the user (`_updateRewards`).
    *   Updates `stakedBalances` and `totalStaked`.
*   **`unstake(uint256 amount)`:**
    *   Updates rewards for the user (`_updateRewards`).
    *   Decreases the user's staked balance and the total staked.
    *   Transfers staking tokens from the contract to the user.
*   **`claimRewards()`:**
    *   Updates rewards for the user (`_updateRewards`).
    *   Transfers reward tokens from the contract to the user.  Resets the user's `pendingRewards` to 0.
*   **`createProposal(string memory _description, uint256 _startTime, uint256 _endTime)`:** Allows the owner to create governance proposals.
*   **`vote(uint256 _proposalId, bool _vote)`:** Allows stakers to vote on proposals. The vote is weighted by the amount of tokens they have staked.
*   **`executeProposal(uint256 _proposalId)`:** Allows the owner to execute a proposal if the yes votes are greater than the no votes.
*   **`setRewardRate(uint256 _rewardRatePerSecond)`:**  Allows the contract owner to change the reward emission rate.
*   **`recoverERC20(address _tokenAddress, uint256 _amount)`:**  Allows the contract owner to recover accidentally sent ERC20 tokens.
*   **`_updateRewards(address user)`:**  (Internal)  The core logic for calculating and updating rewards for a user.
    *   Calculates the time elapsed since the last reward update.
    *   Calculates the rewards earned during that time.
    *   Adds the rewards to the user's `pendingRewards`.
*   **`_updateAllRewards()`:** (Internal) It is supposed to update rewards for all stakers. The current code iterates only on the first 100 users. In a real implementation, you need a more sophisticated way to iterate over all stakers efficiently.
*   **`_calculateRewards(address user)`:** (Internal) Calculates the rewards earned by a user since the last reward update based on their staked balance.

**JavaScript (Web3.js) Example: `script.js`**

```javascript
const Web3 = require('web3');
const contractABI = require('./MultiLayerStaking.json').abi; // Replace with your actual ABI
const stakingTokenABI = require('./StakingToken.json').abi; // Replace with your actual ABI

// Configuration
const contractAddress = 'YOUR_CONTRACT_ADDRESS'; // Replace with your deployed contract address
const stakingTokenAddress = 'YOUR_STAKING_TOKEN_ADDRESS';
const rewardTokenAddress = 'YOUR_REWARD_TOKEN_ADDRESS';
const web3Provider = 'YOUR_WEB3_PROVIDER_URL'; // e.g., 'http://localhost:8545' or an Infura/Alchemy URL
const accountAddress = 'YOUR_ACCOUNT_ADDRESS'; // The account you'll use to interact with the contract
const privateKey = 'YOUR_PRIVATE_KEY'; // WARNING: Never hardcode private keys in production code! Use environment variables or a secure wallet.

// Initialize Web3
const web3 = new Web3(web3Provider);

// Create contract instance
const contract = new web3.eth.Contract(contractABI, contractAddress);
const stakingTokenContract = new web3.eth.Contract(stakingTokenABI, stakingTokenAddress);

// Function to sign and send a transaction
async function sendTransaction(method, args) {
    const data = method.encodeABI(...args);
    const gas = await method(...args).estimateGas({from: accountAddress});
    const tx = {
        from: accountAddress,
        to: contractAddress,
        data: data,
        gas: gas,
    };

    const signedTx = await web3.eth.accounts.signTransaction(tx, privateKey);
    const transaction = await web3.eth.sendSignedTransaction(signedTx.rawTransaction);
    return transaction;
}


// Example functions to interact with the contract
async function stakeTokens(amount) {
    try {
        // Approve the contract to spend tokens on behalf of the user
        const approveTx = await sendTransaction(stakingTokenContract.methods.approve, [contractAddress, amount]);
        console.log("Approval Transaction Hash:", approveTx.transactionHash);

        const tx = await sendTransaction(contract.methods.stake, [amount]);
        console.log("Stake Transaction Hash:", tx.transactionHash);
    } catch (error) {
        console.error("Error staking tokens:", error);
    }
}

async function unstakeTokens(amount) {
    try {
        const tx = await sendTransaction(contract.methods.unstake, [amount]);
        console.log("Unstake Transaction Hash:", tx.transactionHash);
    } catch (error) {
        console.error("Error unstaking tokens:", error);
    }
}

async function claimRewards() {
    try {
        const tx = await sendTransaction(contract.methods.claimRewards, []);
        console.log("Claim Rewards Transaction Hash:", tx.transactionHash);
    } catch (error) {
        console.error("Error claiming rewards:", error);
    }
}

async function createProposal(description, startTime, endTime) {
    try {
        const tx = await sendTransaction(contract.methods.createProposal, [description, startTime, endTime]);
        console.log("Create Proposal Transaction Hash:", tx.transactionHash);
    } catch (error) {
        console.error("Error creating proposal:", error);
    }
}

async function vote(proposalId, vote) {
    try {
        const tx = await sendTransaction(contract.methods.vote, [proposalId, vote]);
        console.log("Vote Transaction Hash:", tx.transactionHash);
    } catch (error) {
        console.error("Error voting:", error);
    }
}

async function executeProposal(proposalId) {
    try {
        const tx = await sendTransaction(contract.methods.executeProposal, [proposalId]);
        console.log("Execute Proposal Transaction Hash:", tx.transactionHash);
    } catch (error) {
        console.error("Error executing proposal:", error);
    }
}


async function getStakedBalance(address) {
    try {
        const balance = await contract.methods.stakedBalances(address).call();
        console.log("Staked Balance:", balance);
        return balance;
    } catch (error) {
        console.error("Error getting staked balance:", error);
    }
}

async function getPendingRewards(address) {
    try {
        const rewards = await contract.methods.pendingRewards(address).call();
        console.log("Pending Rewards:", rewards);
        return rewards;
    } catch (error) {
        console.error("Error getting pending rewards:", error);
    }
}

async function getTotalStaked() {
    try {
        const total = await contract.methods.totalStaked().call();
        console.log("Total Staked:", total);
        return total;
    } catch (error) {
        console.error("Error getting total staked:", error);
    }
}

// Example usage (replace with actual values)
async function main() {
    const amountToStake = web3.utils.toWei('10', 'ether'); // Stake 10 tokens
    const amountToUnstake = web3.utils.toWei('5', 'ether'); // Unstake 5 tokens
    const proposalDescription = "Should we increase the reward rate?";
    const startTime = Math.floor(Date.now() / 1000) + 60; // Start in 1 minute
    const endTime = Math.floor(Date.now() / 1000) + 3600;  // End in 1 hour

    await stakeTokens(amountToStake);
    await getStakedBalance(accountAddress);
    await getPendingRewards(accountAddress);
    await getTotalStaked();
    await claimRewards();
    await unstakeTokens(amountToUnstake);

    await createProposal(proposalDescription, startTime, endTime); //Only owner can create a proposal
    await vote(1, true);
    await executeProposal(1); //Only owner can execute a proposal
}

main();
```

**Explanation (JavaScript/Web3.js):**

*   **Dependencies:** Requires `web3` (install with `npm install web3`).
*   **Configuration:**  You *must* replace the placeholder values for `contractAddress`, `web3Provider`, `accountAddress`, and `privateKey` with your actual values. **Never commit your private key to version control!**
*   **`web3` Initialization:** Creates a Web3 instance using your specified provider URL.
*   **Contract Instance:** Creates a Web3 contract instance using the contract ABI and address.  The ABI is a JSON file that describes the contract's interface.  You'll need to generate this using the Solidity compiler.  If using Remix, it's available in the "Compile" tab under "ABI."
*   **`sendTransaction(method, args)`:** A helper function to sign and send transactions to the smart contract using your private key.  This handles the gas estimation, transaction signing, and sending.
*   **Example Functions:**  Functions like `stakeTokens`, `unstakeTokens`, `claimRewards`, `createProposal`, `vote`, `executeProposal`, `getStakedBalance`, `getPendingRewards`, and `getTotalStaked` demonstrate how to call different functions in the smart contract.  They handle the necessary Web3 calls and log the transaction hashes or return values to the console.
*   **`main()`:**  An example `main` function that shows how to call the functions.  Remember to replace the example values with your desired amounts, addresses, and other parameters.

**Files:**

1.  **`MultiLayerStaking.sol`** (Solidity smart contract)
2.  **`script.js`** (JavaScript/Web3.js script)
3.  **`MultiLayerStaking.json`** (ABI of the smart contract) - Generated by the Solidity compiler.
4.  **`StakingToken.json`** (ABI of the staking token contract) - Generated by the Solidity compiler.  This assumes you're using a standard ERC20 token. You'll need to compile the token contract if you haven't already. The contract of the StakingToken is not here, it is just assumed to be a basic ERC20 Token.

**How to Run:**

1.  **Set up a Development Environment:**
    *   Install Node.js and npm.
    *   Install Web3.js: `npm install web3`
    *   Install OpenZeppelin Contracts: `npm install @openzeppelin/contracts`

2.  **Compile the Solidity Contract:** Use a Solidity compiler (e.g., Remix, Truffle, Hardhat) to compile `MultiLayerStaking.sol`. This will generate the ABI (Application Binary Interface) and bytecode.
    *   If using Remix: Copy the ABI from the "Compile" tab after compiling.

3.  **Deploy the Contract:** Deploy the compiled contract to a blockchain (e.g., Ganache for local development, a testnet like Rinkeby, or a mainnet). You'll need to use a deployment script or tool like Truffle or Hardhat.

4.  **Update Configuration:**  In `script.js`, replace the placeholder values for `contractAddress`, `web3Provider`, `accountAddress`, and `privateKey` with your actual values.  *Especially* be careful with your private key!

5.  **Run the Script:**
    ```bash
    node script.js
    ```

**Important Considerations and Improvements:**

*   **Security:** This is a simplified example and lacks many security best practices. A real-world staking contract needs thorough auditing, input validation, protection against reentrancy attacks, and careful consideration of potential vulnerabilities.
*   **Gas Optimization:** Solidity code can be expensive to execute.  Optimize the code to reduce gas costs.  This includes minimizing storage writes, using efficient data structures, and avoiding unnecessary loops.
*   **Error Handling:**  The Solidity code includes basic `require` statements, but more robust error handling is needed. Consider using custom errors. The Javascript code has basic try/catch, more robust error handling could be done.
*   **Event Handling:**  Events are critical for off-chain monitoring. Ensure all important state changes are emitted as events.
*   **Access Control:**  The `Ownable` contract provides basic ownership. Consider using more granular access control mechanisms if needed.
*   **Reward Distribution:** The current reward distribution is very basic. More sophisticated models could include tiered rewards, bonus periods, and other features.
*   **Reward Calculation:**  The reward calculation assumes a constant reward rate.  You might want to allow for variable reward rates or reward schedules.
*   **Token Approvals:** The `stakeTokens` function requires the user to approve the contract to spend their tokens.  Make sure to handle token approval errors gracefully.
*   **UI:** The provided code is a command-line example. A user-friendly UI would make the staking process much easier.

This comprehensive example provides a foundation for building a multi-layer staking governance model.  Remember to adapt and expand upon it to meet your specific needs and security requirements. Always test thoroughly!