const bumpedMaxFee = (originalTx.maxFeePerGas * 112n) / 100n;
const bumpedPriority = (originalTx.maxPriorityFeePerGas * 112n) / 100n;
const maxFeePerGas = bumpedMaxFee > feeData.maxFeePerGas 
  ? bumpedMaxFee : feeData.maxFeePerGas;

import { ethers } from "ethers";
import { NonceManager } from "@ethersproject/experimental";

const provider = new ethers.providers.JsonRpcProvider("http://localhost:8545");
const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
const managed = new NonceManager(wallet);

// Sequential nonces assigned automatically
const tx1 = await managed.sendTransaction({ to: addr1, value: ethers.utils.parseEther("0.01") });
const tx2 = await managed.sendTransaction({ to: addr2, value: ethers.utils.parseEther("0.01") });

import { ethers, NonceManager } from "ethers";

const provider = new ethers.JsonRpcProvider("http://localhost:8545");
const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
const managed = new NonceManager(wallet);

const tx1 = await managed.sendTransaction({ to: addr1, value: ethers.parseEther("0.01") });
const tx2 = await managed.sendTransaction({ to: addr2, value: ethers.parseEther("0.01") });

// Reset forces reload from chain (new in v6)
managed.reset();

// Works identically in v5 and v6 (adjust imports accordingly)
const nonce = await myNonceManager.acquireNonce(wallet.address);

const tx = await wallet.sendTransaction({
  to: recipient,
  value: ethers.parseEther("0.01"),
  nonce: nonce,  // explicit nonce overrides auto-fill
});

// For contract calls, nonce goes in the overrides object
const contract = new ethers.Contract(address, abi, wallet);
await contract.transfer(recipient, amount, { nonce: nonce });

const provider = new ethers.JsonRpcProvider("http://your-node:8545", undefined, {
  staticNetwork: true,     // Skip network auto-detection on each call
  batchMaxCount: 10,       // Batch up to 10 JSON-RPC calls per HTTP request
  batchStallTime: 10,      // Wait 10ms to collect requests before sending
});

┌────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  API Server │────▶│  Transaction    │────▶│  TX Workers     │
│  (accepts   │     │  Queue (Redis/  │     │  (per-wallet    │
│   requests) │     │  BullMQ)        │     │   sequential)   │
└────────────┘     └─────────────────┘     └────────┬────────┘
                                                     │
                   ┌─────────────────┐               │
                   │  Redis Nonce    │◀──────────────┘
                   │  Store          │  INCR atomically
                   │  (per-wallet    │  before signing
                   │   per-chain)    │
                   └─────────────────┘

import Redis from 'ioredis';
import { ethers } from 'ethers';

class RedisNonceManager {
  private redis: Redis;
  private provider: ethers.JsonRpcProvider;

  constructor(redisUrl: string, rpcUrl: string) {
    this.redis = new Redis(redisUrl);
    this.provider = new ethers.JsonRpcProvider(rpcUrl);
  }

  /** Sync nonce from on-chain state. Called on startup or after drift detection. */
  async syncNonce(walletAddress: string): Promise<number> {
    const onchainNonce = await this.provider.getTransactionCount(walletAddress, 'latest');
    const key = `nonce:${walletAddress.toLowerCase()}`;
    
    // Lua script: only update if on-chain nonce is higher than stored value
    const lua = `
      local current = redis.call('GET', KEYS[1])
      if current == false or tonumber(current) < tonumber(ARGV[1]) then
        redis.call('SET', KEYS[1], ARGV[1])
        return ARGV[1]
      end
      return current
    `;
    const result = await this.redis.eval(lua, 1, key, onchainNonce);
    return Number(result);
  }

  /** Atomically acquire next nonce. Lock-free via Lua script. */
  async acquireNonce(walletAddress: string): Promise<number> {
    const key = `nonce:${walletAddress.toLowerCase()}`;
    const lua = `
      local current = redis.call('GET', KEYS[1])
      if current == false then return nil end
      redis.call('SET', KEYS[1], tonumber(current) + 1)
      return current
    `;
    const result = await this.redis.eval(lua, 1, key);
    if (result === null) {
      await this.syncNonce(walletAddress);
      return this.acquireNonce(walletAddress);
    }
    return Number(result);
  }

  /** Recycle nonce if tx failed before broadcast (only if it's the highest). */
  async recycleNonce(walletAddress: string, nonce: number): Promise<void> {
    const key = `nonce:${walletAddress.toLowerCase()}`;
    const lua = `
      local current = tonumber(redis.call('GET', KEYS[1]))
      if current == tonumber(ARGV[1]) + 1 then
        redis.call('SET', KEYS[1], ARGV[1])
        return 1
      end
      return 0
    `;
    await this.redis.eval(lua, 1, key, nonce);
  }
}

async function processTransaction(
  wallet: ethers.Wallet,
  nonceManager: RedisNonceManager,
  txReq: { to: string; data: string; value: bigint; id: string }
): Promise<string> {
  const nonce = await nonceManager.acquireNonce(wallet.address);

  try {
    // Simulate first — failed simulation should NOT consume the nonce
    const tx: ethers.TransactionRequest = {
      to: txReq.to,
      data: txReq.data,
      value: txReq.value,
      nonce,
    };
    await wallet.provider!.estimateGas({ ...tx, from: wallet.address });

    // Sign and send
    const response = await wallet.sendTransaction(tx);
    return response.hash;
  } catch (err: any) {
    // Recycle nonce only if tx was never broadcast to the network
    if (!err.receipt && !err.transactionHash) {
      await nonceManager.recycleNonce(wallet.address, nonce);
    }
    throw err;
  }
}

async function cancelStuckTransaction(
  wallet: ethers.Wallet,
  stuckNonce: number,
  originalMaxFeePerGas: bigint,
  originalMaxPriorityFeePerGas: bigint
): Promise<ethers.TransactionResponse> {
  // Bump by 12% (safely above Geth's 10% minimum)
  const maxFeePerGas = (originalMaxFeePerGas * 112n) / 100n;
  const maxPriorityFeePerGas = (originalMaxPriorityFeePerGas * 112n) / 100n;

  return wallet.sendTransaction({
    to: wallet.address,   // self-transfer = cancellation
    value: 0n,
    nonce: stuckNonce,
    gasLimit: 21000n,
    maxFeePerGas,
    maxPriorityFeePerGas,
    type: 2,
  });
}

async function fillNonceGaps(
  wallet: ethers.Wallet,
  gapNonces: number[]
): Promise<string[]> {
  const feeData = await wallet.provider!.getFeeData();
  const hashes: string[] = [];

  for (const nonce of gapNonces) {
    const tx = await wallet.sendTransaction({
      to: wallet.address,
      value: 0n,
      nonce,
      gasLimit: 21000n,
      maxFeePerGas: feeData.maxFeePerGas! * 2n,
      maxPriorityFeePerGas: feeData.maxPriorityFeePerGas! * 2n,
    });
    hashes.push(tx.hash);
  }
  return hashes;
}