How to Batch Multiple ETH Transfers in One Transaction Using Solidity

·

In the fast-evolving world of blockchain development, efficiency is key. One of the most common challenges developers face is reducing gas costs when executing multiple Ethereum (ETH) transfers. Sending ETH to several addresses individually can be expensive and inefficient. Fortunately, with Solidity and tools like the OpenZeppelin Address library, you can batch multiple ETH transfers into a single transaction—saving both time and gas.

This guide walks you through building a smart contract that enables batch ETH transfers, leveraging best practices in gas optimization, payable functions, and address manipulation. Whether you're building decentralized applications (dApps), managing airdrops, or handling payroll on-chain, this technique is invaluable.

Understanding Batch ETH Transfers

Batching transactions means combining multiple operations into one smart contract call. Instead of sending 10 separate transactions to 10 different wallets, you send one transaction that distributes funds to all of them at once. The benefits are clear:

This approach is especially useful for:

👉 Discover how smart contracts can automate financial operations securely and efficiently.

Core Components of the Batch Transfer Contract

To implement batch ETH transfers, we use Solidity along with the OpenZeppelin Address library, which provides safe utilities for handling address types.

Key Concepts Used:

The contract accepts two arrays as input:

  1. An array of recipient wallet addresses
  2. A corresponding array of ETH amounts (in wei)

It then iterates over these arrays and sends ETH using low-level .call() to ensure compatibility with non-contract and contract addresses alike.

Writing the Smart Contract

Here’s a simplified version of the Solidity code:

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

import "@openzeppelin/contracts/utils/Address.sol";

contract BatchTransfer {
    using Address for address payable;

    event BatchSent(address[] recipients, uint256[] amounts);

    receive() external payable {}

    function sendMultipleETH(
        address payable[] memory recipients,
        uint256[] memory amounts
    ) external payable {
        require(recipients.length == amounts.length, "Arrays must match");

        uint256 total = 0;
        for (uint256 i = 0; i < amounts.length; i++) {
            total += amounts[i];
        }
        require(msg.value >= total, "Insufficient ETH sent");

        for (uint256 i = 0; i < recipients.length; i++) {
            (bool sent, ) = recipients[i].call{value: amounts[i]}("");
            require(sent, "Failed to send ETH to recipient");
        }

        emit BatchSent(recipients, amounts);
    }
}

Breakdown of Key Functions

receive() Function

Allows the contract to accept plain ETH transfers without data.

sendMultipleETH() Function

Using .call() avoids the 2300 gas stipend limit of .transfer(), making it safer for sending to smart contracts.

Deployment and Usage on Polygon

Polygon is an ideal testbed for gas-efficient experiments due to its low fees and Ethereum compatibility.

Steps:

  1. Compile the contract using Remix IDE or Hardhat
  2. Deploy on Polygon Mumbai testnet (or mainnet)
  3. Fund the contract with enough MATIC/ETH to cover all transfers
  4. Call sendMultipleETH() with your arrays of addresses and amounts (in wei)
Example: To send 0.1 ETH, use 100000000000000000 wei (10¹⁸ base units).

All transfers execute within the same block, visible under a single transaction hash—proving they were truly batched.

👉 Learn how blockchain platforms streamline multi-wallet transactions with optimized execution.

Gas Optimization Benefits

Batching reduces overhead because:

While exact savings vary, batching 10 transfers can reduce total gas cost by 30–50% compared to individual sends.

Additionally, using OpenZeppelin’s Address library ensures safer interactions, especially when dealing with contract wallets that may not handle .transfer() correctly.

Frequently Asked Questions (FAQ)

Q: Can this contract lose funds if one transfer fails?
A: No—each transfer is isolated. If one fails (e.g., recipient reverts), others still proceed. However, the entire transaction may revert if a require() fails or gas runs out.

Q: Why use .call() instead of .transfer()?
A: .transfer() forwards only 2300 gas, which isn’t enough for complex receiving logic. .call() forwards all available gas, making it more reliable for sending to smart contracts.

Q: Is this method compatible with ERC-20 tokens?
A: Not directly. This contract works with native ETH. For ERC-20 tokens, you’d need approve() and transferFrom() mechanics with an allowance system.

Q: What happens if I send more ETH than needed?
A: The contract currently doesn’t refund excess ETH. You can enhance it by adding a refund mechanism: if (msg.value > total) payable(msg.sender).call{value: msg.value - total}("");

Q: Can I use string-based addresses instead of binary?
A: No—Solidity requires binary address format. You must convert strings off-chain before passing them to the contract.

Best Practices & Security Considerations

When implementing batch transfers:

Also consider implementing access control (e.g., onlyOwner) if only specific entities should trigger transfers.

👉 See how leading platforms optimize blockchain transactions for speed and cost-efficiency.

Final Thoughts

Batching ETH transfers using Solidity and OpenZeppelin is a powerful way to optimize gas usage and simplify multi-recipient payments. By consolidating transactions into a single call, developers can significantly cut costs while improving reliability and scalability.

Whether you're distributing rewards, automating payroll, or managing community funds, this pattern offers a clean, secure solution rooted in modern smart contract design principles.

As blockchain adoption grows, mastering techniques like gas optimization, batch processing, and safe address handling will become essential skills for every developer.

Core Keywords: