sendERC20

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract TestERC20 is ERC20 {
    constructor(uint256 initialSupply) ERC20("TestERC20", "TEST") {
        _mint(msg.sender, initialSupply);
    }
}

import { ethers } from 'hardhat';

// npx hardhat run scripts/deployTestERC20.ts --network sepolia
// npx hardhat verify --network sepolia --contract contracts/TestERC20.sol:TestERC20 0x604E24d924322CBEc1D4063DbDB410975b41473a "1000000000000000000000000000"
// https://sepolia.etherscan.io/address/0x604E24d924322CBEc1D4063DbDB410975b41473a#writeContract

async function main() {
  const ERC20 = await ethers.getContractFactory("TestERC20");
  const erc20 = await ERC20.deploy("1000000000000000000000000000");
  await erc20.deployed();
  console.log(`TestERC20 deployed to: https://sepolia.etherscan.io/address/${erc20.address}`)
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

 /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");

function sendERC20(
        address tokenAddress,
        SendRequest[] calldata sendRequests
    ) external {
        IERC20 token = IERC20(tokenAddress);
        for (uint256 i = 0; i < sendRequests.length; i++) {
            // token.safeIncreaseAllowance(address(this), sendRequests[i].amount);
            token.safeTransferFrom(
                msg.sender,
                sendRequests[i].to,
                sendRequests[i].amount
            );
            // emit ERC20TokenTransfer(sendRequests[i].to, sendRequests[i].amount);
        }
    }

    function sendERC20(
        address tokenAddress,
        SendRequest[] calldata sendRequests
    ) external {
        IERC20 token = IERC20(tokenAddress);
        for (uint256 i = 0; i < sendRequests.length; i++) {
            token.transfer(
                sendRequests[i].to,
                sendRequests[i].amount
            );
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

token.transfer(
    sendRequests[i].to,
    sendRequests[i].amount
);

    struct SendRequest {
        address payable to;
        uint256 amount;
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    function safeTransferFrom(
        address tokenAddress,
        SendRequest[] calldata sendRequests
    ) external {
        IERC20 token = IERC20(tokenAddress);
        for (uint256 i = 0; i < sendRequests.length; i++) {
            token.safeTransferFrom(
                msg.sender,
                sendRequests[i].to,
                sendRequests[i].amount
            );
        }
    }

  it("should send ERC20 token", async () => {
    const [owner, recipient1, recipient2] = await ethers.getSigners();

    // Deploy TestERC20 token contract
    const TestERC20 = await ethers.getContractFactory("TestERC20");
    const testERC20 = await TestERC20.deploy(ethers.utils.parseEther("1000"));
    await testERC20.deployed();

    // Deploy BulkTransfer contract
    const BulkTransfer = await ethers.getContractFactory("BulkTransfer");
    const bulkTransfer = await BulkTransfer.deploy();
    await bulkTransfer.deployed();
    // Approve the BulkTransfer contract to spend tokens on behalf of the owner
    await testERC20.approve(bulkTransfer.address, ethers.utils.parseEther("1000"));

    // Prepare the send requests
    const sendRequests = [
        { to: recipient1.address, amount: ethers.utils.parseEther("100") },
        { to: recipient2.address, amount: ethers.utils.parseEther("200") }
    ];

    // Execute the bulk transfer
    await bulkTransfer.safeTransferFrom(testERC20.address, sendRequests);

    // Check final balances
    const finalBalanceOwner = await testERC20.balanceOf(owner.address);
    const finalBalanceRecipient1 = await testERC20.balanceOf(recipient1.address);
    const finalBalanceRecipient2 = await testERC20.balanceOf(recipient2.address);

    // Validate the balances
    expect(finalBalanceOwner).to.equal(ethers.utils.parseEther("700"));
    expect(finalBalanceRecipient1).to.equal(ethers.utils.parseEther("100"));
    expect(finalBalanceRecipient2).to.equal(ethers.utils.parseEther("200"));
  });