@towns-protocol/contracts 0.0.302

package/src/tokens/towns/base/TownsLib.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @title TownsLib
+library TownsLib {
+    /// @notice Address of the L2StandardBridge predeploy.
+    address internal constant L2_STANDARD_BRIDGE = 0x4200000000000000000000000000000000000010;
+
+    /// @notice Address of the SuperchainTokenBridge predeploy.
+    address internal constant SUPERCHAIN_TOKEN_BRIDGE = 0x4200000000000000000000000000000000000028;
+
+    // keccak256(abi.encode(uint256(keccak256("towns.tokens.l2.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    bytes32 constant STORAGE_SLOT =
+        0x708ba15393f53e4db9d749d00ba2ba89a43d1e182bc44eaf801b83b223310b00;
+
+    struct Layout {
+        address remoteToken;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        assembly {
+            l.slot := STORAGE_SLOT
+        }
+    }
+
+    function initializeRemoteToken(address _remoteToken) internal {
+        Layout storage l = layout();
+        l.remoteToken = _remoteToken;
+    }
+}

package/src/tokens/towns/base/versions/TownsV2.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {Towns} from "../Towns.sol";
+
+contract TownsV2 is Towns {
+    function updateCoolDown(uint256 newCoolDown) external onlyOwner {
+        _setDefaultCooldown(newCoolDown);
+    }
+}

package/src/tokens/towns/mainnet/ITowns.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+interface ITownsBase {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Structs                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    struct InflationConfig {
+        uint256 initialMintTime;
+        uint256 initialInflationRate;
+        uint256 finalInflationRate;
+        uint256 finalInflationYears;
+        uint256 inflationDecayRate;
+        address inflationReceiver;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Errors                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    error InvalidAddress();
+    error InvalidInflationRate();
+    error MintingTooSoon();
+    error InitialSupplyAlreadyMinted();
+}
+
+interface ITowns is ITownsBase {
+    /// @notice Mints the initial supply to the given address
+    /// @dev Can only be called by the owner
+    /// @dev Can only be called once
+    function mintInitialSupply(address to) external;
+
+    /// @notice Creates new tokens according to the current inflation rate
+    /// @dev Can only be called by accounts with ROLE_INFLATION_MANAGER
+    /// @dev Mints tokens to the inflation receiver based on current total supply and inflation rate
+    /// @dev Updates lastMintTime to current block timestamp after minting
+    function createInflation() external;
+
+    /// @notice Allows the inflation rate manager to override the normal inflation rate
+    /// @param overrideInflation Whether to override the normal inflation rate
+    /// @param overrideInflationRate The inflation rate to use when overriding, in basis points
+    /// @dev Can only be called by accounts with ROLE_INFLATION_RATE_MANAGER
+    /// @dev overrideInflationRate must be less than or equal to finalInflationRate
+    function setOverrideInflation(bool overrideInflation, uint256 overrideInflationRate) external;
+
+    /// @notice Sets the receiver address for inflation rewards
+    /// @param receiver The new inflation receiver address
+    /// @dev Can only be called by accounts with ROLE_INFLATION_MANAGER
+    /// @dev receiver cannot be the zero address
+    function setInflationReceiver(address receiver) external;
+}

package/src/tokens/towns/mainnet/Towns.sol

@@ -0,0 +1,220 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ITowns} from "./ITowns.sol";
+
+import {IVotes} from "@openzeppelin/contracts/governance/utils/IVotes.sol";
+
+import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
+import {IERC20Metadata} from "@openzeppelin/contracts/interfaces/IERC20Metadata.sol";
+import {IERC6372} from "@openzeppelin/contracts/interfaces/IERC6372.sol";
+import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IVotesEnumerable} from "src/diamond/facets/governance/votes/enumerable/IVotesEnumerable.sol";
+
+// libraries
+
+import {VotesEnumerableLib} from "src/diamond/facets/governance/votes/enumerable/VotesEnumerableLib.sol";
+import {TokenInflationLib} from "src/tokens/towns/mainnet/libs/TokenInflationLib.sol";
+import {BasisPoints} from "src/utils/libraries/BasisPoints.sol";
+
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {OwnableRoles} from "solady/auth/OwnableRoles.sol";
+
+// contracts
+import {IntrospectionBase} from "@towns-protocol/diamond/src/facets/introspection/IntrospectionBase.sol";
+import {VotesEnumerable} from "src/diamond/facets/governance/votes/enumerable/VotesEnumerable.sol";
+import {ERC20Votes} from "solady/tokens/ERC20Votes.sol";
+
+contract Towns is OwnableRoles, ERC20Votes, IntrospectionBase, VotesEnumerable, ITowns, IERC165 {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                  Constants & Immutables                    */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice The name of the token
+    string internal constant NAME = "Towns";
+
+    /// @notice The symbol of the token
+    string internal constant SYMBOL = "TOWNS";
+
+    /// @notice The name hash of the token
+    bytes32 internal constant NAME_HASH = keccak256(bytes(NAME));
+
+    /// @dev initial supply is 10 billion tokens
+    uint256 internal constant INITIAL_SUPPLY = 10_000_000_000 ether;
+
+    /// @dev the role for the inflation caller
+    uint256 public constant ROLE_INFLATION_MANAGER = 1;
+
+    /// @dev the role for the inflation rate manager
+    uint256 public constant ROLE_INFLATION_RATE_MANAGER = 2;
+
+    /// @dev the initial mint time
+    uint256 public immutable initialMintTime;
+
+    /// @dev whether the initial supply has been minted
+    bool internal initialSupplyMinted;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Constructor                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    constructor(address vault, address manager, InflationConfig memory config) {
+        if (vault == address(0) || manager == address(0)) {
+            CustomRevert.revertWith(InvalidAddress.selector);
+        }
+
+        if (config.inflationReceiver == address(0)) {
+            CustomRevert.revertWith(InvalidAddress.selector);
+        }
+
+        _initializeOwner(vault);
+
+        _grantRoles(vault, ROLE_INFLATION_MANAGER);
+        _grantRoles(manager, ROLE_INFLATION_RATE_MANAGER);
+
+        _addInterface(type(ITowns).interfaceId);
+        _addInterface(type(IERC20).interfaceId);
+        _addInterface(type(IERC20Metadata).interfaceId);
+        _addInterface(type(IERC20Permit).interfaceId);
+        _addInterface(type(IVotesEnumerable).interfaceId);
+        _addInterface(type(IERC165).interfaceId);
+        _addInterface(type(IVotes).interfaceId);
+        _addInterface(type(IERC6372).interfaceId);
+
+        initialMintTime = config.initialMintTime;
+
+        TokenInflationLib.initialize(config);
+    }
+
+    /// @notice Mints the initial supply to the given address
+    /// @dev Can only be called by the owner
+    /// @dev Can only be called once
+    function mintInitialSupply(address to) external onlyOwner {
+        if (initialSupplyMinted) {
+            CustomRevert.revertWith(InitialSupplyAlreadyMinted.selector);
+        }
+
+        _mint(to, INITIAL_SUPPLY);
+        initialSupplyMinted = true;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           Inflation                        */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice The final inflation rate in basis points (0-10_000)
+    function finalInflationRate() external view returns (uint256) {
+        return TokenInflationLib.finalInflationRate();
+    }
+
+    /// @notice The address that receives the inflation
+    function inflationReceiver() external view returns (address) {
+        return TokenInflationLib.inflationReceiver();
+    }
+
+    /// @notice The last time the inflation was minted
+    function lastMintTime() external view returns (uint256) {
+        return TokenInflationLib.lastMintTime();
+    }
+
+    /// @notice The current inflation rate in basis points (0-10_000)
+    function currentInflationRate() external view returns (uint256) {
+        return TokenInflationLib.getCurrentInflationRateBPS(initialMintTime);
+    }
+
+    /// @inheritdoc ITowns
+    function setOverrideInflation(
+        bool overrideInflation,
+        uint256 overrideInflationRate
+    ) external onlyRoles(ROLE_INFLATION_RATE_MANAGER) {
+        if (overrideInflationRate > TokenInflationLib.finalInflationRate()) {
+            CustomRevert.revertWith(InvalidInflationRate.selector);
+        }
+
+        TokenInflationLib.setOverrideInflation(overrideInflation, overrideInflationRate);
+    }
+
+    /// @inheritdoc ITowns
+    function setInflationReceiver(address receiver) external onlyRoles(ROLE_INFLATION_MANAGER) {
+        if (receiver == address(0)) {
+            CustomRevert.revertWith(InvalidAddress.selector);
+        }
+
+        TokenInflationLib.setInflationReceiver(receiver);
+    }
+
+    /// @inheritdoc ITowns
+    function createInflation() external onlyRoles(ROLE_INFLATION_MANAGER) {
+        // verify that minting can only happen once per year
+        uint256 timeSinceLastMint = block.timestamp - TokenInflationLib.lastMintTime();
+
+        if (timeSinceLastMint < 365 days) {
+            CustomRevert.revertWith(MintingTooSoon.selector);
+        }
+
+        uint256 inflationRateBPS = TokenInflationLib.getCurrentInflationRateBPS(initialMintTime);
+        uint256 inflationAmount = BasisPoints.calculate(totalSupply(), inflationRateBPS);
+
+        address receiver = TokenInflationLib.inflationReceiver();
+        _mint(receiver, inflationAmount);
+
+        TokenInflationLib.updateLastMintTime();
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     Introspection                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IERC165
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return _supportsInterface(interfaceId);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         Overrides                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    function name() public pure override returns (string memory) {
+        return NAME;
+    }
+
+    function symbol() public pure override returns (string memory) {
+        return SYMBOL;
+    }
+
+    /// @notice Clock used for flagging checkpoints, overridden to implement timestamp based
+    /// checkpoints (and voting).
+    function clock() public view override returns (uint48) {
+        return uint48(block.timestamp);
+    }
+
+    /// @notice Machine-readable description of the clock as specified in EIP-6372.
+    function CLOCK_MODE() public pure override returns (string memory) {
+        return "mode=timestamp";
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                     Internal Overrides                     */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Override the name hash to be a constant value for performance in EIP-712
+    function _constantNameHash() internal pure override returns (bytes32) {
+        return NAME_HASH;
+    }
+
+    /// @dev This allows Permit2 to be used without prior approval.
+    function _givePermit2InfiniteAllowance() internal pure override returns (bool) {
+        return true;
+    }
+
+    /// @dev Override the delegate function to update the delegators and delegation time
+    function _delegate(address account, address delegatee) internal override {
+        address currentDelegatee = delegates(account);
+
+        super._delegate(account, delegatee);
+
+        VotesEnumerableLib.setDelegators(account, delegatee, currentDelegatee);
+    }
+}

package/src/tokens/towns/mainnet/libs/TokenInflationLib.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+import {ITownsBase} from "src/tokens/towns/mainnet/ITowns.sol";
+
+// libraries
+
+// contracts
+
+library TokenInflationLib {
+    struct Layout {
+        uint256 lastMintTime;
+        address inflationReceiver;
+        uint256 initialInflationRate;
+        uint256 finalInflationRate;
+        uint256 inflationDecayRate;
+        uint256 finalInflationYears;
+        bool overrideInflation;
+        uint256 overrideInflationRate;
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("tokens.towns.mainnet.lib.storage")) - 1)) &
+    // ~bytes32(uint256(0xff))
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = 0x366bbacac8c1291905a47c4b12670e7c8ce975e09c84414dddf77ba98c85af00;
+        assembly {
+            l.slot := slot
+        }
+    }
+
+    function initialize(ITownsBase.InflationConfig memory config) internal {
+        Layout storage ds = layout();
+        ds.lastMintTime = config.initialMintTime;
+        ds.inflationReceiver = config.inflationReceiver;
+        ds.initialInflationRate = config.initialInflationRate;
+        ds.finalInflationRate = config.finalInflationRate;
+        ds.inflationDecayRate = config.inflationDecayRate;
+        ds.finalInflationYears = config.finalInflationYears;
+    }
+
+    function finalInflationRate() internal view returns (uint256) {
+        return layout().finalInflationRate;
+    }
+
+    function inflationReceiver() internal view returns (address) {
+        return layout().inflationReceiver;
+    }
+
+    function lastMintTime() internal view returns (uint256) {
+        return layout().lastMintTime;
+    }
+
+    function setInflationReceiver(address receiver) internal {
+        layout().inflationReceiver = receiver;
+    }
+
+    function updateLastMintTime() internal {
+        layout().lastMintTime = block.timestamp;
+    }
+
+    function setOverrideInflation(
+        bool overrideInflation,
+        uint256 overrideInflationRateBps
+    ) internal {
+        layout().overrideInflation = overrideInflation;
+        layout().overrideInflationRate = overrideInflationRateBps;
+    }
+
+    /**
+     * @dev Returns the current inflation rate.
+     * @return inflation rate in basis points (0-10_000)
+     */
+    function getCurrentInflationRateBPS(uint256 initialMintTime) internal view returns (uint256) {
+        Layout storage ds = layout();
+
+        if (ds.overrideInflation) return ds.overrideInflationRate; // override inflation rate
+
+        uint256 yearsSinceInitialMint = (block.timestamp - initialMintTime) / 365 days;
+
+        if (yearsSinceInitialMint >= ds.finalInflationYears) {
+            return ds.finalInflationRate;
+        }
+
+        uint256 inflationRateDecrease = (yearsSinceInitialMint * ds.inflationDecayRate) /
+            ds.finalInflationYears;
+        return ds.initialInflationRate - inflationRateDecrease;
+    }
+}

package/src/tokens/towns/multichain/Towns.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {OFT} from "@layerzerolabs/oft-evm/contracts/OFT.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+contract Towns is OFT {
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _lzEndpoint,
+        address _owner
+    ) OFT(_name, _symbol, _lzEndpoint, _owner) Ownable(_owner) {}
+}

package/src/tokens/towns/multichain/wTowns.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+import {OFTAdapter} from "@layerzerolabs/oft-evm/contracts/OFTAdapter.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+
+contract wTowns is OFTAdapter {
+    constructor(
+        address _token,
+        address _lzEndpoint,
+        address _owner
+    ) OFTAdapter(_token, _lzEndpoint, _owner) Ownable(_owner) {}
+}

package/src/utils/Airdrop.sol

@@ -0,0 +1,156 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+// interfaces
+
+// libraries
+
+// contracts
+
+/**
+ * @title Airdrop
+ * @notice highly optimized airdrop contract
+ */
+contract Airdrop {
+    /// @notice Airdrop ERC721 tokens to a list of addresses
+    /// @param nft The address of the ERC721 contract
+    /// @param addresses The addresses to airdrop to
+    /// @param tokenIds The tokenIds to airdrop
+    function airdropERC721(
+        address nft,
+        address[] calldata addresses,
+        uint256[] calldata tokenIds
+    ) external payable {
+        assembly {
+            // Check that the number of addresses matches the number of tokenIds
+            if iszero(eq(tokenIds.length, addresses.length)) {
+                revert(0, 0)
+            }
+            // transferFrom(address from, address to, uint256 tokenId)
+            mstore(0x00, hex"23b872dd")
+            // from address
+            mstore(0x04, caller())
+
+            // end of array
+            let end := add(addresses.offset, shl(5, addresses.length))
+            // diff = addresses.offset - tokenIds.offset
+            let diff := sub(addresses.offset, tokenIds.offset)
+
+            // Loop through the addresses
+            for {
+                let addressOffset := addresses.offset
+            } 1 {} {
+                // to address
+                mstore(0x24, calldataload(addressOffset))
+                // tokenId
+                mstore(0x44, calldataload(sub(addressOffset, diff)))
+                // transfer the token
+                if iszero(call(gas(), nft, 0, 0x00, 0x64, 0, 0)) {
+                    revert(0, 0)
+                }
+                // increment the address offset
+                addressOffset := add(addressOffset, 0x20)
+                // if addressOffset >= end, break
+                if iszero(lt(addressOffset, end)) {
+                    break
+                }
+            }
+        }
+    }
+
+    /// @notice Airdrop ERC20 tokens to a list of addresses
+    /// @param token The address of the ERC20 contract
+    /// @param addresses The addresses to airdrop to
+    /// @param amounts The amounts to airdrop
+    /// @param totalAmount The total amount to airdrop
+    function airdropERC20(
+        address token,
+        address[] calldata addresses,
+        uint256[] calldata amounts,
+        uint256 totalAmount
+    ) external payable {
+        assembly {
+            // Check that the number of addresses matches the number of amounts
+            if iszero(eq(amounts.length, addresses.length)) {
+                revert(0, 0)
+            }
+
+            // transferFrom(address from, address to, uint256 amount)
+            mstore(0x00, hex"23b872dd")
+            // from address
+            mstore(0x04, caller())
+            // to address (this contract)
+            mstore(0x24, address())
+            // total amount
+            mstore(0x44, totalAmount)
+
+            // transfer total amount to this contract
+            if iszero(call(gas(), token, 0, 0x00, 0x64, 0, 0)) {
+                revert(0, 0)
+            }
+
+            // transfer(address to, uint256 value)
+            mstore(0x00, hex"a9059cbb")
+
+            // end of array
+            let end := add(addresses.offset, shl(5, addresses.length))
+            // diff = addresses.offset - amounts.offset
+            let diff := sub(addresses.offset, amounts.offset)
+
+            // Loop through the addresses
+            for {
+                let addressOffset := addresses.offset
+            } 1 {} {
+                // to address
+                mstore(0x04, calldataload(addressOffset))
+                // amount
+                mstore(0x24, calldataload(sub(addressOffset, diff)))
+                // transfer the tokens
+                if iszero(call(gas(), token, 0, 0x00, 0x64, 0, 0)) {
+                    revert(0, 0)
+                }
+                // increment the address offset
+                addressOffset := add(addressOffset, 0x20)
+                // if addressOffset >= end, break
+                if iszero(lt(addressOffset, end)) {
+                    break
+                }
+            }
+        }
+    }
+
+    /// @notice Airdrop ETH to a list of addresses
+    /// @param addresses The addresses to airdrop to
+    /// @param amounts The amounts to airdrop
+    function airdropETH(address[] calldata addresses, uint256[] calldata amounts) external payable {
+        assembly {
+            // Check that the number of addresses matches the number of amounts
+            if iszero(eq(amounts.length, addresses.length)) {
+                revert(0, 0)
+            }
+
+            // iterator
+            let i := addresses.offset
+            // end of array
+            let end := add(i, shl(5, addresses.length))
+            // diff = addresses.offset - amounts.offset
+            let diff := sub(amounts.offset, addresses.offset)
+
+            // Loop through the addresses
+            for {} 1 {} {
+                // transfer the ETH
+                if iszero(
+                    call(gas(), calldataload(i), calldataload(add(i, diff)), 0x00, 0x00, 0x00, 0x00)
+                ) {
+                    revert(0x00, 0x00)
+                }
+                // increment the iterator
+                i := add(i, 0x20)
+                // if i >= end, break
+                if eq(end, i) {
+                    break
+                }
+            }
+        }
+    }
+}

package/src/utils/airdrop/merkle/IMerkleAirdrop.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// interfaces
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+// libraries
+
+// contracts
+interface IMerkleAirdropBase {
+    error MerkleAirdrop__InvalidProof();
+    error MerkleAirdrop__AlreadyClaimed();
+    error MerkleAirdrop__InvalidSignature();
+
+    event Claimed(address account, uint256 amount, address recipient);
+    event MerkleRootUpdated(bytes32 merkleRoot);
+
+    struct AirdropClaim {
+        address account;
+        uint256 amount;
+        address receiver;
+    }
+}
+
+interface IMerkleAirdrop is IMerkleAirdropBase {
+    /// @notice Computes the hash of the EIP-712 typed data for an airdrop claim
+    /// @param account The address of the account claiming the airdrop
+    /// @param amount The amount of tokens to be claimed
+    /// @return The computed message hash
+    function getMessageHash(
+        address account,
+        uint256 amount,
+        address receiver
+    ) external view returns (bytes32);
+
+    /// @notice Retrieves the current Merkle root used for verifying claims
+    /// @return The current Merkle root
+    function getMerkleRoot() external view returns (bytes32);
+
+    /// @notice Gets the ERC20 token used for the airdrop
+    /// @return The IERC20 interface of the airdrop token
+    function getToken() external view returns (IERC20);
+
+    /// @notice Allows a user to claim their airdrop tokens
+    /// @param account The address of the account claiming the airdrop
+    /// @param amount The amount of tokens to be claimed
+    /// @param merkleProof The merkle proof for the claim
+    /// @param signature The EIP-712 signature authorizing the claim
+    function claim(
+        address account,
+        uint256 amount,
+        bytes32[] calldata merkleProof,
+        bytes calldata signature,
+        address receiver
+    ) external;
+}