Contract

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: MIT

pragma solidity ^0.8.4;

import "./interfaces/IMintable.sol";
import {MerkleProofLib} from "./utils/MerkleProofLib.sol";

contract MintTranche {
    address payable public owner;
    IMintable public mintable;

    bytes32 public root;
    bool whitelistActive;

    uint256 public trancheRemaining;
    uint256 public trancheEnd;

    uint256 public mintPrice = 0.123 ether;

    mapping(address => uint256) public hasMinted;

    event TrancheCreated(uint amount, uint end);

    modifier onlyOwner() {
        require(msg.sender == owner, "Not Owner");
        _;
    }

    function changeOwner(address payable _owner) external onlyOwner() {
        owner = _owner;
    }

    function setMintable(IMintable _mintable) external onlyOwner() {
        require(address(mintable) == address(0) && address(_mintable) != address(0));

        mintable = _mintable;
    }

    function setRoot(bytes32 _root) external onlyOwner() {
        root = _root;
    }

    function setWhitelist(bool _active) external onlyOwner(){
        whitelistActive = _active;
    }

    constructor() payable {
        owner = payable(msg.sender);
    }

    function createTranche(uint256 trancheAmount, uint256 endTime) public onlyOwner() {
        require(address(mintable) != address(0));
        
        trancheRemaining = trancheAmount;
        trancheEnd = endTime;

        emit TrancheCreated(trancheAmount, endTime);
    }

    function mint(uint256 amount, bytes32[] memory proof) payable public {
        require(block.timestamp < trancheEnd, 'Tranche not active');
        require(trancheRemaining >= amount, 'Not enough remaining in current tranche');
        require(msg.value == mintPrice * amount, 'wrong price');
        require(hasMinted[msg.sender] + amount <= 2, 'Mint limit 2');

        if (whitelistActive) {
            bytes32 leaf = keccak256(bytes.concat(keccak256(abi.encode(msg.sender))));
            require(MerkleProofLib.verify(proof, root, leaf), "Invalid proof");
        }

        hasMinted[msg.sender] += amount;
        mintable.mint(address(msg.sender), amount);

        trancheRemaining = trancheRemaining - amount;
    }

    function withdraw() external onlyOwner() {
        (bool success, ) = owner.call{ value: address(this).balance }("");
        require(success, "Transfer failed.");
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.4;

interface IMintable {
    function transferFrom(address from, address to, uint256 tokenId) external;
    function mint(address mintReceiver, uint256 amount) external;
    function totalSupply() external returns (uint256);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Gas optimized verification of proof of inclusion for a leaf in a Merkle tree.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol)
library MerkleProofLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*            MERKLE PROOF VERIFICATION OPERATIONS            */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf)
        internal
        pure
        returns (bool isValid)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(proof) {
                // Initialize `offset` to the offset of `proof` elements in memory.
                let offset := add(proof, 0x20)
                // Left shift by 5 is equivalent to multiplying by 0x20.
                let end := add(offset, shl(5, mload(proof)))
                // Iterate over proof elements to compute root hash.
                for {} 1 {} {
                    // Slot of `leaf` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(leaf, mload(offset)))
                    // Store elements to hash contiguously in scratch space.
                    // Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.
                    mstore(scratch, leaf)
                    mstore(xor(scratch, 0x20), mload(offset))
                    // Reuse `leaf` to store the hash to reduce stack operations.
                    leaf := keccak256(0x00, 0x40)
                    offset := add(offset, 0x20)
                    if iszero(lt(offset, end)) { break }
                }
            }
            isValid := eq(leaf, root)
        }
    }

    /// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf)
        internal
        pure
        returns (bool isValid)
    {
        /// @solidity memory-safe-assembly
        assembly {
            if proof.length {
                // Left shift by 5 is equivalent to multiplying by 0x20.
                let end := add(proof.offset, shl(5, proof.length))
                // Initialize `offset` to the offset of `proof` in the calldata.
                let offset := proof.offset
                // Iterate over proof elements to compute root hash.
                for {} 1 {} {
                    // Slot of `leaf` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(leaf, calldataload(offset)))
                    // Store elements to hash contiguously in scratch space.
                    // Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.
                    mstore(scratch, leaf)
                    mstore(xor(scratch, 0x20), calldataload(offset))
                    // Reuse `leaf` to store the hash to reduce stack operations.
                    leaf := keccak256(0x00, 0x40)
                    offset := add(offset, 0x20)
                    if iszero(lt(offset, end)) { break }
                }
            }
            isValid := eq(leaf, root)
        }
    }

    /// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,
    /// given `proof` and `flags`.
    function verifyMultiProof(
        bytes32[] memory proof,
        bytes32 root,
        bytes32[] memory leaves,
        bool[] memory flags
    ) internal pure returns (bool isValid) {
        // Rebuilds the root by consuming and producing values on a queue.
        // The queue starts with the `leaves` array, and goes into a `hashes` array.
        // After the process, the last element on the queue is verified
        // to be equal to the `root`.
        //
        // The `flags` array denotes whether the sibling
        // should be popped from the queue (`flag == true`), or
        // should be popped from the `proof` (`flag == false`).
        /// @solidity memory-safe-assembly
        assembly {
            // Cache the lengths of the arrays.
            let leavesLength := mload(leaves)
            let proofLength := mload(proof)
            let flagsLength := mload(flags)

            // Advance the pointers of the arrays to point to the data.
            leaves := add(0x20, leaves)
            proof := add(0x20, proof)
            flags := add(0x20, flags)

            // If the number of flags is correct.
            for {} eq(add(leavesLength, proofLength), add(flagsLength, 1)) {} {
                // For the case where `proof.length + leaves.length == 1`.
                if iszero(flagsLength) {
                    // `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.
                    isValid := eq(mload(xor(leaves, mul(xor(proof, leaves), proofLength))), root)
                    break
                }

                // The required final proof offset if `flagsLength` is not zero, otherwise zero.
                let proofEnd := mul(iszero(iszero(flagsLength)), add(proof, shl(5, proofLength)))
                // We can use the free memory space for the queue.
                // We don't need to allocate, since the queue is temporary.
                let hashesFront := mload(0x40)
                // Copy the leaves into the hashes.
                // Sometimes, a little memory expansion costs less than branching.
                // Should cost less, even with a high free memory offset of 0x7d00.
                leavesLength := shl(5, leavesLength)
                for { let i := 0 } iszero(eq(i, leavesLength)) { i := add(i, 0x20) } {
                    mstore(add(hashesFront, i), mload(add(leaves, i)))
                }
                // Compute the back of the hashes.
                let hashesBack := add(hashesFront, leavesLength)
                // This is the end of the memory for the queue.
                // We recycle `flagsLength` to save on stack variables (sometimes save gas).
                flagsLength := add(hashesBack, shl(5, flagsLength))

                for {} 1 {} {
                    // Pop from `hashes`.
                    let a := mload(hashesFront)
                    // Pop from `hashes`.
                    let b := mload(add(hashesFront, 0x20))
                    hashesFront := add(hashesFront, 0x40)

                    // If the flag is false, load the next proof,
                    // else, pops from the queue.
                    if iszero(mload(flags)) {
                        // Loads the next proof.
                        b := mload(proof)
                        proof := add(proof, 0x20)
                        // Unpop from `hashes`.
                        hashesFront := sub(hashesFront, 0x20)
                    }

                    // Advance to the next flag.
                    flags := add(flags, 0x20)

                    // Slot of `a` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(a, b))
                    // Hash the scratch space and push the result onto the queue.
                    mstore(scratch, a)
                    mstore(xor(scratch, 0x20), b)
                    mstore(hashesBack, keccak256(0x00, 0x40))
                    hashesBack := add(hashesBack, 0x20)
                    if iszero(lt(hashesBack, flagsLength)) { break }
                }
                isValid :=
                    and(
                        // Checks if the last value in the queue is same as the root.
                        eq(mload(sub(hashesBack, 0x20)), root),
                        // And whether all the proofs are used, if required (i.e. `proofEnd != 0`).
                        or(iszero(proofEnd), eq(proofEnd, proof))
                    )
                break
            }
        }
    }

    /// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,
    /// given `proof` and `flags`.
    function verifyMultiProofCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32[] calldata leaves,
        bool[] calldata flags
    ) internal pure returns (bool isValid) {
        // Rebuilds the root by consuming and producing values on a queue.
        // The queue starts with the `leaves` array, and goes into a `hashes` array.
        // After the process, the last element on the queue is verified
        // to be equal to the `root`.
        //
        // The `flags` array denotes whether the sibling
        // should be popped from the queue (`flag == true`), or
        // should be popped from the `proof` (`flag == false`).
        /// @solidity memory-safe-assembly
        assembly {
            // If the number of flags is correct.
            for {} eq(add(leaves.length, proof.length), add(flags.length, 1)) {} {
                // For the case where `proof.length + leaves.length == 1`.
                if iszero(flags.length) {
                    // `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.
                    // forgefmt: disable-next-item
                    isValid := eq(
                        calldataload(
                            xor(leaves.offset, mul(xor(proof.offset, leaves.offset), proof.length))
                        ),
                        root
                    )
                    break
                }

                // The required final proof offset if `flagsLength` is not zero, otherwise zero.
                let proofEnd :=
                    mul(iszero(iszero(flags.length)), add(proof.offset, shl(5, proof.length)))
                // We can use the free memory space for the queue.
                // We don't need to allocate, since the queue is temporary.
                let hashesFront := mload(0x40)
                // Copy the leaves into the hashes.
                // Sometimes, a little memory expansion costs less than branching.
                // Should cost less, even with a high free memory offset of 0x7d00.
                calldatacopy(hashesFront, leaves.offset, shl(5, leaves.length))
                // Compute the back of the hashes.
                let hashesBack := add(hashesFront, shl(5, leaves.length))
                // This is the end of the memory for the queue.
                // We recycle `flagsLength` to save on stack variables (sometimes save gas).
                flags.length := add(hashesBack, shl(5, flags.length))

                // We don't need to make a copy of `proof.offset` or `flags.offset`,
                // as they are pass-by-value (this trick may not always save gas).

                for {} 1 {} {
                    // Pop from `hashes`.
                    let a := mload(hashesFront)
                    // Pop from `hashes`.
                    let b := mload(add(hashesFront, 0x20))
                    hashesFront := add(hashesFront, 0x40)

                    // If the flag is false, load the next proof,
                    // else, pops from the queue.
                    if iszero(calldataload(flags.offset)) {
                        // Loads the next proof.
                        b := calldataload(proof.offset)
                        proof.offset := add(proof.offset, 0x20)
                        // Unpop from `hashes`.
                        hashesFront := sub(hashesFront, 0x20)
                    }

                    // Advance to the next flag offset.
                    flags.offset := add(flags.offset, 0x20)

                    // Slot of `a` in scratch space.
                    // If the condition is true: 0x20, otherwise: 0x00.
                    let scratch := shl(5, gt(a, b))
                    // Hash the scratch space and push the result onto the queue.
                    mstore(scratch, a)
                    mstore(xor(scratch, 0x20), b)
                    mstore(hashesBack, keccak256(0x00, 0x40))
                    hashesBack := add(hashesBack, 0x20)
                    if iszero(lt(hashesBack, flags.length)) { break }
                }
                isValid :=
                    and(
                        // Checks if the last value in the queue is same as the root.
                        eq(mload(sub(hashesBack, 0x20)), root),
                        // And whether all the proofs are used, if required (i.e. `proofEnd != 0`).
                        or(iszero(proofEnd), eq(proofEnd, proof.offset))
                    )
                break
            }
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   EMPTY CALLDATA HELPERS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns an empty calldata bytes32 array.
    function emptyProof() internal pure returns (bytes32[] calldata proof) {
        /// @solidity memory-safe-assembly
        assembly {
            proof.length := 0
        }
    }

    /// @dev Returns an empty calldata bytes32 array.
    function emptyLeaves() internal pure returns (bytes32[] calldata leaves) {
        /// @solidity memory-safe-assembly
        assembly {
            leaves.length := 0
        }
    }

    /// @dev Returns an empty calldata bool array.
    function emptyFlags() internal pure returns (bool[] calldata flags) {
        /// @solidity memory-safe-assembly
        assembly {
            flags.length := 0
        }
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"end","type":"uint256"}],"name":"TrancheCreated","type":"event"},{"inputs":[{"internalType":"address payable","name":"_owner","type":"address"}],"name":"changeOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"trancheAmount","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"}],"name":"createTranche","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"hasMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintable","outputs":[{"internalType":"contract IMintable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"root","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IMintable","name":"_mintable","type":"address"}],"name":"setMintable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_root","type":"bytes32"}],"name":"setRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_active","type":"bool"}],"name":"setWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"trancheEnd","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"trancheRemaining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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