Moloch rage quit

README.md

@@ -1,5 +1,7 @@
-# Template For Challenge - ETH Tech Tree
+# Moloch Rage Quit - ETH Tech Tree
+
 ## Contents
+
 - [Requirements](#requirements)
 - [Start Here](#start-here)
 - [Challenge Description](#challenge-description)
@@ -14,36 +16,46 @@ Before you begin, you need to install the following tools:
 - [Foundryup](https://book.getfoundry.sh/getting-started/installation)
 
 ## Start Here
+
 Run the following commands in your terminal:
+
 ```
 yarn install
 foundryup
 ```
 
 ## Challenge Description
-*Edit this section*
-Write challenge description here...
+
+### Objective:
+
+In this challenge, you will create a smart contract that simulates a simple DAO (Decentralized Autonomous Organization) allowing members to propose and exchange ETH for shares. Additionally, members can "rage quit" to exchange their shares back for ETH if they are dissatisfied with the DAO's direction.
+
+### Scenario:
+
+Imagine a DAO where members contribute ETH to acquire shares. These shares represent ownership and voting power within the DAO. Members can propose to acquire a specific amount of shares for a certain amount of ETH. If the proposal is approved by the existing members, the proposer can exchange their ETH for the proposed shares. As the DAO evolves, it can accumulate ETH through various activities or spend ETH on services. If a member becomes unhappy with the DAO's direction, they can call the RageQuit function to exchange their shares for their proportionate share of the DAO's ETH holdings.
 
 Here are some helpful references:
-- [one](buidlguidl.com)
-- [two](buidlguidl.com)
-- [three](buidlguidl.com)
 
-*End of challenge specific section*
+- [Moloch DAO Primer](https://medium.com/odyssy/moloch-primer-for-humans-9e6a4f258f78)
 
 **Don't change any existing method names** as it will break tests but feel free to add additional methods if it helps you complete the task.
 
 When you think you are done run `yarn foundry:test` to run a set of tests against your code. If all your tests pass then you are good to go! If some are returning errors then you might find it useful to run the command with the extra logging verbosity flag `-vvvv` (`yarn foundry:test -vvvv`) as this will show you very detailed information about where tests are failing.
 
 For a more "hands on" approach you can try testing your contract with the provided front end interface by running the following:
+
 ```
 yarn chain
 ```
+
 in a second terminal deploy your contract:
+
 ```
 yarn deploy
 ```
+
 in a third terminal start the NextJS front end:
+
 ```
 yarn start
-```
+```

packages/foundry/contracts/MolochRageQuit.sol

@@ -0,0 +1,312 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0 <0.9.0;
+
+////////////////////
+// Errors
+////////////////////
+error MolochRageQuit__NotAMamber();
+error MolochRageQuit__ZeroAddress();
+error MolochRageQuit__AlreadyVoted();
+error MolochRageQuit__MemberExists();
+error MolochRageQuit__FailedTransfer();
+error MolochRageQuit__NotEnoughVotes();
+error MolochRageQuit__InsufficientETH();
+error MolochRageQuit__FailedToExecute();
+error MolochRageQuit__ProposalNotFound();
+error MolochRageQuit__UnauthorizedAccess();
+error MolochRageQuit__InsufficientShares();
+error MolochRageQuit__InvalidDeadline();
+error MolochRageQuit__ProposalNotApproved();
+error MolochRageQuit__ProposalDeadlineNotReached();
+
+////////////////////
+// Contract
+////////////////////
+contract MolochRageQuit {
+    ///////////////////
+    // Type Declarations
+    ///////////////////
+    struct Proposal {
+        address proposer;
+        address contractAddr;
+        bytes data;
+        uint256 value;
+        uint256 votes;
+        uint256 deadline;
+        bool approved;
+        mapping(address => bool) voted;
+    }
+
+    ///////////////////
+    // State Variables
+    ///////////////////
+    uint256 public totalShares;
+    uint256 public totalEth;
+    uint256 public proposalCount;
+    uint256 public quorum;
+    mapping(address => uint256) public shares;
+    mapping(uint256 => Proposal) public proposals;
+    mapping(address => bool) public members;
+
+    ///////////////////
+    // Events
+    ///////////////////
+    event ProposalCreated(
+        uint256 proposalId,
+        address proposer,
+        address contractAddr,
+        bytes data,
+        uint256 value,
+        uint256 deadline
+    );
+    event ProposalApproved(uint256 proposalId, address approver);
+    event ProposalExecuted(uint256 proposalId);
+    event RageQuit(address member, uint256 shareAmount);
+    event MemberAdded(address member);
+    event Voted(uint256 proposalId, address voter);
+    event ProposalValueRefunded(address proposer, uint256 amount);
+
+    ///////////////////
+    // Modifiers
+    ///////////////////
+    modifier onlyMember(address _member) {
+        if (!members[_member]) {
+            revert MolochRageQuit__NotAMamber();
+        }
+        _;
+    }
+
+    modifier onlyContractAddress() {
+        if (msg.sender != address(this)) {
+            revert MolochRageQuit__UnauthorizedAccess();
+        }
+        _;
+    }
+    modifier proposalExists(uint256 proposalId) {
+        if (proposalId > proposalCount) {
+            revert MolochRageQuit__ProposalNotFound();
+        }
+        _;
+    }
+
+    modifier isProposalApproved(uint256 proposalId) {
+        if (!proposals[proposalId].approved) {
+            revert MolochRageQuit__ProposalNotApproved();
+        }
+        _;
+    }
+
+    ///////////////////
+    // Constructor
+    ///////////////////
+    constructor(uint256 _quorum) {
+        members[msg.sender] = true;
+        quorum = _quorum;
+    }
+
+    ///////////////////
+    // External Functions
+    ///////////////////
+
+    /**
+     * @dev Propose a transaction.
+     * @param contractAddr The address of the contract to call.
+     * @param data The calldata for the transaction.
+     * @param value The ETH value to send with the transaction.
+     * @param deadline The timestamp until when the proposal is valid.
+     * Requirements:
+     * - `contractAddr` cannot be the zero address. Reverts with MolochRageQuit__ZeroAddress if the contract address is zero.
+     * - `deadline` should be in the future. Reverts with MolochRageQuit__InvalidDeadline if the deadline is in the past.
+     * - `msg.value` must be at least  `value`. Reverts with MolochRageQuit__InsufficientETH if insufficient ETH is sent.
+     * - Increment the proposal count.
+     * - Create a new proposal.
+     * Emits a `ProposalCreated` event.
+     */
+    function propose(
+        address contractAddr,
+        bytes memory data,
+        uint256 value,
+        uint256 deadline
+    ) external payable {
+        if (contractAddr == address(0)) {
+            revert MolochRageQuit__ZeroAddress();
+        }
+        if (deadline <= block.timestamp) {
+            revert MolochRageQuit__InvalidDeadline();
+        }
+        if (msg.value < value) {
+            revert MolochRageQuit__InsufficientETH();
+        }
+
+        proposalCount++;
+        totalEth += msg.value;
+        Proposal storage proposal = proposals[proposalCount];
+        proposal.proposer = msg.sender;
+        proposal.contractAddr = contractAddr;
+        proposal.data = data;
+        proposal.value = value;
+        proposal.deadline = deadline;
+
+        emit ProposalCreated(
+            proposalCount,
+            msg.sender,
+            contractAddr,
+            data,
+            value,
+            deadline
+        );
+    }
+
+    /**
+     * @dev Vote on a proposal.
+     * @param proposalId The ID of the proposal to vote on.
+     * Requirements:
+     * - Caller must be a member. make use of onlyMember modifier.
+     * - The proposal must exist. use proposalExists modifier to check if there is a proposal.
+     * - Caller must not have already voted on the proposal. Reverts with MolochRageQuit__AlreadyVoted if the caller has already voted.
+     * - Increment the proposal's vote count.
+     * - Mark the caller as having voted on the proposal.
+     * - If the proposal has enough votes, mark it as approved.
+     * Emits a `Voted` event.
+     * Emits a `ProposalApproved` event if the proposal is approved.
+     */
+    function vote(
+        uint256 proposalId
+    ) external onlyMember(msg.sender) proposalExists(proposalId) {
+        Proposal storage proposal = proposals[proposalId];
+
+        if (proposal.voted[msg.sender]) {
+            revert MolochRageQuit__AlreadyVoted();
+        }
+
+        proposal.votes++;
+        proposal.voted[msg.sender] = true;
+
+        emit Voted(proposalId, msg.sender);
+
+        if (proposal.votes >= quorum) {
+            proposal.approved = true;
+            emit ProposalApproved(proposalId, msg.sender);
+        }
+    }
+
+    /**
+     * @dev Execute an approved proposal after the deadline.
+     * @param proposalId The ID of the proposal to execute.
+     * Requirements:
+     * - The proposal must be approved. Use proposalExists modifier to check if there is a proposal.
+     * - The proposal deadline must be over. Reverts with MolochRageQuit__ProposalDeadlineNotReached if the deadline is not reached.
+     * - Execute the calldata with the value.
+     * - If the proposal is rejected: if the deadline has passed but it has not been approved, refund any value deposited. Reverts with MolochRageQuit__FailedTransfer if the transfer fails.
+     * - Emit a `ProposalValueRefunded` event if the proposal is not approved.
+     * - if the proposal is approved and the deadline has passed: execute the calldata with the value. Reverts with MolochRageQuit__FailedToExecute if the execution fails.
+     * - Emit a `ProposalExecuted` event if the proposal is executed.
+     */
+    function executeProposal(
+        uint256 proposalId
+    ) external proposalExists(proposalId) {
+        Proposal storage proposal = proposals[proposalId];
+
+        if (block.timestamp < proposal.deadline) {
+            revert MolochRageQuit__ProposalDeadlineNotReached();
+        }
+
+        if (!proposal.approved) {
+            // Refund the value to the proposer if the proposal is not approved
+            if (proposal.value > 0) {
+                (bool refunded, ) = proposal.proposer.call{
+                    value: proposal.value
+                }("");
+                if (!refunded) {
+                    revert MolochRageQuit__FailedTransfer();
+                }
+            }
+            emit ProposalValueRefunded(proposal.proposer, proposal.value);
+        } else {
+            if (proposal.contractAddr != address(this)) {
+                (bool success, ) = proposal.contractAddr.call{
+                    value: proposal.value
+                }(proposal.data);
+                if (!success) {
+                    revert MolochRageQuit__FailedToExecute();
+                }
+            } else {
+                (bool success, ) = proposal.contractAddr.call(proposal.data);
+                if (!success) {
+                    revert MolochRageQuit__FailedToExecute();
+                }
+            }
+
+            emit ProposalExecuted(proposalId);
+        }
+    }
+
+    /**
+     * @dev Add a new member to the DAO.
+     * @param newMember The address of the new member.
+     * @param proposalId The ID of the approved proposal which is the current proposalCount.
+     * Requirements:
+     * - Only callable by the contract itself. User onlyContractAddress to be sure only the contract can call the function.
+     * - The proposal must exist. Use proposalExists modifier to check if there is a proposal.
+     * - The proposal must be approved. make use of isProposalApproved modifier if the proposal is not approved.
+     * - The address must not already be a member. Reverts with MolochRageQuit__MemberExists if the address is already a member.
+     * - Mark the address as a member.
+     * - Increment the total shares by adding proposal value.
+     * - Set the shares of the new member to the proposal value.
+     * Emits a `MemberAdded` event.
+     */
+    function addMember(
+        address newMember,
+        uint256 proposalId
+    )
+        external
+        onlyContractAddress
+        proposalExists(proposalId)
+        isProposalApproved(proposalId)
+    {
+        Proposal storage proposal = proposals[proposalId];
+
+        if (members[newMember]) {
+            revert MolochRageQuit__MemberExists();
+        }
+        members[newMember] = true;
+        totalShares += proposal.value;
+        shares[newMember] = proposal.value;
+        emit MemberAdded(newMember);
+    }
+
+    /**
+     * @dev Rage quit and exchange shares for ETH.
+     * @param member The address of the new member.
+     * @param proposalId The ID of the approved proposal which is the current proposalCount.
+     * Requirements:
+     * - The address must be a member. make use of onlyMember modifier.
+     * - The proposal must exist. use proposalExists modifier to check if there is a proposal.
+     * - Reverts with MolochRageQuit__FailedTransfer if the transfer fails.
+     * - Calculate the amount of ETH to return to the caller.
+     * - Update the total shares and total ETH.
+     * - Mark the caller as having 0 shares.
+     * - Transfer the ETH to the caller.
+     * - Mark member as non member(revoke membership).
+     * Emits a `RageQuit` event.
+     */
+    function rageQuit(
+        address member,
+        uint256 proposalId
+    )
+        public
+        onlyMember(member)
+        proposalExists(proposalId)
+        isProposalApproved(proposalId)
+    {
+        uint256 memberShare = shares[member];
+        totalEth -= memberShare;
+        shares[member] = 0;
+        (bool sent, ) = payable(member).call{value: memberShare}("");
+        if (!sent) {
+            revert MolochRageQuit__FailedTransfer();
+        }
+        members[member] = false;
+        emit RageQuit(member, memberShare);
+    }
+}

packages/foundry/foundry.toml

@@ -3,6 +3,7 @@ src = 'contracts'
 out = 'out'
 libs = ['lib']
 fs_permissions = [{ access = "read-write", path = "./"}]
+solc_version = "0.8.19"
 
 [rpc_endpoints]
 default_network = "http://127.0.0.1:8545"