eth_sendRawTransaction | Aurora

const { Web3 } = require("web3");

// Initialize Web3 instance using a provider
const web3 = new Web3(
  new Web3.providers.HttpProvider("YOUR_CHAINSTACK_RPC_NODE")
);

/**
 * Sends a specified amount from a given account to another.
 *
 * @param {string} secretKey The private key of the sender's account.
 * @param {string} to The recipient address.
 * @param {string} amount The amount to send in Ether.
 */
async function sendAmount(secretKey, to, amount) {
  const account = web3.eth.accounts.privateKeyToAccount(secretKey);
  web3.eth.accounts.wallet.add(account);
  const senderAddress = account.address;
  console.log(
    `Attempting to send ${amount} ETH from ${senderAddress} to ${to}`
  );

  const MAX_RETRIES = 3; // Maximum number of retries
  const COOLDOWN = 5000; // Time waited between retries in ms

  let retries = 0; // Initialize retry counter

  async function sendTransaction() {
    try {
      const balance = await web3.eth.getBalance(senderAddress);
      console.log(
        `Current balance: ${web3.utils.fromWei(balance, "ether")} ETH`
      );

      const gasPrice = await web3.eth.getGasPrice();
      console.log(
        `Current gas price: ${web3.utils.fromWei(gasPrice, "gwei")} Gwei`
      );

      const gasLimit = await web3.eth.estimateGas({
        from: senderAddress,
        to: to,
        value: web3.utils.toWei(amount, "ether"),
      });
      console.log(`Estimated gas limit: ${gasLimit}`);

      const gasCost = BigInt(gasPrice) * BigInt(gasLimit);
      console.log(
        `Estimated gas cost: ${web3.utils.fromWei(
          gasCost.toString(),
          "ether"
        )} ETH`
      );

      const amountToSend = web3.utils.toWei(amount, "ether");
      const totalCost = BigInt(amountToSend) + gasCost;

      if (BigInt(balance) >= totalCost) {
        console.log(`Amount to send: ${amount} ETH`);

        const transaction = {
          to: to,
          value: amountToSend,
          gas: gasLimit,
          gasPrice: gasPrice,
          nonce: await web3.eth.getTransactionCount(senderAddress, "latest"),
        };

        console.log("Signing transaction...");
        const signedTx = await account.signTransaction(transaction);

        console.log("Transaction signed. Sending...");
        const receipt = await web3.eth.sendSignedTransaction(
          signedTx.rawTransaction
        );

        console.log(
          `Transaction successful with hash: ${receipt.transactionHash}`
        );
        console.log(
          `Find the transaction in the explorer: https://sepolia.etherscan.io/tx/${receipt.transactionHash}`
        );
      } else {
        console.log(
          "Not enough balance to cover the transaction cost. Transaction aborted."
        );
      }
    } catch (error) {
      console.error(`Failed to send transaction: ${error.message}`);

      if (retries < MAX_RETRIES) {
        retries++;
        console.log(`Retrying... (${retries}/${MAX_RETRIES})`);
        await new Promise((resolve) => setTimeout(resolve, COOLDOWN)); // Wait for 5 seconds before retrying
        await sendTransaction(); // Retry the transaction
      } else {
        console.error("Maximum retries reached. Giving up.");
      }
    }
  }

  await sendTransaction();
}

// Replace with your secret key, recipient address, and the amount to send
const secretKey = "0x_YOUR_PRIVATE_KEY";
const recipientAddress = "DESTINATION_ADDRESS";
const amountToSend = "1.0"; // Amount in Ether

sendAmount(secretKey, recipientAddress, amountToSend);