Airdrop Updates

The claim fee is now stored inside each allocation leaf and used directly during withdrawals without any on-chain maximum. The allocation struct includes a claimFee field and the withdrawal flow uses that value to compute the required ETH, so the contract will enforce whatever fee is encoded in the merkle tree. This removes the previous on-chain guardrail and shifts correctness to off-chain tooling and UI expectations, because the contract only compares claimFee against msg.value and does not validate bounds.

struct Allocation {
    string id;
    address originalBeneficiary;
    uint256 totalAllocation;
    bool cancelable;
    bool revokable;
    bool transferableByAdmin;
    bool transferableByBeneficiary;
    uint256 claimFee;
    bytes extraData;
}

modifier checkFee(string memory allocationId, uint256 claimFee) {
    uint256 expectedFee = getClaimFee(allocationId, claimFee);
    if (expectedFee > 0) {
        transientFeeIncurred += expectedFee;
        require(transientFeeReceived >= transientFeeIncurred, TooSmallFeeAmountSent());
    }
    _;
}

function getClaimFee(string memory allocationId, uint256 claimFee) public view returns (uint256) {
    if (shouldPayClaimFeeOnlyOnce && feeAlreadyPayed[allocationId]) {
        return 0;
    } else {
        return claimFee;
    }
}

Impact: Users can be economically blocked from claiming if fees are set unreasonably high and the contract provides no on-chain protection against excessive fees.

Consider introducing an on-chain guardrail by enforcing a maximum fee, either as an absolute cap or as a percentage of the allocation size, and validate claimFee against it during withdrawal or merkle root acceptance. If the design intentionally relies on off-chain checks, add explicit governance approval for fee changes and ensure the UI and tooling reject out-of-policy claimFee values before roots are published.

The getClaimFee function now requires the caller to provide a claimFee value as an input parameter. As a result, the function can no longer be used to derive the claim fee for a given allocationId by itself. This removes the ability for integrators or users to query the correct claim fee directly from the contract.

Consider adding a view function that derives and returns the correct claim fee for a given allocationId, allowing callers to query the expected fee without prior knowledge.