A universal handle transaction method?

[Benjythebee]

Can we all work together and come up with an almost perfect method that handles a transaction?
By "almost perfectly handles a transaction" I mean:

• Waits for transaction to be mined.
• Resolves or at leasts timeouts (tx.wait() never resolves #945 somehow is still relevant on Polygon like 3 times out of 10)
• Handles repricing and cancellations
• Handles successful transactions

I've come up with my own little handler in typescript, but it's not perfect given I still get issues with it.
I'm sure some of you have better ideas and stricter types.
I'd love for us to end up with a method that receives an ethers transaction and handles every case.

Here is my contribution to start things:

type txError = {
  hash?: string
  reason?: 'repriced' | 'cancelled' | 'replaced'
  cancelled?: boolean
  replacement?: ethers.providers.TransactionResponse
  receipt?: ethers.providers.TransactionReceipt
}
export async function handleTransaction(transaction: any) {
  let tx

  const awaitTransaction = async (trans: ethers.providers.TransactionResponse) => {
    let tx: ethers.providers.TransactionReceipt
    try {
      tx = await trans.wait(1)
    } catch (error: any) {
      const e = error as txError
      // @see https://docs.ethers.io/v5/api/providers/types/#providers-TransactionResponse
      if ((e.reason == 'replaced' || e.reason == 'repriced') && e.replacement) {
        tx = await awaitTransaction(e.replacement)
      } else if (e.reason == 'cancelled') {
        throw new Error('Transaction cancelled')
      } else {
        throw new Error(e.reason || e?.toString())
      }
    }
    return tx
  }

  tx = await awaitTransaction(transaction)

  return tx
}

Example Use:

    let transaction;
    try {
      transaction = await contract.method()

    } catch (e: any) {
      if (e.code == 4001) {
       // User refused transaction.
       console.error(e)
      }
      console.error(e)
    }
    
    let tx;
    try {
      tx = await handleTransaction(transaction)
    } catch (e) {
      console.error(e)
      return
    }
    // tx should be an etherjs tx receipt