extracted claim interface (#32)

Author: oveddan

src/claim/IZoraTokenCommunityClaim.sol

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+/**
+ * @title IZoraTokenCommunityClaim
+ * @notice Interface for the Zora Token Community Claim contract
+ */
+interface IZoraTokenCommunityClaim {
+    /**
+     * @notice Emitted when allocations are set
+     * @param allocations The packed allocation data (address + amount)
+     */
+    event AllocationsSet(bytes32[] indexed allocations);
+
+    /**
+     * @notice Emitted when tokens are claimed
+     * @param account The account that had the allocation
+     * @param claimTo The address that received the tokens
+     * @param amount The amount of tokens claimed
+     */
+    event Claimed(address indexed account, address indexed claimTo, uint256 amount);
+
+    /**
+     * @notice Error thrown when a non-admin tries to perform an admin-only action
+     */
+    error OnlyAdmin();
+
+    /**
+     * @notice Error thrown when trying to claim before the claim period has started
+     */
+    error ClaimNotOpen();
+
+    /**
+     * @notice Error thrown when trying to set allocations after the claim period has started
+     */
+    error ClaimOpened();
+
+    /**
+     * @notice Error thrown when a user tries to claim without having an allocation
+     */
+    error NoAllocation();
+
+    /**
+     * @notice Error thrown when a user tries to claim more than once
+     */
+    error AlreadyClaimed();
+
+    /**
+     * @notice Error thrown when a signature is invalid
+     */
+    error InvalidSignature();
+
+    /**
+     * @notice Error thrown when a signature has expired
+     */
+    error SignatureExpired();
+
+    /**
+     * @notice Returns the admin address
+     * @return The admin address
+     */
+    function admin() external view returns (address);
+
+    /**
+     * @notice Returns the claim start timestamp
+     * @return The claim start timestamp
+     */
+    function claimStart() external view returns (uint256);
+
+    /**
+     * @notice Returns the token contract address
+     * @return The token contract address
+     */
+    function token() external view returns (IERC20);
+
+    /**
+     * @notice Returns the allocation for a user
+     * @param user The user address
+     * @return The allocation amount
+     */
+    function allocations(address user) external view returns (uint256);
+
+    /**
+     * @notice Returns whether a user has claimed their allocation
+     * @param user The user address
+     * @return Whether the user has claimed
+     */
+    function hasClaimed(address user) external view returns (bool);
+
+    /**
+     * @notice Sets allocations using packed data format for gas efficiency
+     * @dev Each bytes32 contains an address (160 bits) and allocation (96 bits)
+     * @param packedData Array of packed address+allocation data
+     */
+    function setAllocations(bytes32[] calldata packedData) external;
+
+    /**
+     * @notice Returns whether claiming is open
+     * @return Whether claiming is open
+     */
+    function claimIsOpen() external view returns (bool);
+
+    /**
+     * @notice Claims tokens for the caller
+     * @param _claimTo The address to send the tokens to
+     */
+    function claim(address _claimTo) external;
+
+    /**
+     * @notice Claims tokens on behalf of a user with their signature
+     * @param _user The user who is delegating their claim
+     * @param _claimTo The address to send the tokens to
+     * @param _deadline The deadline for the signature to be valid
+     * @param _signature The signature authorizing the claim
+     */
+    function claimWithSignature(address _user, address _claimTo, uint256 _deadline, bytes calldata _signature) external;
+
+    /**
+     * @notice Returns the domain separator used for EIP-712 signatures
+     * @return The domain separator
+     */
+    function getDomainSeparator() external view returns (bytes32);
+}

src/claim/ZoraTokenCommunityClaim.sol

@@ -5,37 +5,26 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {SignatureChecker} from "@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol";
 import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {IZoraTokenCommunityClaim} from "./IZoraTokenCommunityClaim.sol";
 
 /// @title Zora Token Claim
 /// @notice Contract for distributing tokens to the Zora community
 /// @dev Allows an admin to set allocations in advance using a storage mapping of addresses to amounts,
 /// avoiding the blockspace congestion that can occur with merkle proofs during claiming
-contract ZoraTokenCommunityClaim is EIP712 {
+contract ZoraTokenCommunityClaim is IZoraTokenCommunityClaim, EIP712 {
     string private constant DOMAIN_NAME = "ZoraTokenCommunityClaim";
     string private constant DOMAIN_VERSION = "1";
 
     // Type hash for the ClaimWithSignature struct
     bytes32 private constant CLAIM_TYPEHASH = keccak256("ClaimWithSignature(address user,address claimTo,uint256 deadline)");
 
-    address public immutable admin;
-    uint256 public immutable claimStart;
+    address public immutable override admin;
+    uint256 public immutable override claimStart;
     IERC20 public immutable token;
 
     // Compact allocations stored as uint96 (token count, will be multiplied by 1e18)
     mapping(address => uint96) private compactAllocations;
-    mapping(address => bool) public hasClaimed;
-
-    error OnlyAdmin();
-    error ClaimNotOpen();
-    error ClaimOpened();
-    error ArrayLengthMismatch();
-    error NoAllocation();
-    error AlreadyClaimed();
-    error InvalidSignature();
-    error SignatureExpired();
-
-    event AllocationsSet(bytes32[] indexed allocations);
-    event Claimed(address indexed account, address indexed claimTo, uint256 amount);
+    mapping(address => bool) public override hasClaimed;
 
     constructor(address _admin, uint256 _claimStart, address _token) EIP712(DOMAIN_NAME, DOMAIN_VERSION) {
         admin = _admin;
@@ -44,14 +33,14 @@ contract ZoraTokenCommunityClaim is EIP712 {
     }
 
     // Public view function to get the full allocation amount with 18 decimals
-    function allocations(address user) public view returns (uint256) {
+    function allocations(address user) public view override returns (uint256) {
         return uint256(compactAllocations[user]);
     }
 
     /// @notice Sets allocations using packed data format for gas efficiency
     /// @dev Each bytes32 contains an address (160 bits) and allocation (96 bits)
     /// @param packedData Array of packed address+allocation data
-    function setAllocations(bytes32[] calldata packedData) external {
+    function setAllocations(bytes32[] calldata packedData) external override {
         require(msg.sender == admin, OnlyAdmin());
         require(!claimIsOpen(), ClaimOpened());
 
@@ -69,11 +58,11 @@ contract ZoraTokenCommunityClaim is EIP712 {
         emit AllocationsSet(packedData);
     }
 
-    function claimIsOpen() public view returns (bool) {
+    function claimIsOpen() public view override returns (bool) {
         return block.timestamp >= claimStart;
     }
 
-    function claim(address _claimTo) external {
+    function claim(address _claimTo) external override {
         _claim(msg.sender, _claimTo);
     }
 
@@ -82,7 +71,7 @@ contract ZoraTokenCommunityClaim is EIP712 {
     /// @param _claimTo The address to send the tokens to
     /// @param _deadline The deadline for the signature to be valid
     /// @param _signature The signature authorizing the claim
-    function claimWithSignature(address _user, address _claimTo, uint256 _deadline, bytes calldata _signature) external {
+    function claimWithSignature(address _user, address _claimTo, uint256 _deadline, bytes calldata _signature) external override {
         require(block.timestamp <= _deadline, SignatureExpired());
 
         // Verify signature
@@ -113,8 +102,8 @@ contract ZoraTokenCommunityClaim is EIP712 {
         SafeERC20.safeTransfer(token, _claimTo, amount);
     }
 
-    // Make the domain separator accessible for testing
-    function getDomainSeparator() public view returns (bytes32) {
+    /// @notice Make the domain separator accessible for testing
+    function getDomainSeparator() public view override returns (bytes32) {
         return _domainSeparatorV4();
     }
 }

test/ZoraTokenCommunityClaim.t.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.28;
 import {Test} from "forge-std/Test.sol";
 import {Zora} from "../src/zora/Zora.sol";
 import {ZoraTokenCommunityClaim} from "../src/claim/ZoraTokenCommunityClaim.sol";
+import {IZoraTokenCommunityClaim} from "../src/claim/IZoraTokenCommunityClaim.sol";
 import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
 
 interface IMultiOwnable {
@@ -98,7 +99,7 @@ contract ZoraTokenCommunityClaimTest is Test {
         bytes32[] memory compactAllocations = toCompactAllocations(accounts, amounts);
 
         vm.prank(makeAddr("not-admin"));
-        vm.expectRevert(ZoraTokenCommunityClaim.OnlyAdmin.selector);
+        vm.expectRevert(IZoraTokenCommunityClaim.OnlyAdmin.selector);
         claim.setAllocations(compactAllocations);
     }
 
@@ -115,7 +116,7 @@ contract ZoraTokenCommunityClaimTest is Test {
         vm.warp(claimStart + 1);
 
         vm.prank(deployer);
-        vm.expectRevert(ZoraTokenCommunityClaim.ClaimOpened.selector);
+        vm.expectRevert(IZoraTokenCommunityClaim.ClaimOpened.selector);
         claim.setAllocations(compactAllocations);
     }
 
@@ -161,7 +162,7 @@ contract ZoraTokenCommunityClaimTest is Test {
         claim.setAllocations(compactAllocations);
 
         vm.prank(user1);
-        vm.expectRevert(ZoraTokenCommunityClaim.ClaimNotOpen.selector);
+        vm.expectRevert(IZoraTokenCommunityClaim.ClaimNotOpen.selector);
         claim.claim(user1);
     }
 
@@ -234,7 +235,7 @@ contract ZoraTokenCommunityClaimTest is Test {
         claim.claimWithSignature(signer, recipient, deadline, signature);
 
         // Second claim should fail due to no allocation
-        vm.expectRevert(ZoraTokenCommunityClaim.AlreadyClaimed.selector);
+        vm.expectRevert(IZoraTokenCommunityClaim.AlreadyClaimed.selector);
         claim.claimWithSignature(signer, recipient, deadline, signature);
     }
 
@@ -261,7 +262,7 @@ contract ZoraTokenCommunityClaimTest is Test {
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
         bytes memory signature = abi.encodePacked(r, s, v);
 
-        vm.expectRevert(ZoraTokenCommunityClaim.SignatureExpired.selector);
+        vm.expectRevert(IZoraTokenCommunityClaim.SignatureExpired.selector);
         claim.claimWithSignature(signer, recipient, deadline, signature);
     }
 
@@ -288,7 +289,7 @@ contract ZoraTokenCommunityClaimTest is Test {
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(wrongPrivateKey, digest);
         bytes memory signature = abi.encodePacked(r, s, v);
 
-        vm.expectRevert(ZoraTokenCommunityClaim.InvalidSignature.selector);
+        vm.expectRevert(IZoraTokenCommunityClaim.InvalidSignature.selector);
         claim.claimWithSignature(signer, recipient, deadline, signature);
     }
 
@@ -365,7 +366,7 @@ contract ZoraTokenCommunityClaimTest is Test {
         bytes memory signature = abi.encodePacked(r, s, v);
 
         // Attempt to claim with invalid signature should fail
-        vm.expectRevert(ZoraTokenCommunityClaim.InvalidSignature.selector);
+        vm.expectRevert(IZoraTokenCommunityClaim.InvalidSignature.selector);
         claim.claimWithSignature(address(smartWallet), recipient, deadline, signature);
     }
 }