Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract CloneFactory
•    - function createClone(address target, ...
•    - function computeCloneAddress(address ...
•    - function isClone(address target, addr ...
• library MerkleProof
•    - function verify(bytes32[] memory proo ...
• interface IERC20
•    - function transfer(address recipient, ...
•    - function balanceOf(address account)
• interface IERC721
•    - function safeTransferFrom(address fro ...
•    - function ownerOf(uint256 tokenId)
• library Address
•    - function isContract(address account)
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function callOptionalReturn(IERC20 to ...
• interface IAstrodrop
•    - function token()
•    - function merkleRoot()
•    - function isClaimed(uint256 index)
•    - function claim(uint256 index, address ...
•  contract Astrodrop is IAstrodrop, ...
•    - function init(address owner_, address ...
•    - function isClaimed(uint256 index)
•    - function _setClaimed(uint256 index)
•    - function claim(uint256 index, address ...
•    - function sweep(address token_, addres ...
•  contract AstrodropERC721 is IAstro ...
•    - function init(address owner_, address ...
•    - function isClaimed(uint256 index)
•    - function _setClaimed(uint256 index)
•    - function claim(uint256 index, address ...
•    - function sweep(address token_, addres ...
•  contract AstrodropFactory is Clone ... *
•    - function createAstrodrop(
•    - function computeAstrodropAddress(
•    - function isAstrodrop(address template ...

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-03-27
*/

// SPDX-License-Identifier: MIT AND GPL-v3-or-later
pragma solidity 0.8.1;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Returns true if the caller is the current owner.
     */
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}


contract CloneFactory {
    function createClone(address target, bytes32 salt) internal returns (address result) {
        bytes20 targetBytes = bytes20(target);
        assembly {
            let clone := mload(0x40)
            mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(clone, 0x14), targetBytes)
            mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            result := create2(0, clone, 0x37, salt)
        }
  }
  
  function computeCloneAddress(address target, bytes32 salt) internal view returns (address) {
        bytes20 targetBytes = bytes20(target);
        bytes32 bytecodeHash;
        assembly {
            let clone := mload(0x40)
            mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
            mstore(add(clone, 0x14), targetBytes)
            mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            bytecodeHash := keccak256(clone, 0x37)
        }
        bytes32 _data = keccak256(
            abi.encodePacked(bytes1(0xff), address(this), salt, bytecodeHash)
        );
        return address(bytes20(_data << 96));
    }
    
    function isClone(address target, address query) internal view returns (bool result) {
        bytes20 targetBytes = bytes20(target);
        assembly {
            let clone := mload(0x40)
            mstore(clone, 0x363d3d373d3d3d363d7300000000000000000000000000000000000000000000)
            mstore(add(clone, 0xa), targetBytes)
            mstore(add(clone, 0x1e), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
            
            let other := add(clone, 0x40)
            extcodecopy(query, other, 0, 0x2d)
            result := and(
                eq(mload(clone), mload(other)),
                eq(mload(add(clone, 0xd)), mload(add(other, 0xd)))
            )
        }
    }
}


library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}


interface IERC20 {
    function transfer(address recipient, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}


interface IERC721 {
    function safeTransferFrom(address from, address to, uint256 tokenId) external;
    function ownerOf(uint256 tokenId) external view returns (address owner);
}


library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}


library SafeERC20 {
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


interface IAstrodrop {
    // Returns the address of the token distributed by this contract.
    function token() external view returns (address);
    // Returns the merkle root of the merkle tree containing account balances available to claim.
    function merkleRoot() external view returns (bytes32);
    // Returns true if the index has been marked claimed.
    function isClaimed(uint256 index) external view returns (bool);
    // Claim the given amount of the token to the given address. Reverts if the inputs are invalid.
    function claim(uint256 index, address account, uint256 amount, bytes32[] calldata merkleProof) external;

    // This event is triggered whenever a call to #claim succeeds.
    event Claimed(uint256 index, address account, uint256 amount);
}


contract Astrodrop is IAstrodrop, Ownable {
    using SafeERC20 for IERC20;

    address public override token;
    bytes32 public override merkleRoot;
    bool public initialized;
    uint256 public expireTimestamp;

    // This is a packed array of booleans.
    mapping(uint256 => uint256) public claimedBitMap;

    function init(address owner_, address token_, bytes32 merkleRoot_, uint256 expireTimestamp_) external {
        require(!initialized, "Astrodrop: Initialized");
        initialized = true;

        token = token_;
        merkleRoot = merkleRoot_;
        expireTimestamp = expireTimestamp_;
        
        _transferOwnership(owner_);
    }

    function isClaimed(uint256 index) public view override returns (bool) {
        uint256 claimedWordIndex = index / 256;
        uint256 claimedBitIndex = index % 256;
        uint256 claimedWord = claimedBitMap[claimedWordIndex];
        uint256 mask = (1 << claimedBitIndex);
        return claimedWord & mask == mask;
    }

    function _setClaimed(uint256 index) private {
        uint256 claimedWordIndex = index / 256;
        uint256 claimedBitIndex = index % 256;
        claimedBitMap[claimedWordIndex] = claimedBitMap[claimedWordIndex] | (1 << claimedBitIndex);
    }

    function claim(uint256 index, address account, uint256 amount, bytes32[] calldata merkleProof) external override {
        require(!isClaimed(index), 'MerkleDistributor: Drop already claimed.');

        // Verify the merkle proof.
        bytes32 node = keccak256(abi.encodePacked(index, account, amount));
        require(MerkleProof.verify(merkleProof, merkleRoot, node), 'Astrodrop: Invalid proof');

        // Mark it claimed and send the token.
        _setClaimed(index);
        IERC20(token).safeTransfer(account, amount);

        emit Claimed(index, account, amount);
    }

    function sweep(address token_, address target) external onlyOwner {
        require(block.timestamp >= expireTimestamp || token_ != token, "Astrodrop: Not expired");
        IERC20 tokenContract = IERC20(token_);
        uint256 balance = tokenContract.balanceOf(address(this));
        tokenContract.safeTransfer(target, balance);
    }
}


contract AstrodropERC721 is IAstrodrop, Ownable {
    using SafeERC20 for IERC20;

    address public override token;
    bytes32 public override merkleRoot;
    bool public initialized;
    uint256 public expireTimestamp;

    // This is a packed array of booleans.
    mapping(uint256 => uint256) public claimedBitMap;

    function init(address owner_, address token_, bytes32 merkleRoot_, uint256 expireTimestamp_) external {
        require(!initialized, "Astrodrop: Initialized");
        initialized = true;

        token = token_;
        merkleRoot = merkleRoot_;
        expireTimestamp = expireTimestamp_;
        
        _transferOwnership(owner_);
    }

    function isClaimed(uint256 index) public view override returns (bool) {
        uint256 claimedWordIndex = index / 256;
        uint256 claimedBitIndex = index % 256;
        uint256 claimedWord = claimedBitMap[claimedWordIndex];
        uint256 mask = (1 << claimedBitIndex);
        return claimedWord & mask == mask;
    }

    function _setClaimed(uint256 index) private {
        uint256 claimedWordIndex = index / 256;
        uint256 claimedBitIndex = index % 256;
        claimedBitMap[claimedWordIndex] = claimedBitMap[claimedWordIndex] | (1 << claimedBitIndex);
    }

    function claim(uint256 index, address account, uint256 amount, bytes32[] calldata merkleProof) external override {
        require(!isClaimed(index), 'MerkleDistributor: Drop already claimed.');

        // Verify the merkle proof.
        bytes32 node = keccak256(abi.encodePacked(index, account, amount));
        require(MerkleProof.verify(merkleProof, merkleRoot, node), 'Astrodrop: Invalid proof');

        // Mark it claimed and send the token.
        _setClaimed(index);
        IERC721 tokenContract = IERC721(token);
        tokenContract.safeTransferFrom(tokenContract.ownerOf(amount), account, amount);

        emit Claimed(index, account, amount);
    }

    function sweep(address token_, address target) external onlyOwner {
        require(block.timestamp >= expireTimestamp || token_ != token, "Astrodrop: Not expired");
        IERC20 tokenContract = IERC20(token_);
        uint256 balance = tokenContract.balanceOf(address(this));
        tokenContract.safeTransfer(target, balance);
    }
}


contract AstrodropFactory is CloneFactory {
    event CreateAstrodrop(address astrodrop, bytes32 ipfsHash);

    function createAstrodrop(
        address template,
        address token,
        bytes32 merkleRoot,
        uint256 expireTimestamp,
        bytes32 salt,
        bytes32 ipfsHash
    ) external returns (Astrodrop drop) {
        drop = Astrodrop(createClone(template, salt));
        drop.init(msg.sender, token, merkleRoot, expireTimestamp);
        emit CreateAstrodrop(address(drop), ipfsHash);
    }

    function computeAstrodropAddress(
        address template,
        bytes32 salt
    ) external view returns (address) {
        return computeCloneAddress(template, salt);
    }
    
    function isAstrodrop(address template, address query) external view returns (bool) {
        return isClone(template, query);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"astrodrop","type":"address"},{"indexed":false,"internalType":"bytes32","name":"ipfsHash","type":"bytes32"}],"name":"CreateAstrodrop","type":"event"},{"inputs":[{"internalType":"address","name":"template","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"}],"name":"computeAstrodropAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"template","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"expireTimestamp","type":"uint256"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"bytes32","name":"ipfsHash","type":"bytes32"}],"name":"createAstrodrop","outputs":[{"internalType":"contract Astrodrop","name":"drop","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"template","type":"address"},{"internalType":"address","name":"query","type":"address"}],"name":"isAstrodrop","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

13981:873:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14718:133;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14523:183;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;14097:418::-;;;;;;:::i;:::-;;:::i;14718:133::-;14795:4;14819:24;14827:8;14837:5;14819:7;:24::i;:::-;14812:31;14718:133;-1:-1:-1;;;14718:133:0:o;14523:183::-;14636:7;14663:35;14683:8;14693:4;14663:19;:35::i;14097:418::-;14311:14;14355:27;14367:8;14377:4;14355:11;:27::i;:::-;14394:57;;-1:-1:-1;;;14394:57:0;;14338:45;;-1:-1:-1;;;;;;14394:9:0;;;;;:57;;14404:10;;14416:5;;14423:10;;14435:15;;14394:57;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14467:40;14491:4;14498:8;14467:40;;;;;;;:::i;:::-;;;;;;;;14097:418;;;;;;;;:::o;3548:725::-;3619:11;3643:19;3673:6;3665:15;;3643:37;;3734:4;3728:11;-1:-1:-1;;;3760:5:0;3753:81;3872:11;3866:3;3859:5;3855:15;3848:36;-1:-1:-1;;;3916:4:0;3909:5;3905:16;3898:92;4042:4;4035:5;4031:16;4090:4;4087:1;4080:5;4073;4061:34;4234:3;4227:5;4223:15;4217:22;4210:3;4203:5;4199:15;4193:22;4190:50;4164:5;4158:12;4150:5;4144:12;4141:30;4119:136;4109:146;;;;3700:566;;;;;:::o;2811:725::-;3035:4;3029:11;;-1:-1:-1;;;3054:81:0;;2935:15;;;;3167:4;3156:16;;3149:37;;;-1:-1:-1;;;3218:4:0;3207:16;;3200:92;3339:4;3322:22;;;3405:65;;2893:7;;3322:22;2893:7;;3405:65;;-1:-1:-1;;;;;;3422:12:0;3444:4;;3451;;3322:22;;-1:-1:-1;3405:65:0;;:::i;:::-;;;;;;;-1:-1:-1;;3405:65:0;;;;;;3381:100;;3405:65;3381:100;;;;-1:-1:-1;;;;;3499:29:0;;2811:725;-1:-1:-1;;;;;;2811:725:0:o;2290:513::-;2359:14;2386:19;2416:6;2408:15;;2386:37;;2477:4;2471:11;-1:-1:-1;;;2503:5:0;2496:81;2616:11;2609:4;2602:5;2598:16;2591:37;-1:-1:-1;;;2660:4:0;2653:5;2649:16;2642:92;2782:4;2776;2769:5;2766:1;2758:29;2748:39;2443:355;-1:-1:-1;;;;;2443:355:0:o;14:175:1:-;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;113:2;65:124;;;:::o;194:274::-;;;323:2;311:9;302:7;298:23;294:32;291:2;;;344:6;336;329:22;291:2;372:31;393:9;372:31;:::i;:::-;362:41;;422:40;458:2;447:9;443:18;422:40;:::i;:::-;412:50;;281:187;;;;;:::o;473:549::-;;;;;;;670:3;658:9;649:7;645:23;641:33;638:2;;;692:6;684;677:22;638:2;720:31;741:9;720:31;:::i;:::-;710:41;;770:40;806:2;795:9;791:18;770:40;:::i;:::-;628:394;;760:50;;-1:-1:-1;;;;857:2:1;842:18;;829:32;;908:2;893:18;;880:32;;959:3;944:19;;931:33;;-1:-1:-1;1011:3:1;996:19;;;983:33;;-1:-1:-1;628:394:1:o;1027:266::-;;;1156:2;1144:9;1135:7;1131:23;1127:32;1124:2;;;1177:6;1169;1162:22;1124:2;1205:31;1226:9;1205:31;:::i;:::-;1195:41;1283:2;1268:18;;;;1255:32;;-1:-1:-1;;;1114:179:1:o;1298:441::-;-1:-1:-1;;;;;;1521:26:1;;;;1509:39;;1585:2;1581:15;;;;-1:-1:-1;;1577:53:1;1573:1;1564:11;;1557:74;1656:2;1647:12;;1640:28;1693:2;1684:12;;1677:28;1730:2;1721:12;;1499:240::o;1744:203::-;-1:-1:-1;;;;;1908:32:1;;;;1890:51;;1878:2;1863:18;;1845:102::o;1952:447::-;-1:-1:-1;;;;;2239:15:1;;;2221:34;;2291:15;;;;2286:2;2271:18;;2264:43;2338:2;2323:18;;2316:34;2381:2;2366:18;;2359:34;;;;2170:3;2155:19;;2137:262::o;2404:274::-;-1:-1:-1;;;;;2596:32:1;;;;2578:51;;2660:2;2645:18;;2638:34;2566:2;2551:18;;2533:145::o;2683:187::-;2848:14;;2841:22;2823:41;;2811:2;2796:18;;2778:92::o

ipfs://66b9fc57335ef615ca5ef1adf158ef3369663123fd2b48d472b328956508a332