Airdrop

[
  {
    "inputs": [],
    "name": "EtherTransferFailed",
    "type": "error"
  },
  {
    "inputs": [],
    "name": "InsufficientEther",
    "type": "error"
  },
  {
    "inputs": [],
    "name": "InvalidArrays",
    "type": "error"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "token",
        "type": "address"
      }
    ],
    "name": "SafeERC20FailedOperation",
    "type": "error"
  },
  {
    "inputs": [
      {
        "internalType": "address[]",
        "name": "recipients",
        "type": "address[]"
      },
      {
        "internalType": "uint256[]",
        "name": "values",
        "type": "uint256[]"
      }
    ],
    "name": "airdropEther",
    "outputs": [],
    "stateMutability": "payable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "contract IERC20",
        "name": "token",
        "type": "address"
      },
      {
        "internalType": "address[]",
        "name": "recipients",
        "type": "address[]"
      },
      {
        "internalType": "uint256[]",
        "name": "values",
        "type": "uint256[]"
      }
    ],
    "name": "airdropToken",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "contract IERC20",
        "name": "token",
        "type": "address"
      },
      {
        "internalType": "address[]",
        "name": "recipients",
        "type": "address[]"
      },
      {
        "internalType": "uint256[]",
        "name": "values",
        "type": "uint256[]"
      }
    ],
    "name": "airdropTokenSimple",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  }
]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract Airdrop {
    using SafeERC20 for IERC20;

    error InvalidArrays();
    error InsufficientEther();
    error EtherTransferFailed();

    function airdropEther(
        address[] calldata recipients,
        uint256[] calldata values
    ) external payable {
        _validate(recipients.length, values.length);

        uint256 total = _sum(values);
        if (msg.value < total) revert InsufficientEther();

        for (uint256 i; i < recipients.length; ++i) {
            (bool success,) = payable(recipients[i]).call{value: values[i]}("");
            if (!success) revert EtherTransferFailed();
        }

        uint256 refund = msg.value - total;
        if (refund != 0) {
            (bool success,) = payable(msg.sender).call{value: refund}("");
            if (!success) revert EtherTransferFailed();
        }
    }

    function airdropToken(
        IERC20 token,
        address[] calldata recipients,
        uint256[] calldata values
    ) external {
        _validate(recipients.length, values.length);

        token.safeTransferFrom(msg.sender, address(this), _sum(values));

        for (uint256 i; i < recipients.length; ++i)
            token.safeTransfer(recipients[i], values[i]);
    }

    function airdropTokenSimple(
        IERC20 token,
        address[] calldata recipients,
        uint256[] calldata values
    ) external {
        _validate(recipients.length, values.length);

        for (uint256 i; i < recipients.length; ++i)
            token.safeTransferFrom(msg.sender, recipients[i], values[i]);
    }

    function _sum(uint256[] calldata values) private pure returns (uint256 total) {
        for (uint256 i; i < values.length; ++i) total += values[i];
    }

    function _validate(uint256 recipients, uint256 values) private pure {
        if (recipients == 0 || recipients != values) revert InvalidArrays();
    }
}