Nethereum C# automated ether transfer

Question

I wish to automate the transfer of ether to a list of people. Assume the list is in a csv. I wrote some code to automate the process.

 class Program
{
    int nonce = 0;
    static void Main(string[] args)
    {
        var account = SetupAccount();
        var recipients = ReadCsv();
        var web3Init = GetConnection();
        nonce = web3.Eth.Transactions.GetTransactionCount.SendRequestAsync(account.Address).Result;
        //var recipients = new List<Records>() { new Records() { Value = 10000000000000000, Address = "0x5CC494843e3f4AC175A5e730c300b011FAbF2cEa" } };
        foreach (var recipient in recipients)
        {
            try
            {
                var web3 = GetConnection();
                var receipt = SendEther(account, recipient, web3).Result;
            }
            catch (System.Exception)
            {
                MessageBox.Show("Failed");                                        
            }
            Thread.Sleep(30000);
        }
    }

    private static async Task<TransactionReceipt> SendEther(Account account, Records recipient, Web3 web3)
    {
        var transactionPolling = web3.TransactionManager.TransactionReceiptService;

        //var currentBalance = await web3.Eth.GetBalance.SendRequestAsync(account.Address);

        //assumed client is mining already
        //when sending a transaction using an Account, a raw transaction is signed and send using the private key
        return await transactionPolling.SendRequestAndWaitForReceiptAsync(() =>
        {
            var transactionInput = new TransactionInput
            {
                From = account.Address,
                //Gas = new HexBigInteger(25000),
                GasPrice = new HexBigInteger(10 ^ 10),
                To = recipient.Address,
                Value = new HexBigInteger(new BigInteger(recipient.Value)),
                Nonce = nonce
            };
            var txSigned = new Nethereum.Signer.TransactionSigner();
            var signedTx = txSigned.SignTransaction(account.PrivateKey, transactionInput.To, transactionInput.Value, transactionInput.Nonce);
            var transaction = new Nethereum.RPC.Eth.Transactions.EthSendRawTransaction(web3.Client);
            nonce++;
            return transaction.SendRequestAsync(signedTx);
        });
    }

    private static Web3 GetConnection()
    {
        return new Web3("https://mainnet.infura.io");
    }

    private static Account SetupAccount()
    {
        var password = "@Password";
        var accountFilePath = @"filePath";
        return Account.LoadFromKeyStoreFile(accountFilePath, password);
    }

    private static List<Records> ReadCsv()
    {
        string filePath = @"C:\Users\Potti\source\repos\ConversionFiles\XrcfRecipients.csv";
        if (File.Exists(filePath))
        {
            using (StreamReader stream = new StreamReader(filePath))
            {
                CsvReader reader = new CsvReader(stream, new Configuration
                {
                    TrimOptions = TrimOptions.Trim,
                    HasHeaderRecord = true,
                    HeaderValidated = null
                });
                reader.Configuration.RegisterClassMap<RecordMapper>();

                return reader.GetRecords<Records>().ToList();
            }
        }
        else
        {
            return null;
        }
    }
}

class Records
{
    public string Address { get; set; }

    public decimal Value { get; set; }
}

sealed class RecordMapper : ClassMap<Records>
{
    public RecordMapper()
    {
        Map(x => x.Address).Name("Address");
        Map(x => x.Value).Name("Value");
    }
}

How do i modify the process to execute all the transactions at once instead of waiting for each to complete? (Fire and forget) Also, are there any security considerations of doing this?

Answer 1

What you are currently doing is waiting for each transaction to be mined. What you can do is the following:

var account = new Account("privateKey"); // or load it from your keystore file as you are doing.
var web3 = new Web3(account, "https://mainnet.infura.io");

First create a web3 instance using the same Account object, because we are using an account with a private key, Nethereum will sign your transactions offline before sending them.

Now using the TransactionManager, you can then send a transaction per each recepient

var transactionHashes = new List<string>();
foreach(var recepient in recepients){

            var transactionInput = new TransactionInput
            {
                From = account.Address,
                GasPrice = Web3.Convert.ToWei(1.5, UnitConversion.EthUnit.Gwei);,
                To = recipient.Address,
                Value = new HexBigInteger(new BigInteger(recipient.Value)),
            };
     var transactionHash = web3.Eth.TransactionManager.SendTransactionAsync(transactionInput);
     transanctionHashes.Add(transactionHash);
}

Note that when Nethereum uses the same instance of an Account and TransactionManager (or Web3 in this scenario) it creates a default NonceMemoryService, so you don't need to keep track of your nonces (Transaction number), to sign the transaction.

Also I have done a conversion for the GasPrice from Gwei to Wei, as an example of Unit conversions, I assume that you already have converted to Wei the Ether amounts you are going to send.

Finally, another note, to further simplify this, there is an upcoming EtherTransferService which allows you to input Ether amounts and Gwei price amounts to avoid doing conversions. Also the gas price will be calculated for you, if not passed any parameter.

 web3.Eth.GetEtherTransferService().TransferEtherAsync("toAddress", EtherAmount);