Sending multiple transactions in the same block with incremented nonces

Question

I need to send 0.1 ETH to 10 unique addresses from the same address at the same time. I am manually incrementing each transaction's nonce, and the transactions are sent successfully.

However, each transaction is entered into a new block. For example, transaction A in block 1, B in 2, C in 3, and so on. The problem is that this isn't scalable across n transactions, because I'd have to wait for n blocks to confirm.

Is there a proper way to batch-send ETH so that the collective of transactions confirms as quickly as possible?

Edit: This has only been tested on Kovan. Even with Kovan's 4 second block time, shouldn't transactions sent at the exact same time be included in the same block?

Answer 1

You can write a solidity contract with one method that receives the addresses and the amounts to transfer, and performs the corresponding transfers.

Then you achieve your objective in a single transaction.

For security reasons I recommend to extend the Ownable contract and use the onlyOwner() modifier:

https://docs.openzeppelin.com/contracts/4.x/api/access#Ownable

:)

Answer 2

I have been playing around with a similar thing however, on the ropsten network and i get multiple transactions in the same block when testing with sending 100 transactions. I have written the following function that allows me to send an arbitrary amount of transactions to my smart contract at the same time. Perhaps this could be re-purposed for your needs?

async function multipleTx(n) {
  accounts = await web3.eth.getAccounts()
  for (let i = 0; i < n; i++) {
    instance.methods
      .addSubmission(i, i, i, i)
      .send({
        from: accounts[0],
        gasPrice: 10000000000,
      })
      .then((receipt) => {
        console.log(receipt)
      })
  }
}

Answer 3

All web3.eth.send() calls automatically increment nonce by your wallet (what wallet provider you are using for this?).

You can simply fire out as many web3.eth.send() calls or contract calls as possible and then await them as Promise.all() to resolve. Miners will fill your transactions in block and try to fit as many transactions, yours or otheres, in a block as possible.