@towns-protocol/contracts 0.0.302

package/scripts/interactions/interfaces/IL2StandardBridge.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+interface IL2StandardBridge {
+    /// @notice Sends ETH to the sender's address on the other chain.
+    /// @param _minGasLimit Minimum amount of gas that the bridge can be relayed with.
+    /// @param _extraData   Extra data to be sent with the transaction. Note that the recipient will
+    ///                     not be triggered with this data, but it will be emitted and can be used
+    ///                     to identify the transaction.
+    function bridgeETH(uint32 _minGasLimit, bytes calldata _extraData) external payable;
+
+    /// @notice Sends ETH to a receiver's address on the other chain. Note that if ETH is sent to a
+    ///         smart contract and the call fails, the ETH will be temporarily locked in the
+    ///         StandardBridge on the other chain until the call is replayed. If the call cannot be
+    ///         replayed with any amount of gas (call always reverts), then the ETH will be
+    ///         permanently locked in the StandardBridge on the other chain. ETH will also
+    ///         be locked if the receiver is the other bridge, because finalizeBridgeETH will revert
+    ///         in that case.
+    /// @param _to          Address of the receiver.
+    /// @param _minGasLimit Minimum amount of gas that the bridge can be relayed with.
+    /// @param _extraData   Extra data to be sent with the transaction. Note that the recipient will
+    ///                     not be triggered with this data, but it will be emitted and can be used
+    ///                     to identify the transaction.
+    function bridgeETHTo(
+        address _to,
+        uint32 _minGasLimit,
+        bytes calldata _extraData
+    ) external payable;
+
+    /// @notice Sends ERC20 tokens to the sender's address on the other chain. Note that if the
+    ///         ERC20 token on the other chain does not recognize the local token as the correct
+    ///         pair token, the ERC20 bridge will fail and the tokens will be returned to sender on
+    ///         this chain.
+    /// @param _localToken  Address of the ERC20 on this chain.
+    /// @param _remoteToken Address of the corresponding token on the remote chain.
+    /// @param _amount      Amount of local tokens to deposit.
+    /// @param _minGasLimit Minimum amount of gas that the bridge can be relayed with.
+    /// @param _extraData   Extra data to be sent with the transaction. Note that the recipient will
+    ///                     not be triggered with this data, but it will be emitted and can be used
+    ///                     to identify the transaction.
+    function bridgeERC20(
+        address _localToken,
+        address _remoteToken,
+        uint256 _amount,
+        uint32 _minGasLimit,
+        bytes calldata _extraData
+    ) external;
+
+    /// @notice Sends ERC20 tokens to a receiver's address on the other chain. Note that if the
+    ///         ERC20 token on the other chain does not recognize the local token as the correct
+    ///         pair token, the ERC20 bridge will fail and the tokens will be returned to sender on
+    ///         this chain.
+    /// @param _localToken  Address of the ERC20 on this chain.
+    /// @param _remoteToken Address of the corresponding token on the remote chain.
+    /// @param _to          Address of the receiver.
+    /// @param _amount      Amount of local tokens to deposit.
+    /// @param _minGasLimit Minimum amount of gas that the bridge can be relayed with.
+    /// @param _extraData   Extra data to be sent with the transaction. Note that the recipient will
+    ///                     not be triggered with this data, but it will be emitted and can be used
+    ///                     to identify the transaction.
+    function bridgeERC20To(
+        address _localToken,
+        address _remoteToken,
+        address _to,
+        uint256 _amount,
+        uint32 _minGasLimit,
+        bytes calldata _extraData
+    ) external;
+}

package/src/airdrop/drop/DropBase.sol

@@ -0,0 +1,210 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDropFacetBase} from "./IDropFacet.sol";
+
+// libraries
+import {BasisPoints} from "../../utils/libraries/BasisPoints.sol";
+import {CustomRevert} from "../../utils/libraries/CustomRevert.sol";
+import {DropGroup} from "./DropGroup.sol";
+import {DropStorage} from "./DropStorage.sol";
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
+
+abstract contract DropBase is IDropFacetBase {
+    using DropGroup for DropGroup.Layout;
+    using SafeTransferLib for address;
+    using CustomRevert for bytes4;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          SETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _setRewardsDistribution(address rewardsDistribution) internal {
+        if (rewardsDistribution == address(0)) {
+            DropFacet__RewardsDistributionNotSet.selector.revertWith();
+        }
+
+        _getLayout().rewardsDistribution = rewardsDistribution;
+    }
+
+    function _addClaimCondition(DropGroup.ClaimCondition calldata newCondition) internal {
+        (uint48 existingStartId, uint48 existingCount) = _getStartIdAndCount();
+        uint48 newConditionId = existingStartId + existingCount;
+
+        // Check timestamp order
+        if (existingCount > 0) {
+            DropGroup.ClaimCondition storage lastCondition;
+            unchecked {
+                lastCondition = _getClaimConditionById(newConditionId - 1);
+            }
+            if (lastCondition.startTimestamp >= newCondition.startTimestamp) {
+                DropFacet__ClaimConditionsNotInAscendingOrder.selector.revertWith();
+            }
+        }
+
+        // verify enough balance
+        _verifyEnoughBalance(newCondition.currency, newCondition.maxClaimableSupply);
+
+        _getDropGroup(newConditionId).condition = newCondition;
+
+        // Update condition count
+        _getLayout().conditionCount = existingCount + 1;
+
+        emit DropFacet_ClaimConditionAdded(newConditionId, newCondition);
+    }
+
+    function _setClaimConditions(DropGroup.ClaimCondition[] calldata conditions) internal {
+        DropStorage.Layout storage self = _getLayout();
+        // get the existing claim condition count and start id
+        (uint48 newStartId, uint48 existingConditionCount) = _getStartIdAndCount();
+
+        if (uint256(newStartId) + conditions.length > type(uint48).max) {
+            DropFacet__CannotSetClaimConditions.selector.revertWith();
+        }
+
+        uint48 newConditionCount = uint48(conditions.length);
+
+        uint48 lastConditionTimestamp;
+        uint256 totalClaimableSupply;
+
+        for (uint256 i; i < newConditionCount; ++i) {
+            DropGroup.ClaimCondition calldata newCondition = conditions[i];
+            if (lastConditionTimestamp >= newCondition.startTimestamp) {
+                DropFacet__ClaimConditionsNotInAscendingOrder.selector.revertWith();
+            }
+
+            // check that amount already claimed is less than or equal to the max claimable supply
+            DropGroup.Layout storage drop = self.groupById[newStartId + i];
+            uint256 amountAlreadyClaimed = drop.condition.supplyClaimed;
+
+            if (amountAlreadyClaimed > newCondition.maxClaimableSupply) {
+                DropFacet__CannotSetClaimConditions.selector.revertWith();
+            }
+
+            // copy the new condition to the storage except `supplyClaimed`
+            drop.updateClaimCondition(newCondition);
+
+            lastConditionTimestamp = newCondition.startTimestamp;
+            totalClaimableSupply += newCondition.maxClaimableSupply;
+            _verifyEnoughBalance(newCondition.currency, totalClaimableSupply);
+        }
+
+        self.conditionCount = newConditionCount;
+
+        if (existingConditionCount > newConditionCount) {
+            for (uint256 i = newConditionCount; i < existingConditionCount; ++i) {
+                unchecked {
+                    delete self.groupById[newStartId + i];
+                }
+            }
+        }
+
+        emit DropFacet_ClaimConditionsUpdated(newStartId, conditions);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                            UTILS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _deductPenalty(
+        uint256 amount,
+        uint16 penaltyBps,
+        uint16 expectedPenaltyBps
+    ) internal pure returns (uint256) {
+        if (penaltyBps != expectedPenaltyBps) {
+            DropFacet__UnexpectedPenaltyBps.selector.revertWith();
+        }
+
+        if (penaltyBps > 0) {
+            unchecked {
+                uint256 penaltyAmount = BasisPoints.calculate(amount, penaltyBps);
+                amount -= penaltyAmount;
+            }
+        }
+        return amount;
+    }
+
+    function _verifyEnoughBalance(address token, uint256 amount) internal view {
+        if (amount > token.balanceOf(address(this))) {
+            DropFacet__InsufficientBalance.selector.revertWith();
+        }
+    }
+
+    function _approveClaimToken(address token, uint256 amount) internal {
+        token.safeApprove(_getLayout().rewardsDistribution, amount);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _getLayout() internal pure returns (DropStorage.Layout storage) {
+        return DropStorage.getLayout();
+    }
+
+    function _getDropGroup(uint256 conditionId) internal view returns (DropGroup.Layout storage) {
+        return _getLayout().groupById[conditionId];
+    }
+
+    function _getClaimConditionById(
+        uint256 conditionId
+    ) internal view returns (DropGroup.ClaimCondition storage) {
+        return _getDropGroup(conditionId).condition;
+    }
+
+    function _getSupplyClaimedByWallet(
+        uint256 conditionId,
+        address account
+    ) internal view returns (DropGroup.Claimed storage) {
+        return _getDropGroup(conditionId).supplyClaimedByWallet[account];
+    }
+
+    function _getStartIdAndCount() internal view returns (uint48 startId, uint48 count) {
+        DropStorage.Layout storage self = _getLayout();
+        (startId, count) = (self.conditionStartId, self.conditionCount);
+    }
+
+    function _getClaimConditions()
+        internal
+        view
+        returns (DropGroup.ClaimCondition[] memory conditions)
+    {
+        (uint48 conditionStartId, uint48 conditionCount) = _getStartIdAndCount();
+        conditions = new DropGroup.ClaimCondition[](conditionCount);
+        for (uint256 i; i < conditionCount; ++i) {
+            conditions[i] = _getClaimConditionById(conditionStartId + i);
+        }
+        return conditions;
+    }
+
+    function _getActiveConditionId() internal view returns (uint256) {
+        (uint48 conditionStartId, uint48 conditionCount) = _getStartIdAndCount();
+
+        if (conditionCount == 0) {
+            DropFacet__NoActiveClaimCondition.selector.revertWith();
+        }
+
+        uint256 lastConditionId;
+        unchecked {
+            lastConditionId = conditionStartId + conditionCount - 1;
+        }
+
+        for (uint256 i = lastConditionId + 1; i > conditionStartId; ) {
+            unchecked {
+                --i;
+            }
+
+            DropGroup.ClaimCondition storage condition = _getClaimConditionById(i);
+            uint256 endTimestamp = condition.endTimestamp;
+            if (
+                block.timestamp >= condition.startTimestamp &&
+                (endTimestamp == 0 || block.timestamp < endTimestamp)
+            ) {
+                return i;
+            }
+        }
+
+        DropFacet__NoActiveClaimCondition.selector.revertWith();
+    }
+}

package/src/airdrop/drop/DropClaim.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDropFacetBase} from "./IDropFacet.sol";
+
+// libraries
+import {CustomRevert} from "../../utils/libraries/CustomRevert.sol";
+import {MerkleProofLib} from "solady/utils/MerkleProofLib.sol";
+
+// contracts
+
+library DropClaim {
+    using MerkleProofLib for bytes32[];
+    using CustomRevert for bytes4;
+
+    /// @notice A struct representing a claim
+    /// @param conditionId The ID of the claim condition
+    /// @param account The address of the account that claimed
+    /// @param recipient The address of the recipient of the tokens
+    /// @param quantity The quantity of tokens claimed
+    /// @param points The points to be burned
+    /// @param proof The proof of the claim
+    struct Claim {
+        uint256 conditionId;
+        address account;
+        address recipient;
+        uint256 quantity;
+        uint256 points;
+        bytes32[] proof;
+    }
+
+    function verify(Claim calldata claim, bytes32 root) internal pure {
+        bytes32 leaf = createLeaf(claim);
+        if (!claim.proof.verifyCalldata(root, leaf)) {
+            IDropFacetBase.DropFacet__InvalidProof.selector.revertWith();
+        }
+    }
+
+    function createLeaf(Claim calldata claim) internal pure returns (bytes32 leaf) {
+        address account = claim.account;
+        uint256 quantity = claim.quantity;
+        uint256 points = claim.points;
+        assembly ("memory-safe") {
+            let fmp := mload(0x40)
+            mstore(0, account)
+            mstore(0x20, quantity)
+            mstore(0x40, points)
+            leaf := keccak256(0, 0x60)
+            mstore(0, leaf)
+            leaf := keccak256(0, 0x20)
+            mstore(0x40, fmp)
+        }
+    }
+}

package/src/airdrop/drop/DropFacet.sol

@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IRewardsDistribution} from "../../base/registry/facets/distribution/v2/IRewardsDistribution.sol";
+import {IDropFacet} from "./IDropFacet.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+// libraries
+import {DropClaim} from "./DropClaim.sol";
+import {DropGroup} from "./DropGroup.sol";
+import {DropStorage} from "./DropStorage.sol";
+import {SafeCastLib} from "solady/utils/SafeCastLib.sol";
+import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
+import {CustomRevert} from "../../utils/libraries/CustomRevert.sol";
+
+// contracts
+import {TownsPointsStorage} from "../points/TownsPointsStorage.sol";
+import {DropBase} from "./DropBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {PausableBase} from "@towns-protocol/diamond/src/facets/pausable/PausableBase.sol";
+
+contract DropFacet is IDropFacet, DropBase, OwnableBase, PausableBase, Facet {
+    using DropClaim for DropClaim.Claim;
+    using DropGroup for DropGroup.Layout;
+    using SafeTransferLib for address;
+    using CustomRevert for bytes4;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       ADMIN FUNCTIONS                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function __DropFacet_init(address rewardsDistribution) external onlyInitializing {
+        _addInterface(type(IDropFacet).interfaceId);
+        __DropFacet_init_unchained(rewardsDistribution);
+    }
+
+    function __DropFacet_init_unchained(address rewardsDistribution) internal {
+        _setRewardsDistribution(rewardsDistribution);
+    }
+
+    /// @inheritdoc IDropFacet
+    function addClaimCondition(DropGroup.ClaimCondition calldata condition) external onlyOwner {
+        _addClaimCondition(condition);
+    }
+
+    /// @inheritdoc IDropFacet
+    function setClaimConditions(DropGroup.ClaimCondition[] calldata conditions) external onlyOwner {
+        _setClaimConditions(conditions);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          CLAIMING                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IDropFacet
+    function claimWithPenalty(
+        DropClaim.Claim calldata req,
+        uint16 expectedPenaltyBps
+    ) external whenNotPaused returns (uint256 amount) {
+        if (msg.sender != req.account) DropFacet__NotClaimingAccount.selector.revertWith();
+        if (req.recipient == address(0)) DropFacet__InvalidRecipient.selector.revertWith();
+
+        DropGroup.Layout storage drop = _getDropGroup(req.conditionId);
+
+        amount = _deductPenalty(req.quantity, drop.condition.penaltyBps, expectedPenaltyBps);
+
+        drop.verify(amount);
+
+        // verify the Merkle proof of the claim
+        req.verify(drop.condition.merkleRoot);
+
+        drop.claim(req.account, amount);
+
+        _burnPoints(req.account, req.points);
+
+        drop.condition.currency.safeTransfer(req.recipient, amount);
+
+        emit DropFacet_Claimed_WithPenalty(req.conditionId, msg.sender, req.account, amount);
+    }
+
+    /// @inheritdoc IDropFacet
+    function claimAndStake(
+        DropClaim.Claim calldata req,
+        address delegatee,
+        uint256 deadline,
+        bytes calldata signature
+    ) external whenNotPaused returns (uint256 amount) {
+        if (msg.sender != req.account) DropFacet__NotClaimingAccount.selector.revertWith();
+        if (req.recipient == address(0)) DropFacet__InvalidRecipient.selector.revertWith();
+
+        DropGroup.Layout storage drop = _getDropGroup(req.conditionId);
+
+        amount = req.quantity;
+        drop.verify(amount);
+
+        // verify the Merkle proof of the claim
+        req.verify(drop.condition.merkleRoot);
+
+        drop.claim(req.account, amount);
+
+        _burnPoints(req.account, req.points);
+        _approveClaimToken(drop.condition.currency, amount);
+
+        uint256 depositId = IRewardsDistribution(DropStorage.getLayout().rewardsDistribution)
+            .stakeOnBehalf(
+                SafeCastLib.toUint96(amount),
+                delegatee,
+                req.account,
+                req.account,
+                deadline,
+                signature
+            );
+
+        DropGroup.Claimed storage claimed = drop.supplyClaimedByWallet[req.account];
+        claimed.depositId = depositId;
+
+        emit DropFacet_Claimed_And_Staked(req.conditionId, msg.sender, req.account, amount);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          GETTERS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IDropFacet
+    function getActiveClaimConditionId() external view returns (uint256) {
+        return _getActiveConditionId();
+    }
+
+    /// @inheritdoc IDropFacet
+    function getClaimConditions() external view returns (DropGroup.ClaimCondition[] memory) {
+        return _getClaimConditions();
+    }
+
+    /// @inheritdoc IDropFacet
+    function getClaimConditionById(
+        uint256 conditionId
+    ) external view returns (DropGroup.ClaimCondition memory condition) {
+        assembly ("memory-safe") {
+            // By default, memory has been implicitly allocated for `condition`.
+            // But we don't need this implicitly allocated memory.
+            // So we just set the free memory pointer to what it was before `condition` has been
+            // allocated.
+            mstore(0x40, condition)
+        }
+        condition = _getClaimConditionById(conditionId);
+    }
+
+    /// @inheritdoc IDropFacet
+    function getSupplyClaimedByWallet(
+        address account,
+        uint256 conditionId
+    ) external view returns (uint256) {
+        return _getSupplyClaimedByWallet(conditionId, account).amount;
+    }
+
+    /// @inheritdoc IDropFacet
+    function getDepositIdByWallet(
+        address account,
+        uint256 conditionId
+    ) external view returns (uint256) {
+        return _getSupplyClaimedByWallet(conditionId, account).depositId;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        INTERNAL FUNCTIONS                  */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function _burnPoints(address from, uint256 amount) internal {
+        if (amount == 0) return;
+        TownsPointsStorage.Layout storage points = TownsPointsStorage.layout();
+        points.inner.burn(from, amount);
+        emit IERC20.Transfer(from, address(0), amount);
+    }
+}

package/src/airdrop/drop/DropGroup.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {IDropFacetBase} from "./IDropFacet.sol";
+
+// libraries
+import {CustomRevert} from "../../utils/libraries/CustomRevert.sol";
+
+// contracts
+
+library DropGroup {
+    using CustomRevert for bytes4;
+
+    /// @notice The layout of the drop group
+    /// @param supplyClaimedByWallet A mapping of addresses to their claimed amounts and deposit IDs
+    /// @param condition The current claim condition
+    struct Layout {
+        mapping(address => Claimed) supplyClaimedByWallet;
+        ClaimCondition condition;
+    }
+
+    /// @notice A struct representing a claimed drop
+    /// @param amount The amount of tokens claimed
+    /// @param depositId The deposit ID of the claim
+    struct Claimed {
+        uint256 amount;
+        uint256 depositId;
+    }
+
+    /// @notice A struct representing a claim condition
+    /// @param currency The currency to claim in
+    /// @param startTimestamp The timestamp at which the claim condition starts
+    /// @param endTimestamp The timestamp at which the claim condition ends
+    /// @param penaltyBps The penalty in basis points for early withdrawal
+    /// @param maxClaimableSupply The maximum claimable supply for the claim condition
+    /// @param supplyClaimed The supply already claimed for the claim condition
+    /// @param merkleRoot The merkle root for the claim condition
+    struct ClaimCondition {
+        address currency;
+        uint40 startTimestamp;
+        uint40 endTimestamp;
+        uint16 penaltyBps;
+        uint256 maxClaimableSupply;
+        uint256 supplyClaimed;
+        bytes32 merkleRoot;
+    }
+
+    /// @notice Updates to the claim condition except for `supplyClaimed`
+    /// @param self The drop group
+    /// @param newCondition The new claim condition
+    function updateClaimCondition(
+        Layout storage self,
+        ClaimCondition calldata newCondition
+    ) internal {
+        ClaimCondition storage condition = self.condition;
+        condition.startTimestamp = newCondition.startTimestamp;
+        condition.endTimestamp = newCondition.endTimestamp;
+        condition.maxClaimableSupply = newCondition.maxClaimableSupply;
+        condition.merkleRoot = newCondition.merkleRoot;
+        condition.currency = newCondition.currency;
+        condition.penaltyBps = newCondition.penaltyBps;
+    }
+
+    /// @notice Claims the amount of tokens for the claim
+    /// @param self The drop group
+    /// @param account The claiming account
+    /// @param amount The amount of tokens to claim
+    function claim(Layout storage self, address account, uint256 amount) internal {
+        Claimed storage claimed = self.supplyClaimedByWallet[account];
+        // check if already claimed
+        if (claimed.amount > 0) {
+            IDropFacetBase.DropFacet__AlreadyClaimed.selector.revertWith();
+        }
+
+        self.condition.supplyClaimed += amount;
+        claimed.amount = amount;
+    }
+
+    /// @notice Verifies the claim condition
+    /// @param self The drop group
+    /// @param amount The amount of tokens to claim
+    function verify(Layout storage self, uint256 amount) internal view {
+        ClaimCondition storage condition = self.condition;
+        if (condition.merkleRoot == bytes32(0)) {
+            IDropFacetBase.DropFacet__MerkleRootNotSet.selector.revertWith();
+        }
+
+        if (amount == 0) {
+            IDropFacetBase.DropFacet__QuantityMustBeGreaterThanZero.selector.revertWith();
+        }
+
+        if (condition.currency == address(0)) {
+            IDropFacetBase.DropFacet__CurrencyNotSet.selector.revertWith();
+        }
+
+        // check if the total claimed supply (including the current claim) exceeds the maximum
+        // claimable supply
+        if (condition.supplyClaimed + amount > condition.maxClaimableSupply) {
+            IDropFacetBase.DropFacet__ExceedsMaxClaimableSupply.selector.revertWith();
+        }
+
+        if (block.timestamp < condition.startTimestamp) {
+            IDropFacetBase.DropFacet__ClaimHasNotStarted.selector.revertWith();
+        }
+
+        if (condition.endTimestamp > 0 && block.timestamp >= condition.endTimestamp) {
+            IDropFacetBase.DropFacet__ClaimHasEnded.selector.revertWith();
+        }
+    }
+}

package/src/airdrop/drop/DropStorage.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {DropGroup} from "./DropGroup.sol";
+
+library DropStorage {
+    // keccak256(abi.encode(uint256(keccak256("diamond.facets.drop.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xeda6a1e2ce6f1639b6d3066254ca87a2daf51c4f0ad5038d408bbab6cc2cab00;
+
+    struct Layout {
+        address rewardsDistribution;
+        uint48 conditionStartId;
+        uint48 conditionCount;
+        mapping(uint256 groupId => DropGroup.Layout) groupById;
+    }
+
+    function getLayout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+}