feat: ERC20 airdrop tool

.gitmodules

@@ -22,3 +22,6 @@
 [submodule "lib/v3-periphery"]
 	path = lib/v3-periphery
 	url = https://github.com/ChrisiPK/v3-periphery
+[submodule "lib/dropper-util"]
+	path = lib/dropper-util
+	url = https://github.com/PartyDAO/dropper-util

script/Deploy.s.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity ^0.8;
+
+import "forge-std/Script.sol";
+import "src/ERC20Airdropper.sol";
+
+contract DeployScript is Script {
+    function run() external {
+        vm.startBroadcast();
+        ERC20Airdropper airdropper = new ERC20Airdropper(
+            Dropper(address(0x2871e49a08AceE842C8F225bE7BFf9cC311b9F43))
+        );
+        console.log(address(airdropper));
+        vm.stopBroadcast();
+    }
+}

src/ERC20Airdropper.sol

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8;
+
+import { GovernableERC20 } from "./GovernableERC20.sol";
+import { ERC20 } from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
+import { Dropper } from "dropper-util/src/Dropper.sol";
+
+contract ERC20Airdropper {
+    struct TokenArgs {
+        string name;
+        string symbol;
+        // Token metadata image URI that only gets emitted (not stored on-chain)
+        string image;
+        // Token metadata description that only gets emitted (not stored on-chain)
+        string description;
+        uint256 totalSupply;
+        address owner;
+    }
+
+    struct DropArgs {
+        bytes32 merkleRoot;
+        uint256 totalTokens;
+        uint40 startTimestamp;
+        uint40 expirationTimestamp;
+        address expirationRecipient;
+        string merkleTreeURI;
+        string dropDescription;
+    }
+
+    event DropCreated(
+        uint256 indexed dropId,
+        address indexed token,
+        bytes32 merkleRoot,
+        uint256 totalTokens,
+        uint40 startTimestamp,
+        uint40 expirationTimestamp
+    );
+
+    event ERC20Created(
+        address indexed token,
+        address indexed owner,
+        string name,
+        string symbol,
+        uint256 totalSupply
+    );
+
+    Dropper public immutable DROPPER;
+
+    constructor(Dropper dropper) {
+        DROPPER = dropper;
+    }
+
+    function createTokenAndAirdrop(
+        TokenArgs memory tokenArgs,
+        DropArgs memory dropArgs
+    ) external returns (ERC20 token, uint256 dropId) {
+        token = createToken(tokenArgs, address(this));
+
+        token.approve(address(DROPPER), dropArgs.totalTokens);
+
+        dropId = DROPPER.createDrop(
+            dropArgs.merkleRoot,
+            dropArgs.totalTokens,
+            address(token),
+            dropArgs.startTimestamp,
+            dropArgs.expirationTimestamp,
+            dropArgs.expirationRecipient,
+            dropArgs.merkleTreeURI,
+            dropArgs.dropDescription
+        );
+
+        emit DropCreated(
+            dropId,
+            address(token),
+            dropArgs.merkleRoot,
+            dropArgs.totalTokens,
+            dropArgs.startTimestamp,
+            dropArgs.expirationTimestamp
+        );
+
+        uint256 remaining = token.balanceOf(address(this));
+        if (remaining > 0) {
+            token.transfer(msg.sender, remaining);
+        }
+    }
+
+    function createToken(
+        TokenArgs memory tokenArgs,
+        address receiver
+    ) public returns (ERC20 token) {
+        token = new GovernableERC20(
+            tokenArgs.name,
+            tokenArgs.symbol,
+            tokenArgs.image,
+            tokenArgs.description,
+            tokenArgs.totalSupply,
+            receiver,
+            tokenArgs.owner
+        );
+
+        emit ERC20Created(
+            address(token),
+            tokenArgs.owner,
+            tokenArgs.name,
+            tokenArgs.symbol,
+            tokenArgs.totalSupply
+        );
+    }
+}

src/ERC20Creator.sol

@@ -32,6 +32,12 @@ contract ERC20Creator {
     address public feeRecipient;
     uint16 public feeBasisPoints;
 
+    struct TokenMetadata {
+        string name;
+        string symbol;
+        string image;
+        string description;
+    }
     struct TokenConfiguration {
         uint256 totalSupply;
         uint256 numTokensForDistribution;
@@ -58,8 +64,7 @@ contract ERC20Creator {
 
     function createToken(
         address partyAddress,
-        string calldata name,
-        string calldata symbol,
+        TokenMetadata calldata metadata,
         TokenConfiguration calldata config,
         address recipientAddress
     ) external payable returns (ERC20 token) {
@@ -74,7 +79,15 @@ contract ERC20Creator {
         }
 
         // Create token
-        token = new GovernableERC20(name, symbol, config.totalSupply, address(this));
+        token = new GovernableERC20(
+            metadata.name,
+            metadata.symbol,
+            metadata.image,
+            metadata.description,
+            config.totalSupply,
+            address(this),
+            partyAddress
+        );
 
         if (config.numTokensForDistribution > 0) {
             // Create distribution
@@ -113,8 +126,8 @@ contract ERC20Creator {
             address(token),
             partyAddress,
             recipientAddress,
-            name,
-            symbol,
+            metadata.name,
+            metadata.symbol,
             ethValue,
             config
         );

src/ERC20CreatorV3.sol

@@ -19,6 +19,13 @@ contract ERC20CreatorV3 is IERC721Receiver {
         uint256 numTokensForLP; // Number of tokens for the Uniswap V3 LP
     }
 
+    struct TokenMetadata {
+        string name;
+        string symbol;
+        string image;
+        string description;
+    }
+
     event ERC20Created(
         address indexed token,
         address indexed party,
@@ -99,16 +106,14 @@ contract ERC20CreatorV3 is IERC721Receiver {
     /// @dev The party is assumed to be `msg.sender`
     /// @param party The party to allocate the token distribution to
     /// @param lpFeeRecipient The address to receive the LP fee
-    /// @param name The name of the new token
-    /// @param symbol The symbol of the new token
+    /// @param metadata Token metadata including name, symbol, image, and description
     /// @param config Token distribution configuration. See above for additional information.
     /// @param tokenRecipientAddress The address to receive the tokens allocated for the token recipient
     /// @return token The address of the newly created token
     function createToken(
         address party,
         address lpFeeRecipient,
-        string memory name,
-        string memory symbol,
+        TokenMetadata memory metadata,
         TokenDistributionConfiguration memory config,
         address tokenRecipientAddress
     ) external payable returns (address) {
@@ -129,7 +134,15 @@ contract ERC20CreatorV3 is IERC721Receiver {
             address(
                 new GovernableERC20{
                     salt: keccak256(abi.encode(blockhash(block.number - 1), msg.sender))
-                }(name, symbol, config.totalSupply, address(this))
+                }(
+                    metadata.name,
+                    metadata.symbol,
+                    metadata.image,
+                    metadata.description,
+                    config.totalSupply,
+                    address(this),
+                    party
+                )
             )
         );
 
@@ -234,8 +247,8 @@ contract ERC20CreatorV3 is IERC721Receiver {
             address(token),
             party,
             tokenRecipientAddress,
-            name,
-            symbol,
+            metadata.name,
+            metadata.symbol,
             msg.value,
             config
         );

src/GovernableERC20.sol

@@ -3,15 +3,28 @@ pragma solidity ^0.8;
 
 import "openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Permit.sol";
 import "openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Votes.sol";
+import "openzeppelin-contracts/contracts/access/Ownable.sol";
+
+contract GovernableERC20 is ERC20Permit, ERC20Votes, Ownable {
+    event MetadataSet(string image, string description);
 
-contract GovernableERC20 is ERC20Permit, ERC20Votes {
     constructor(
-        string memory _name,
-        string memory _symbol,
-        uint256 _totalSupply,
-        address _receiver
-    ) ERC20(_name, _symbol) ERC20Permit(_name) {
-        _mint(_receiver, _totalSupply);
+        string memory name_,
+        string memory symbol_,
+        string memory image_,
+        string memory description_,
+        uint256 totalSupply_,
+        address receiver_,
+        address owner_
+    ) ERC20(name_, symbol_) ERC20Permit(name_) Ownable(owner_) {
+        _mint(receiver_, totalSupply_);
+
+        emit MetadataSet(image_, description_);
+    }
+
+    /// @notice Updates the emitted metadata for the token.
+    function setMetadata(string memory image, string memory description) public onlyOwner {
+        emit MetadataSet(image, description);
     }
 
     // The following functions are overrides required by Solidity.