multisend ERC20 tokens

Question

I have main address: const fromAddress

There is also an array of addresses and their keys:foreth/keys

I need to send all erc20 tokens from: foreth array to the: fromAddress

Tokens are sent only from the first address of the foreth array, a hash is generated for all subsequent addresses, which is not on etherscan with error: Sorry, We are unable to locate this TxnHash

It is necessary to make sure that tokens are sent from all addresses that are in the array foreth

let tokenAddress = "erc20_contract_addr";
let fromAddress = 'main_addr'
let privateKey = Buffer.from('key_main_addr', 'hex')

const contractInstance = new web3.eth.Contract(minABI, tokenAddress)
let foreth = ["addr1", "addr2", "addr3", "addr4"];
let keys = ['addr1_key', 'addr2_key', 'addr3_key', 'addr4_key']

function nonce_addr(address) {
    return web3.eth.getTransactionCount(address)
}

foreth.forEach(async function(recipient, i) {

    const balance = await contractInstance.methods.balanceOf(recipient).call(function(err, result) {
        let contract = new web3.eth.Contract(minABI, tokenAddress, {
            from: recipient
        })

        if (result < 0) return
        web3.eth.getTransactionCount(fromAddress)
            .then((count) => {
                let rawTransaction = {
                    'from': fromAddress,
                    'gasPrice': web3.utils.toHex(20 * 1e9),
                    'gasLimit': web3.utils.toHex(21000),
                    'to': recipient,
                    'value': web3.utils.toHex(web3.utils.toWei("0.0008")),
                    'nonce': web3.utils.toHex(count + i)
                }
                let transaction = new Tx(rawTransaction)
                transaction.sign(privateKey)
                return new Promise((resolve, reject) => {
                    web3.eth.sendSignedTransaction('0x' + transaction.serialize().toString('hex'))
                        .on('transactionHash', console.log)
                        .on('receipt', resolve)
                        .on('error', reject)
                })
            }).then(receipt => {
                console.log("eth was send")

                keys.forEach(async function(keys) {
                    let nonce = await web3.eth.getTransactionCount(recipient, 'pending');

                    let rawTransaction = {
                        'from': recipient,
                        'gasPrice': web3.utils.toHex(20 * 1e9),
                        'gasLimit': web3.utils.toHex(100000),
                        'to': tokenAddress,
                        'value': 0x0,
                        'data': contract.methods.transfer(fromAddress, web3.utils.toHex(result)).encodeABI(),
                        'nonce': web3.utils.toHex(nonce)
                    }
                    nonce++
                    let transaction = new Tx(rawTransaction)
                    transaction.sign(Buffer.from(keys, 'hex'))
                    let serializedTx = '0x' + transaction.serialize().toString('hex')
                    return new Promise(resolve => {
                        web3.eth.sendSignedTransaction(serializedTx)
                            .on('transactionHash', console.log)

                    })
                })


            })
    })

})

Answer 1

well, this:

'nonce': web3.utils.toHex(count + k)

is unlikely to work. Each account has a separate nonce. So, if all the accounts here had, say, nonce = 2, then each nonce would need to be 3, not 3, 4, 5 etc...

you can find the current nonce of an account using web3.eth.getTransactionCount(accountAddress)

and then add one to it. You need to do this for each address.

Note that this will not necessarily be accurate if there are pending transactions against the accounts. Welcome to the wonderful world of managing Ethereum nonces!

Answer 2

You may also need to add pending flag to getTransactionCount.this flag also includes unconfirmed transactions in transaction count, which is important in your case.

I haven't tested but following code (roughly written) should work:

const testStackCode = async() => {
  let fromAddress = ''
  const contractInstance = new web3.eth.Contract(minABI, contractAddress)
  let foreth = []
  let keys = []

  for(let i=0; i< foreth.length; i++) {
    let recipeint = foreth[i]
    let balance = await contractInstance.methods.balanceOf(recipeint).call()
    if(balance < 0 ) continue
    key = keys[i]
    let nonce = await web3.eth.getTransactionCount(recipeint, 'pending');
    let extraData = contractInstance.methods.transfer(fromAddress, balance);
    let data = extraData.encodeABI()
    let txParams = {
      to: contractAddress,
      data,
      value: web3.utils.toHex(0),
      nonce: web3.utils.toHex(nonce)

    }
    console.log({ from: recipeint, to: fromAddress, nonce, amount: balance})
    var tx = new Tx(txParams)
    let privKey = _validatePrivKey(key)
    privKey = new Buffer(privKey, 'hex')
    tx.sign(privKey)
    let serializedTx = '0x' + tx.serialize().toString('hex')
    await submitSignedTx(serializedTx)
  }
}

function _validatePrivKey(privKey){
  if(privKey.startsWith('0x')) privKey = privKey.substr(2)
  return privKey
}

const submitSignedTx = async(serializedTx) => {
  try{
    return new Promise((fullfill, reject) => {
      web3.eth.sendSignedTransaction(serializedTx)
        .on('transactionHash', txHash => {
         console.log(logmsg, 'transaction sent. hash =>', txHash)
          return fullfill({success: true, txHash : txHash})
        })
        .on('error', e => {
          console.log('unable to send tx', e);
          return fullfill({success: false, message: e})
        })
    })
  } catch(e){
    console.log(e)
    return {success: false, message: e.message };
  }
}