Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import {ProposalTxs} from "src/interfaces/ProposalTxs.sol";
import {INounsDAOLogicV4} from "src/interfaces/INounsDAOLogicV4.sol";
import {ProposalValidatorLib} from "src/lib/ProposalValidatorLib.sol";

/// @title Wave Protocol Delegate
/// @author 📯📯📯.eth
/// @notice All Wave Protocol Delegate contracts are managed by the Wave Core. They are designed to receive
/// Nouns token delegation non-custodially so they can be used as proxies to push onchain proposals to Nouns governance.
/// @notice For utmost security, Delegates never custody Nouns tokens and can only push proposals

contract Delegate {
    using ProposalValidatorLib for ProposalTxs;

    error NotWaveCore(address caller);

    address public immutable waveCore;

    constructor(address waveCore_) {
        waveCore = waveCore_;
    }

    modifier onlyWaveCore() {
        if (msg.sender != waveCore) revert NotWaveCore(msg.sender);
        _;
    }

    /// @dev Pushes a proposal to the Nouns governor, kickstarting the Nouns proposal process
    /// @notice May only be invoked by the Wave core contract as a part of the `IdeaTokenHub::finalizeWave()` flow
    function pushProposal(INounsDAOLogicV4 governor, ProposalTxs calldata txs, string calldata description)
        external
        onlyWaveCore
        returns (uint256 nounsProposalId)
    {
        nounsProposalId =
            INounsDAOLogicV4(governor).propose(txs.targets, txs.values, txs.signatures, txs.calldatas, description);
    }

    /// @dev Updates an existing proposal which was made by this contract
    /// @notice May only be invoked through the Wave core contract, given a `proposalId` that is currently updatable
    function updateProposal(
        INounsDAOLogicV4 governor,
        uint256 nounsProposalId,
        ProposalTxs memory updatedTxs,
        string calldata updatedDescription,
        string calldata updateMessage
    ) external onlyWaveCore {
        ProposalValidatorLib._validateProposalArity(updatedTxs);

        // switch case to delineate calls to the granular functions offered by NounsDAOProposals.sol
        if (keccak256(bytes(updatedDescription)) == keccak256("")) {
            // if `updatedDescription` is empty, validate and update proposal transactions only
            ProposalValidatorLib._validateProposalTargetsAndOperations(updatedTxs, governor);
            governor.updateProposalTransactions(
                nounsProposalId,
                updatedTxs.targets,
                updatedTxs.values,
                updatedTxs.signatures,
                updatedTxs.calldatas,
                updateMessage
            );
        } else if (updatedTxs.targets.length == 0) {
            // if `updatedTxs.targets` is empty, update description only
            governor.updateProposalDescription(nounsProposalId, updatedDescription, updateMessage);
        } else {
            // update both the proposal's transactions and description
            ProposalValidatorLib._validateProposalTargetsAndOperations(updatedTxs, governor);
            governor.updateProposal(
                nounsProposalId,
                updatedTxs.targets,
                updatedTxs.values,
                updatedTxs.signatures,
                updatedTxs.calldatas,
                updatedDescription,
                updateMessage
            );
        }
    }

    /// @dev Cancels an existing proposal which was made by this contract
    /// @notice May only be invoked through the Wave core contract, given a `proposalId` that is currently cancelable
    function cancelProposal(INounsDAOLogicV4 governor, uint256 nounsProposalId) external onlyWaveCore {
        governor.cancel(nounsProposalId);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

/// @title Sole `ProposalTxs` struct from the NounsDAOProposals contract to save on imported bytecode

/// @dev Wave Protocol's IdeaTokenHub and Delegate contracts only rely on a single struct
/// from the NounsDAOProposals dependency so it is made available here without bytecode overhead
struct ProposalTxs {
    address[] targets;
    uint256[] values;
    string[] signatures;
    bytes[] calldatas;
}

// SPDX-License-Identifier: BSD-3-Clause

/// @dev Interface for interacting with the NounsDAOLogicV4 governor contract with minimal deployment bytecode overhead
pragma solidity ^0.8.24;

import {
    NounsDAOStorage,
    INounsDAOExecutor,
    NounsTokenLike,
    INounsDAOForkEscrow,
    IForkDAODeployer
} from "nouns-monorepo/governance/NounsDAOInterfaces.sol";

interface INounsDAOLogicV4 {
    /// @notice The minimum setable proposal threshold
    function MIN_PROPOSAL_THRESHOLD_BPS() external pure returns (uint256);
    /// @notice The maximum setable proposal threshold
    function MAX_PROPOSAL_THRESHOLD_BPS() external pure returns (uint256);
    /// @notice The minimum setable voting period in blocks
    function MIN_VOTING_PERIOD() external pure returns (uint256);
    /// @notice The max setable voting period in blocks
    function MAX_VOTING_PERIOD() external pure returns (uint256);
    /// @notice The min setable voting delay in blocks
    function MIN_VOTING_DELAY() external pure returns (uint256);
    /// @notice The max setable voting delay in blocks
    function MAX_VOTING_DELAY() external pure returns (uint256);
    /// @notice The maximum number of actions that can be included in a proposal
    function proposalMaxOperations() external pure returns (uint256);

    /// @notice Used to initialize the contract during delegator contructor
    function initialize(
        address timelock_,
        address nouns_,
        address forkEscrow_,
        address forkDAODeployer_,
        address vetoer_,
        NounsDAOStorage.NounsDAOParams calldata daoParams_,
        NounsDAOStorage.DynamicQuorumParams calldata dynamicQuorumParams_
    ) external;

    /// @notice Function used to propose a new proposal. Sender must have delegates above the proposal threshold
    function propose(
        address[] memory targets,
        uint256[] memory values,
        string[] memory signatures,
        bytes[] memory calldatas,
        string memory description
    ) external returns (uint256);

    /// @notice Function used to propose a new proposal. Sender must have delegates above the proposal threshold.
    /// This proposal would be executed via the timelockV1 contract. This is meant to be used in case timelockV1
    /// is still holding funds or has special permissions to execute on certain contracts.
    function proposeOnTimelockV1(
        address[] memory targets,
        uint256[] memory values,
        string[] memory signatures,
        bytes[] memory calldatas,
        string memory description
    ) external returns (uint256);

    /// @notice Function used to propose a new proposal. Sender and signers must have delegates above the proposal threshold
    /// Signers are regarded as co-proposers, and therefore have the ability to cancel the proposal at any time.
    function proposeBySigs(
        NounsDAOStorage.ProposerSignature[] memory proposerSignatures,
        address[] memory targets,
        uint256[] memory values,
        string[] memory signatures,
        bytes[] memory calldatas,
        string memory description
    ) external returns (uint256);

    /// @notice Invalidates a signature that may be used for signing a new proposal.
    function cancelSig(bytes calldata sig) external;

    /// @notice Update a proposal transactions and description.
    /// Only the proposer can update it, and only during the updateable period.
    function updateProposal(
        uint256 proposalId,
        address[] memory targets,
        uint256[] memory values,
        string[] memory signatures,
        bytes[] memory calldatas,
        string memory description,
        string memory updateMessage
    ) external;

    /// @notice Updates the proposal's description. Only the proposer can update it, and only during the updateable period.
    function updateProposalDescription(uint256 proposalId, string calldata description, string calldata updateMessage)
        external;

    /// @notice Updates the proposal's transactions. Only the proposer can update it, and only during the updateable period.
    function updateProposalTransactions(
        uint256 proposalId,
        address[] memory targets,
        uint256[] memory values,
        string[] memory signatures,
        bytes[] memory calldatas,
        string memory updateMessage
    ) external;

    /// @notice Update a proposal's transactions and description that was created with proposeBySigs.
    function updateProposalBySigs(
        uint256 proposalId,
        NounsDAOStorage.ProposerSignature[] memory proposerSignatures,
        address[] memory targets,
        uint256[] memory values,
        string[] memory signatures,
        bytes[] memory calldatas,
        string memory description,
        string memory updateMessage
    ) external;

    /// @notice Queues a proposal of state succeeded
    function queue(uint256 proposalId) external;
    /// @notice Executes a queued proposal if eta has passed
    function execute(uint256 proposalId) external;
    /// @notice Executes a queued proposal on timelockV1 if eta has passed
    function executeOnTimelockV1(uint256 proposalId) external;
    /// @notice Cancels a proposal only if sender is the proposer or a signer, or proposer & signers voting power
    /// dropped below proposal threshold
    function cancel(uint256 proposalId) external;
    /// @notice Gets the state of a proposal
    function state(uint256 proposalId) external view returns (NounsDAOStorage.ProposalState);
    /// @notice Gets actions of a proposal

    function getActions(uint256 proposalId)
        external
        view
        returns (
            address[] memory targets,
            uint256[] memory values,
            string[] memory signatures,
            bytes[] memory calldatas
        );

    /// @notice Gets the receipt for a voter on a given proposal
    function getReceipt(uint256 proposalId, address voter) external view returns (NounsDAOStorage.Receipt memory);
    /// @notice Returns the proposal details given a proposal id.
    function proposals(uint256 proposalId) external view returns (NounsDAOStorage.ProposalCondensedV3 memory);
    /// @notice Returns the proposal details given a proposal id.
    function proposalsV3(uint256 proposalId) external view returns (NounsDAOStorage.ProposalCondensedV3 memory);
    /// @notice Current proposal threshold using Noun Total Supply
    function proposalThreshold() external view returns (uint256);

    /// @notice Escrow Nouns to contribute to the fork threshold
    function escrowToFork(uint256[] calldata tokenIds, uint256[] calldata proposalIds, string calldata reason)
        external;

    /// @notice Withdraw Nouns from the fork escrow. Only possible if the fork has not been executed.
    function withdrawFromForkEscrow(uint256[] calldata tokenIds) external;
    /// @notice Execute the fork. Only possible if the fork threshold has been met.
    function executeFork() external returns (address forkTreasury, address forkToken);

    /// @notice Joins a fork while a fork is active
    function joinFork(uint256[] calldata tokenIds, uint256[] calldata proposalIds, string calldata reason) external;

    /// @notice Withdraws nouns from the fork escrow to the treasury after the fork has been executed
    function withdrawDAONounsFromEscrowToTreasury(uint256[] calldata tokenIds) external;
    /// @notice Withdraws nouns from the fork escrow after the fork has been executed to an address other than the treasury
    function withdrawDAONounsFromEscrowIncreasingTotalSupply(uint256[] calldata tokenIds, address to) external;
    /// @notice Returns the number of nouns in supply minus nouns owned by the DAO, i.e. held in the treasury or in an
    /// escrow after it has closed.
    function adjustedTotalSupply() external view returns (uint256);
    /// @notice returns the required number of tokens to escrow to trigger a fork
    function forkThreshold() external view returns (uint256);
    /// @notice Returns the number of tokens currently in escrow, contributing to the fork threshold
    function numTokensInForkEscrow() external view returns (uint256);
    /// @notice Vetoes a proposal only if sender is the vetoer and the proposal has not been executed.
    function veto(uint256 proposalId) external;
    /// @notice Cast a vote for a proposal
    function castVote(uint256 proposalId, uint8 support) external;
    /// @notice Cast a vote for a proposal, asking the DAO to refund gas costs.
    function castRefundableVote(uint256 proposalId, uint8 support) external;

    /// @notice Cast a vote for a proposal, asking the DAO to refund gas costs.
    function castRefundableVoteWithReason(uint256 proposalId, uint8 support, string calldata reason) external;

    /// @notice Cast a vote for a proposal with a reason
    function castVoteWithReason(uint256 proposalId, uint8 support, string calldata reason) external;

    /// @notice Cast a vote for a proposal by signature
    function castVoteBySig(uint256 proposalId, uint8 support, uint8 v, bytes32 r, bytes32 s) external;

    /// @notice Admin function for setting the voting delay. Best to set voting delay to at least a few days, to give
    /// voters time to make sense of proposals, e.g. 21,600 blocks which should be at least 3 days.
    function _setVotingDelay(uint256 newVotingDelay) external;
    /// @notice Admin function for setting the voting period
    function _setVotingPeriod(uint256 newVotingPeriod) external;
    /// @notice Admin function for setting the proposal threshold basis points
    function _setProposalThresholdBPS(uint256 newProposalThresholdBPS) external;
    /// @notice Admin function for setting the objection period duration

    function _setObjectionPeriodDurationInBlocks(uint32 newObjectionPeriodDurationInBlocks) external;

    /// @notice Admin function for setting the objection period last minute window
    function _setLastMinuteWindowInBlocks(uint32 newLastMinuteWindowInBlocks) external;
    /// @notice Admin function for setting the proposal updatable period
    function _setProposalUpdatablePeriodInBlocks(uint32 newProposalUpdatablePeriodInBlocks) external;
    /// @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer.
    function _setPendingAdmin(address newPendingAdmin) external;
    /// @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin
    function _acceptAdmin() external;
    /// @notice Begins transition of vetoer. The newPendingVetoer must call _acceptVetoer to finalize the transfer.
    function _setPendingVetoer(address newPendingVetoer) external;
    /// @notice Called by the pendingVetoer to accept role and update vetoer
    function _acceptVetoer() external;
    /// @notice Burns veto priviledges
    function _burnVetoPower() external;
    /// @notice Admin function for setting the minimum quorum votes bps
    function _setMinQuorumVotesBPS(uint16 newMinQuorumVotesBPS) external;
    /// @notice Admin function for setting the maximum quorum votes bps
    function _setMaxQuorumVotesBPS(uint16 newMaxQuorumVotesBPS) external;
    /// @notice Admin function for setting the dynamic quorum coefficient
    function _setQuorumCoefficient(uint32 newQuorumCoefficient) external;
    /// @notice Admin function for setting all the dynamic quorum parameters
    function _setDynamicQuorumParams(
        uint16 newMinQuorumVotesBPS,
        uint16 newMaxQuorumVotesBPS,
        uint32 newQuorumCoefficient
    ) external;

    /// @notice Withdraws all the ETH in the contract. This is callable only by the admin (timelock)
    function _withdraw() external returns (uint256, bool);
    /// @notice Admin function for setting the fork period
    function _setForkPeriod(uint256 newForkPeriod) external;
    /// @notice Admin function for setting the fork threshold
    function _setForkThresholdBPS(uint256 newForkThresholdBPS) external;
    /// @notice Admin function for setting the proposal id at which vote snapshots start using the voting start block
    /// instead of the proposal creation block.
    function _setVoteSnapshotBlockSwitchProposalId() external;
    /// @notice Admin function for setting the fork DAO deployer contract
    function _setForkDAODeployer(address newForkDAODeployer) external;
    /// @notice Admin function for setting the ERC20 tokens that are used when splitting funds to a fork
    function _setErc20TokensToIncludeInFork(address[] calldata erc20tokens) external;
    /// @notice Admin function for setting the fork escrow contract
    function _setForkEscrow(address newForkEscrow) external;

    /// @notice Admin function for setting the fork related parameters
    function _setForkParams(
        address forkEscrow_,
        address forkDAODeployer_,
        address[] calldata erc20TokensToIncludeInFork_,
        uint256 forkPeriod_,
        uint256 forkThresholdBPS_
    ) external;

    /// @notice Admin function for setting the timelocks and admin
    function _setTimelocksAndAdmin(address newTimelock, address newTimelockV1, address newAdmin) external;

    /// @notice Quorum votes required for a specific proposal to succeed
    function quorumVotes(uint256 proposalId) external view returns (uint256);

    /// @notice Calculates the required quorum of for-votes based on the amount of against-votes
    function dynamicQuorumVotes(
        uint256 againstVotes,
        uint256 adjustedTotalSupply_,
        NounsDAOStorage.DynamicQuorumParams memory params
    ) external pure returns (uint256);

    /// @notice returns the dynamic quorum parameters values at a certain block number
    function getDynamicQuorumParamsAt(uint256 blockNumber_)
        external
        view
        returns (NounsDAOStorage.DynamicQuorumParams memory);
    /// @notice Current min quorum votes using Nouns adjusted total supply
    function minQuorumVotes() external view returns (uint256);
    /// @notice Current max quorum votes using Nouns adjusted total supply
    function maxQuorumVotes() external view returns (uint256);
    /// @notice Get all quorum params checkpoints
    function quorumParamsCheckpoints()
        external
        view
        returns (NounsDAOStorage.DynamicQuorumParamsCheckpoint[] memory);
    /// @notice Get a quorum params checkpoint by its index
    function quorumParamsCheckpoints(uint256 index)
        external
        view
        returns (NounsDAOStorage.DynamicQuorumParamsCheckpoint memory);
    function vetoer() external view returns (address);
    function pendingVetoer() external view returns (address);
    function votingDelay() external view returns (uint256);
    function votingPeriod() external view returns (uint256);
    function proposalThresholdBPS() external view returns (uint256);
    function quorumVotesBPS() external view returns (uint256);
    function proposalCount() external view returns (uint256);
    function timelock() external view returns (INounsDAOExecutor);
    function nouns() external view returns (NounsTokenLike);
    function latestProposalIds(address account) external view returns (uint256);
    function lastMinuteWindowInBlocks() external view returns (uint256);
    function objectionPeriodDurationInBlocks() external view returns (uint256);
    function erc20TokensToIncludeInFork() external view returns (address[] memory);
    function forkEscrow() external view returns (INounsDAOForkEscrow);
    function forkDAODeployer() external view returns (IForkDAODeployer);
    function forkEndTimestamp() external view returns (uint256);
    function forkPeriod() external view returns (uint256);
    function forkThresholdBPS() external view returns (uint256);
    function proposalUpdatablePeriodInBlocks() external view returns (uint256);
    function timelockV1() external view returns (address);
    function voteSnapshotBlockSwitchProposalId() external view returns (uint256);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;

import {ProposalTxs} from "src/interfaces/ProposalTxs.sol";
import {INounsDAOLogicV4} from "src/interfaces/INounsDAOLogicV4.sol";

/// @title Proposal Validator Library
/// @author 📯📯📯.eth
/// @dev This library provides modular proposal validation logic inherited by Wave Protocol's
/// IdeaTokenHub and Delegate contracts, used to validate proposals when created or updated

library ProposalValidatorLib {
    error ProposalInfoArityMismatch();
    error InvalidDescription();
    error InvalidActionsCount(uint256 exceedsMaxOperations);

    /// @notice To account for Nouns governor contract upgradeability, `PROPOSAL_MAX_OPERATIONS` must be read dynamically
    function _validateProposalTargetsAndOperations(ProposalTxs memory txs, INounsDAOLogicV4 governor) internal pure {
        uint256 maxOperations = governor.proposalMaxOperations();
        if (txs.targets.length == 0 || txs.targets.length > maxOperations) {
            revert InvalidActionsCount(txs.targets.length);
        }
    }

    function _validateProposalArity(ProposalTxs memory txs) internal pure {
        if (
            txs.targets.length != txs.values.length || txs.targets.length != txs.signatures.length
                || txs.targets.length != txs.calldatas.length
        ) revert ProposalInfoArityMismatch();
    }
}

// SPDX-License-Identifier: BSD-3-Clause

/// @title Nouns DAO Logic interfaces and events

/*********************************
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░░░░░█████████░░█████████░░░ *
 * ░░░░░░██░░░████░░██░░░████░░░ *
 * ░░██████░░░████████░░░████░░░ *
 * ░░██░░██░░░████░░██░░░████░░░ *
 * ░░██░░██░░░████░░██░░░████░░░ *
 * ░░░░░░█████████░░█████████░░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 * ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ *
 *********************************/

// LICENSE
// NounsDAOInterfaces.sol is a modified version of Compound Lab's GovernorBravoInterfaces.sol:
// https://github.com/compound-finance/compound-protocol/blob/b9b14038612d846b83f8a009a82c38974ff2dcfe/contracts/Governance/GovernorBravoInterfaces.sol
//
// GovernorBravoInterfaces.sol source code Copyright 2020 Compound Labs, Inc. licensed under the BSD-3-Clause license.
// With modifications by Nounders DAO.
//
// Additional conditions of BSD-3-Clause can be found here: https://opensource.org/licenses/BSD-3-Clause
//
// MODIFICATIONS
// NounsDAOEvents, NounsDAOProxyStorage, NounsDAOStorageV1 add support for changes made by Nouns DAO to GovernorBravo.sol
// See NounsDAOLogicV1.sol for more details.
// NounsDAOStorageV1Adjusted and NounsDAOStorageV2 add support for a dynamic vote quorum.
// See NounsDAOLogicV2.sol for more details.
// NounsDAOStorageV3
// See NounsDAOLogicV3.sol for more details.

pragma solidity ^0.8.19;

interface NounsDAOEventsV3 {
    /// @notice An event emitted when a new proposal is created
    event ProposalCreated(
        uint256 id,
        address proposer,
        address[] targets,
        uint256[] values,
        string[] signatures,
        bytes[] calldatas,
        uint256 startBlock,
        uint256 endBlock,
        string description
    );

    /// @notice An event emitted when a new proposal is created, which includes additional information
    event ProposalCreatedWithRequirements(
        uint256 id,
        address proposer,
        address[] targets,
        uint256[] values,
        string[] signatures,
        bytes[] calldatas,
        uint256 startBlock,
        uint256 endBlock,
        uint256 proposalThreshold,
        uint256 quorumVotes,
        string description
    );

    /// @notice An event emitted when a vote has been cast on a proposal
    /// @param voter The address which casted a vote
    /// @param proposalId The proposal id which was voted on
    /// @param support Support value for the vote. 0=against, 1=for, 2=abstain
    /// @param votes Number of votes which were cast by the voter
    /// @param reason The reason given for the vote by the voter
    event VoteCast(address indexed voter, uint256 proposalId, uint8 support, uint256 votes, string reason);

    /// @notice An event emitted when a proposal has been canceled
    event ProposalCanceled(uint256 id);

    /// @notice An event emitted when a proposal has been queued in the NounsDAOExecutor
    event ProposalQueued(uint256 id, uint256 eta);

    /// @notice An event emitted when a proposal has been executed in the NounsDAOExecutor
    event ProposalExecuted(uint256 id);

    /// @notice An event emitted when a proposal has been vetoed by vetoAddress
    event ProposalVetoed(uint256 id);

    /// @notice An event emitted when the voting delay is set
    event VotingDelaySet(uint256 oldVotingDelay, uint256 newVotingDelay);

    /// @notice An event emitted when the voting period is set
    event VotingPeriodSet(uint256 oldVotingPeriod, uint256 newVotingPeriod);

    /// @notice Emitted when proposal threshold basis points is set
    event ProposalThresholdBPSSet(uint256 oldProposalThresholdBPS, uint256 newProposalThresholdBPS);

    /// @notice Emitted when quorum votes basis points is set
    event QuorumVotesBPSSet(uint256 oldQuorumVotesBPS, uint256 newQuorumVotesBPS);

    /// @notice Emitted when pendingAdmin is changed
    event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);

    /// @notice Emitted when pendingAdmin is accepted, which means admin is updated
    event NewAdmin(address oldAdmin, address newAdmin);

    /// @notice Emitted when vetoer is changed
    event NewVetoer(address oldVetoer, address newVetoer);

    /// @notice Emitted when minQuorumVotesBPS is set
    event MinQuorumVotesBPSSet(uint16 oldMinQuorumVotesBPS, uint16 newMinQuorumVotesBPS);

    /// @notice Emitted when maxQuorumVotesBPS is set
    event MaxQuorumVotesBPSSet(uint16 oldMaxQuorumVotesBPS, uint16 newMaxQuorumVotesBPS);

    /// @notice Emitted when quorumCoefficient is set
    event QuorumCoefficientSet(uint32 oldQuorumCoefficient, uint32 newQuorumCoefficient);

    /// @notice Emitted when a voter cast a vote requesting a gas refund.
    event RefundableVote(address indexed voter, uint256 refundAmount, bool refundSent);

    /// @notice Emitted when admin withdraws the DAO's balance.
    event Withdraw(uint256 amount, bool sent);

    /// @notice Emitted when pendingVetoer is changed
    event NewPendingVetoer(address oldPendingVetoer, address newPendingVetoer);

    /// @notice An event emitted when a new proposal is created, which includes additional information
    /// @dev V3 adds `signers`, `updatePeriodEndBlock` compared to the V1/V2 event.
    /// @dev V4: Removed data that's already emitted in `ProposalCreated`, added clientId
    event ProposalCreatedWithRequirements(
        uint256 id,
        address[] signers,
        uint256 updatePeriodEndBlock,
        uint256 proposalThreshold,
        uint256 quorumVotes,
        uint32 indexed clientId
    );

    /// @notice Emitted when a proposal is created to be executed on timelockV1
    event ProposalCreatedOnTimelockV1(uint256 id);

    /// @notice Emitted when a proposal is updated
    event ProposalUpdated(
        uint256 indexed id,
        address indexed proposer,
        address[] targets,
        uint256[] values,
        string[] signatures,
        bytes[] calldatas,
        string description,
        string updateMessage
    );

    /// @notice Emitted when a proposal's transactions are updated
    event ProposalTransactionsUpdated(
        uint256 indexed id,
        address indexed proposer,
        address[] targets,
        uint256[] values,
        string[] signatures,
        bytes[] calldatas,
        string updateMessage
    );

    /// @notice Emitted when a proposal's description is updated
    event ProposalDescriptionUpdated(
        uint256 indexed id,
        address indexed proposer,
        string description,
        string updateMessage
    );

    /// @notice Emitted when a proposal is set to have an objection period
    event ProposalObjectionPeriodSet(uint256 indexed id, uint256 objectionPeriodEndBlock);

    /// @notice Emitted when someone cancels a signature
    event SignatureCancelled(address indexed signer, bytes sig);

    /// @notice An event emitted when the objection period duration is set
    event ObjectionPeriodDurationSet(
        uint32 oldObjectionPeriodDurationInBlocks,
        uint32 newObjectionPeriodDurationInBlocks
    );

    /// @notice An event emitted when the objection period last minute window is set
    event LastMinuteWindowSet(uint32 oldLastMinuteWindowInBlocks, uint32 newLastMinuteWindowInBlocks);

    /// @notice An event emitted when the proposal updatable period is set
    event ProposalUpdatablePeriodSet(
        uint32 oldProposalUpdatablePeriodInBlocks,
        uint32 newProposalUpdatablePeriodInBlocks
    );

    /// @notice Emitted when the erc20 tokens to include in a fork are set
    event ERC20TokensToIncludeInForkSet(address[] oldErc20Tokens, address[] newErc20tokens);

    /// @notice Emitted when the fork DAO deployer is set
    event ForkDAODeployerSet(address oldForkDAODeployer, address newForkDAODeployer);

    /// @notice Emitted when the during of the forking period is set
    event ForkPeriodSet(uint256 oldForkPeriod, uint256 newForkPeriod);

    /// @notice Emitted when the threhsold for forking is set
    event ForkThresholdSet(uint256 oldForkThreshold, uint256 newForkThreshold);

    /// @notice Emitted when the main timelock, timelockV1 and admin are set
    event TimelocksAndAdminSet(address timelock, address timelockV1, address admin);

    /// @notice Emitted when someones adds nouns to the fork escrow
    event EscrowedToFork(
        uint32 indexed forkId,
        address indexed owner,
        uint256[] tokenIds,
        uint256[] proposalIds,
        string reason
    );

    /// @notice Emitted when the owner withdraws their nouns from the fork escrow
    event WithdrawFromForkEscrow(uint32 indexed forkId, address indexed owner, uint256[] tokenIds);

    /// @notice Emitted when the fork is executed and the forking period begins
    event ExecuteFork(
        uint32 indexed forkId,
        address forkTreasury,
        address forkToken,
        uint256 forkEndTimestamp,
        uint256 tokensInEscrow
    );

    /// @notice Emitted when someone joins a fork during the forking period
    event JoinFork(
        uint32 indexed forkId,
        address indexed owner,
        uint256[] tokenIds,
        uint256[] proposalIds,
        string reason
    );

    /// @notice Emitted when the DAO withdraws nouns from the fork escrow after a fork has been executed
    event DAOWithdrawNounsFromEscrow(uint256[] tokenIds, address to);

    /// @notice Emitted when withdrawing nouns from escrow increases adjusted total supply
    event DAONounsSupplyIncreasedFromEscrow(uint256 numTokens, address to);

    /// @notice An event emitted when a vote has been cast with a non-zero client Id.
    /// @dev Assumes the `VoteCast` event is emitted, and that indexers can use the voter address and propose ID to
    /// find the relevant vote and set its client ID.
    event VoteCastWithClientId(address indexed voter, uint256 indexed proposalId, uint32 indexed clientId);
}

interface INounsDAOExecutor {
    function delay() external view returns (uint256);

    function GRACE_PERIOD() external view returns (uint256);

    function acceptAdmin() external;

    function queuedTransactions(bytes32 hash) external view returns (bool);

    function queueTransaction(
        address target,
        uint256 value,
        string calldata signature,
        bytes calldata data,
        uint256 eta
    ) external returns (bytes32);

    function cancelTransaction(
        address target,
        uint256 value,
        string calldata signature,
        bytes calldata data,
        uint256 eta
    ) external;

    function executeTransaction(
        address target,
        uint256 value,
        string calldata signature,
        bytes calldata data,
        uint256 eta
    ) external payable returns (bytes memory);
}

interface NounsTokenLike {
    function getPriorVotes(address account, uint256 blockNumber) external view returns (uint96);

    function totalSupply() external view returns (uint256);

    function transferFrom(address from, address to, uint256 tokenId) external;

    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    function balanceOf(address owner) external view returns (uint256 balance);

    function ownerOf(uint256 tokenId) external view returns (address owner);

    function minter() external view returns (address);

    function mint() external returns (uint256);

    function setApprovalForAll(address operator, bool approved) external;
}

interface IForkDAODeployer {
    function deployForkDAO(
        uint256 forkingPeriodEndTimestamp,
        INounsDAOForkEscrow forkEscrowAddress
    ) external returns (address treasury, address token);

    function tokenImpl() external view returns (address);

    function auctionImpl() external view returns (address);

    function governorImpl() external view returns (address);

    function treasuryImpl() external view returns (address);
}

interface INounsDAOExecutorV2 is INounsDAOExecutor {
    function sendETH(address recipient, uint256 ethToSend) external;

    function sendERC20(address recipient, address erc20Token, uint256 tokensToSend) external;
}

interface INounsDAOForkEscrow {
    function markOwner(address owner, uint256[] calldata tokenIds) external;

    function returnTokensToOwner(address owner, uint256[] calldata tokenIds) external;

    function closeEscrow() external returns (uint32);

    function numTokensInEscrow() external view returns (uint256);

    function numTokensOwnedByDAO() external view returns (uint256);

    function withdrawTokens(uint256[] calldata tokenIds, address to) external;

    function forkId() external view returns (uint32);

    function nounsToken() external view returns (NounsTokenLike);

    function dao() external view returns (address);

    function ownerOfEscrowedToken(uint32 forkId_, uint256 tokenId) external view returns (address);
}

interface NounsDAOTypes {
    struct Storage {
        // ================ PROXY ================ //
        /// @notice Administrator for this contract
        address admin;
        /// @notice Pending administrator for this contract
        address pendingAdmin;
        /// @notice Active brains of Governor
        address implementation;
        // ================ V1 ================ //
        /// @notice Vetoer who has the ability to veto any proposal
        address vetoer;
        /// @notice The delay before voting on a proposal may take place, once proposed, in blocks
        uint256 votingDelay;
        /// @notice The duration of voting on a proposal, in blocks
        uint256 votingPeriod;
        /// @notice The basis point number of votes required in order for a voter to become a proposer. *DIFFERS from GovernerBravo
        uint256 proposalThresholdBPS;
        /// @notice The basis point number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed. *DIFFERS from GovernerBravo
        uint256 quorumVotesBPS;
        /// @notice The total number of proposals
        uint256 proposalCount;
        /// @notice The address of the Nouns DAO Executor NounsDAOExecutor
        INounsDAOExecutorV2 timelock;
        /// @notice The address of the Nouns tokens
        NounsTokenLike nouns;
        /// @notice The official record of all proposals ever proposed
        mapping(uint256 => Proposal) _proposals;
        /// @notice The latest proposal for each proposer
        mapping(address => uint256) latestProposalIds;
        // ================ V2 ================ //
        DynamicQuorumParamsCheckpoint[] quorumParamsCheckpoints;
        /// @notice Pending new vetoer
        address pendingVetoer;
        // ================ V3 ================ //
        /// @notice user => sig => isCancelled: signatures that have been cancelled by the signer and are no longer valid
        mapping(address => mapping(bytes32 => bool)) cancelledSigs;
        /// @notice The number of blocks before voting ends during which the objection period can be initiated
        uint32 lastMinuteWindowInBlocks;
        /// @notice Length of the objection period in blocks
        uint32 objectionPeriodDurationInBlocks;
        /// @notice Length of proposal updatable period in block
        uint32 proposalUpdatablePeriodInBlocks;
        /// @notice address of the DAO's fork escrow contract
        INounsDAOForkEscrow forkEscrow;
        /// @notice address of the DAO's fork deployer contract
        IForkDAODeployer forkDAODeployer;
        /// @notice ERC20 tokens to include when sending funds to a deployed fork
        address[] erc20TokensToIncludeInFork;
        /// @notice The treasury contract of the last deployed fork
        address forkDAOTreasury;
        /// @notice The token contract of the last deployed fork
        address forkDAOToken;
        /// @notice Timestamp at which the last fork period ends
        uint256 forkEndTimestamp;
        /// @notice Fork period in seconds
        uint256 forkPeriod;
        /// @notice Threshold defined in basis points (10,000 = 100%) required for forking
        uint256 forkThresholdBPS;
        /// @notice Address of the original timelock
        INounsDAOExecutor timelockV1;
        /// @dev Make sure this stays the last variable in this struct, so we can delete it in the next version
        /// @dev To be zeroed-out in the upcoming DAO upgrade.
        uint256 voteSnapshotBlockSwitchProposalId;
    }

    struct Proposal {
        /// @notice Unique id for looking up a proposal
        uint32 id;
        /// @notice client id for rewards
        uint32 clientId;
        /// @notice currently unused
        uint192 _gap;
        /// @notice Creator of the proposal
        address proposer;
        /// @notice The number of votes needed to create a proposal at the time of proposal creation. *DIFFERS from GovernerBravo
        uint256 proposalThreshold;
        /// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed at the time of proposal creation. *DIFFERS from GovernerBravo
        uint256 quorumVotes;
        /// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
        uint256 eta;
        /// @notice the ordered list of target addresses for calls to be made
        address[] targets;
        /// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
        uint256[] values;
        /// @notice The ordered list of function signatures to be called
        string[] signatures;
        /// @notice The ordered list of calldata to be passed to each call
        bytes[] calldatas;
        /// @notice The block at which voting begins: holders must delegate their votes prior to this block
        uint256 startBlock;
        /// @notice The block at which voting ends: votes must be cast prior to this block
        uint256 endBlock;
        /// @notice Current number of votes in favor of this proposal
        uint256 forVotes;
        /// @notice Current number of votes in opposition to this proposal
        uint256 againstVotes;
        /// @notice Current number of votes for abstaining for this proposal
        uint256 abstainVotes;
        /// @notice Flag marking whether the proposal has been canceled
        bool canceled;
        /// @notice Flag marking whether the proposal has been vetoed
        bool vetoed;
        /// @notice Flag marking whether the proposal has been executed
        bool executed;
        /// @notice Receipts of ballots for the entire set of voters
        mapping(address => Receipt) receipts;
        /// @notice The total supply at the time of proposal creation
        uint256 totalSupply;
        /// @notice The block at which this proposal was created
        uint32 creationBlock;
        /// @notice The timestamp of the block at which this proposal was created
        uint32 creationTimestamp;
        /// @notice The last block which allows updating a proposal's description and transactions
        uint64 updatePeriodEndBlock;
        /// @notice Starts at 0 and is set to the block at which the objection period ends when the objection period is initiated
        uint64 objectionPeriodEndBlock;
        /// @dev unused for now
        uint64 placeholder;
        /// @notice The signers of a proposal, when using proposeBySigs
        address[] signers;
        /// @notice When true, a proposal would be executed on timelockV1 instead of the current timelock
        bool executeOnTimelockV1;
        /// @notice How many votes and vote transactions each clientId contributed to this proposal
        mapping(uint32 => ClientVoteData) voteClients;
    }

    struct ClientVoteData {
        /// @notice The number of votes the client facilitated on a proposal
        uint32 votes;
        /// @notice The number of vote transactions the client facilitated on a proposal
        uint32 txs;
    }

    /// @notice Ballot receipt record for a voter
    struct Receipt {
        /// @notice Whether or not a vote has been cast
        bool hasVoted;
        /// @notice Whether or not the voter supports the proposal or abstains
        uint8 support;
        /// @notice The number of votes the voter had, which were cast
        uint96 votes;
    }

    struct ProposerSignature {
        /// @notice Signature of a proposal
        bytes sig;
        /// @notice The address of the signer
        address signer;
        /// @notice The timestamp until which the signature is valid
        uint256 expirationTimestamp;
    }

    /// @notice A subset of Proposal data, used for client rewards calculation
    struct ProposalForRewards {
        /// @notice The proposal's voting period end block
        uint256 endBlock;
        /// @notice The proposal's objection period end block
        uint256 objectionPeriodEndBlock;
        /// @notice The proposal's For votes count
        uint256 forVotes;
        /// @notice The proposal's Against votes count
        uint256 againstVotes;
        /// @notice The proposal's Abstain votes count
        uint256 abstainVotes;
        /// @notice The proposal's snapshot of total supply
        uint256 totalSupply;
        /// @notice The timestamp of the block at which the proposal was created
        uint256 creationTimestamp;
        /// @notice The ID for the client that facilitated the proposal
        uint32 clientId;
        ClientVoteData[] voteData;
    }

    struct ProposalCondensedV3 {
        /// @notice Unique id for looking up a proposal
        uint256 id;
        /// @notice Creator of the proposal
        address proposer;
        /// @notice The number of votes needed to create a proposal at the time of proposal creation. *DIFFERS from GovernerBravo
        uint256 proposalThreshold;
        /// @notice The minimum number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed at the time of proposal creation. *DIFFERS from GovernerBravo
        uint256 quorumVotes;
        /// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
        uint256 eta;
        /// @notice The block at which voting begins: holders must delegate their votes prior to this block
        uint256 startBlock;
        /// @notice The block at which voting ends: votes must be cast prior to this block
        uint256 endBlock;
        /// @notice Current number of votes in favor of this proposal
        uint256 forVotes;
        /// @notice Current number of votes in opposition to this proposal
        uint256 againstVotes;
        /// @notice Current number of votes for abstaining for this proposal
        uint256 abstainVotes;
        /// @notice Flag marking whether the proposal has been canceled
        bool canceled;
        /// @notice Flag marking whether the proposal has been vetoed
        bool vetoed;
        /// @notice Flag marking whether the proposal has been executed
        bool executed;
        /// @notice The total supply at the time of proposal creation
        uint256 totalSupply;
        /// @notice The block at which this proposal was created
        uint256 creationBlock;
        /// @notice The signers of a proposal, when using proposeBySigs
        address[] signers;
        /// @notice The last block which allows updating a proposal's description and transactions
        uint256 updatePeriodEndBlock;
        /// @notice Starts at 0 and is set to the block at which the objection period ends when the objection period is initiated
        uint256 objectionPeriodEndBlock;
        /// @notice When true, a proposal would be executed on timelockV1 instead of the current timelock
        bool executeOnTimelockV1;
    }

    struct ProposalCondensedV2 {
        /// @notice Unique id for looking up a proposal
        uint256 id;
        /// @notice Creator of the proposal
        address proposer;
        /// @notice The number of votes needed to create a proposal at the time of proposal creation. *DIFFERS from GovernerBravo
        uint256 proposalThreshold;
        /// @notice The minimum number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed at the time of proposal creation. *DIFFERS from GovernerBravo
        uint256 quorumVotes;
        /// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
        uint256 eta;
        /// @notice The block at which voting begins: holders must delegate their votes prior to this block
        uint256 startBlock;
        /// @notice The block at which voting ends: votes must be cast prior to this block
        uint256 endBlock;
        /// @notice Current number of votes in favor of this proposal
        uint256 forVotes;
        /// @notice Current number of votes in opposition to this proposal
        uint256 againstVotes;
        /// @notice Current number of votes for abstaining for this proposal
        uint256 abstainVotes;
        /// @notice Flag marking whether the proposal has been canceled
        bool canceled;
        /// @notice Flag marking whether the proposal has been vetoed
        bool vetoed;
        /// @notice Flag marking whether the proposal has been executed
        bool executed;
        /// @notice The total supply at the time of proposal creation
        uint256 totalSupply;
        /// @notice The block at which this proposal was created
        uint256 creationBlock;
    }

    struct DynamicQuorumParams {
        /// @notice The minimum basis point number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed.
        uint16 minQuorumVotesBPS;
        /// @notice The maximum basis point number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed.
        uint16 maxQuorumVotesBPS;
        /// @notice The dynamic quorum coefficient
        /// @dev Assumed to be fixed point integer with 6 decimals, i.e 0.2 is represented as 0.2 * 1e6 = 200000
        uint32 quorumCoefficient;
    }

    struct NounsDAOParams {
        uint256 votingPeriod;
        uint256 votingDelay;
        uint256 proposalThresholdBPS;
        uint32 lastMinuteWindowInBlocks;
        uint32 objectionPeriodDurationInBlocks;
        uint32 proposalUpdatablePeriodInBlocks;
    }

    /// @notice A checkpoint for storing dynamic quorum params from a given block
    struct DynamicQuorumParamsCheckpoint {
        /// @notice The block at which the new values were set
        uint32 fromBlock;
        /// @notice The parameter values of this checkpoint
        DynamicQuorumParams params;
    }

    /// @notice Possible states that a proposal may be in
    enum ProposalState {
        Pending,
        Active,
        Canceled,
        Defeated,
        Succeeded,
        Queued,
        Expired,
        Executed,
        Vetoed,
        ObjectionPeriod,
        Updatable
    }
}

contract NounsDAOStorage is NounsDAOTypes {
    Storage ds;
}

{
  "remappings": [
    "ds-test/=lib/nouns-monorepo/lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/nouns-monorepo/lib/forge-std/src/",
    "nouns-monorepo/=lib/nouns-monorepo/packages/nouns-contracts/contracts/",
    "@openzeppelin/=lib/nouns-monorepo/node_modules/@openzeppelin/",
    "solady/=lib/solady/src/",
    "@ensdomains/=lib/nouns-monorepo/node_modules/@ensdomains/",
    "@nouns/=lib/nouns-monorepo/node_modules/@nouns/contracts/",
    "base64-sol/=lib/nouns-monorepo/node_modules/base64-sol/",
    "eth-gas-reporter/=lib/nouns-monorepo/node_modules/eth-gas-reporter/",
    "hardhat/=lib/nouns-monorepo/node_modules/hardhat/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"waveCore_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"exceedsMaxOperations","type":"uint256"}],"name":"InvalidActionsCount","type":"error"},{"inputs":[{"internalType":"address","name":"caller","type":"address"}],"name":"NotWaveCore","type":"error"},{"inputs":[],"name":"ProposalInfoArityMismatch","type":"error"},{"inputs":[{"internalType":"contract INounsDAOLogicV4","name":"governor","type":"address"},{"internalType":"uint256","name":"nounsProposalId","type":"uint256"}],"name":"cancelProposal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract INounsDAOLogicV4","name":"governor","type":"address"},{"components":[{"internalType":"address[]","name":"targets","type":"address[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"string[]","name":"signatures","type":"string[]"},{"internalType":"bytes[]","name":"calldatas","type":"bytes[]"}],"internalType":"struct ProposalTxs","name":"txs","type":"tuple"},{"internalType":"string","name":"description","type":"string"}],"name":"pushProposal","outputs":[{"internalType":"uint256","name":"nounsProposalId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract INounsDAOLogicV4","name":"governor","type":"address"},{"internalType":"uint256","name":"nounsProposalId","type":"uint256"},{"components":[{"internalType":"address[]","name":"targets","type":"address[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"string[]","name":"signatures","type":"string[]"},{"internalType":"bytes[]","name":"calldatas","type":"bytes[]"}],"internalType":"struct ProposalTxs","name":"updatedTxs","type":"tuple"},{"internalType":"string","name":"updatedDescription","type":"string"},{"internalType":"string","name":"updateMessage","type":"string"}],"name":"updateProposal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"waveCore","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000000000000008ddb753b2dfd31e7127f4094ce5630

-----Decoded View---------------
Arg [0] : waveCore_ (address): 0x00000000008DDB753b2dfD31e7127f4094CE5630

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000008ddb753b2dfd31e7127f4094ce5630