@0xsequence/relayer 2.3.35 → 3.0.0-beta.2

package/dist/declarations/src/index.d.ts

@@ -1,42 +0,0 @@
-import { ethers } from 'ethers';
-import { proto } from "./rpc-relayer/index.js";
-import { commons } from '@0xsequence/core';
-export interface Relayer {
-    simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]>;
-    getFeeOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<{
-        options: FeeOption[];
-        quote?: FeeQuote;
-    }>;
-    getFeeOptionsRaw(entrypoint: string, data: ethers.BytesLike, options?: {
-        simulate?: boolean;
-    }): Promise<{
-        options: FeeOption[];
-        quote?: FeeQuote;
-    }>;
-    gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
-    listGasSponsors(args: proto.ListGasSponsorsArgs): Promise<proto.ListGasSponsorsReturn>;
-    addGasSponsor(args: proto.AddGasSponsorArgs): Promise<proto.AddGasSponsorReturn>;
-    updateGasSponsor(args: proto.UpdateGasSponsorArgs): Promise<proto.UpdateGasSponsorReturn>;
-    removeGasSponsor(args: proto.RemoveGasSponsorArgs): Promise<proto.RemoveGasSponsorReturn>;
-    getNonce(address: string, space?: ethers.BigNumberish, blockTag?: ethers.BlockTag): Promise<ethers.BigNumberish>;
-    relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean, projectAccessKey?: string): Promise<commons.transaction.TransactionResponse>;
-    wait(metaTxnId: string | commons.transaction.SignedTransactionBundle, timeout?: number, delay?: number, maxFails?: number): Promise<commons.transaction.TransactionResponse>;
-    getMetaTransactions(projectId: number, page?: proto.Page): Promise<{
-        page: proto.Page;
-        transactions: proto.MetaTxnLog[];
-    }>;
-    getTransactionCost(projectId: number, from: string, to: string): Promise<{
-        cost: number;
-    }>;
-}
-export * from "./local-relayer.js";
-export * from "./provider-relayer.js";
-export * from "./rpc-relayer/index.js";
-export { proto as RpcRelayerProto } from "./rpc-relayer/index.js";
-export type SimulateResult = proto.SimulateResult;
-export type FeeOption = proto.FeeOption;
-export interface FeeQuote {
-    _tag: 'FeeQuote';
-    _quote: unknown;
-}
-export declare function isRelayer(cand: any): cand is Relayer;

package/dist/declarations/src/local-relayer.d.ts

@@ -1,35 +0,0 @@
-import { ethers } from 'ethers';
-import { FeeOption, FeeQuote, proto, Relayer } from "./index.js";
-import { ProviderRelayer, ProviderRelayerOptions } from "./provider-relayer.js";
-import { commons } from '@0xsequence/core';
-export type LocalRelayerOptions = Omit<ProviderRelayerOptions, 'provider'> & {
-    signer: ethers.Signer;
-};
-export declare function isLocalRelayerOptions(obj: any): obj is LocalRelayerOptions;
-export declare class LocalRelayer extends ProviderRelayer implements Relayer {
-    private signer;
-    private txnOptions;
-    constructor(options: LocalRelayerOptions | ethers.AbstractSigner);
-    getFeeOptions(_address: string, ..._transactions: commons.transaction.Transaction[]): Promise<{
-        options: FeeOption[];
-    }>;
-    getFeeOptionsRaw(_entrypoint: string, _data: ethers.BytesLike, _options?: {
-        simulate?: boolean;
-    }): Promise<{
-        options: FeeOption[];
-    }>;
-    gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
-    setTransactionOptions(transactionRequest: ethers.TransactionRequest): void;
-    relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse<ethers.TransactionReceipt>>;
-    getMetaTransactions(projectId: number, page?: proto.Page): Promise<{
-        page: proto.Page;
-        transactions: proto.MetaTxnLog[];
-    }>;
-    getTransactionCost(projectId: number, from: string, to: string): Promise<{
-        cost: number;
-    }>;
-    listGasSponsors(args: proto.ListGasSponsorsArgs): Promise<proto.ListGasSponsorsReturn>;
-    addGasSponsor(args: proto.AddGasSponsorArgs): Promise<proto.AddGasSponsorReturn>;
-    updateGasSponsor(args: proto.UpdateGasSponsorArgs): Promise<proto.UpdateGasSponsorReturn>;
-    removeGasSponsor(args: proto.RemoveGasSponsorArgs): Promise<proto.RemoveGasSponsorReturn>;
-}

package/dist/declarations/src/provider-relayer.d.ts

@@ -1,47 +0,0 @@
-import { ethers } from 'ethers';
-import { FeeOption, FeeQuote, proto, Relayer, SimulateResult } from "./index.js";
-import { Optionals } from '@0xsequence/utils';
-import { commons } from '@0xsequence/core';
-export interface ProviderRelayerOptions {
-    provider: ethers.Provider;
-    waitPollRate?: number;
-    deltaBlocksLog?: number;
-    fromBlockLog?: number;
-}
-export declare const ProviderRelayerDefaults: Required<Optionals<ProviderRelayerOptions>>;
-export declare function isProviderRelayerOptions(obj: any): obj is ProviderRelayerOptions;
-export declare abstract class ProviderRelayer implements Relayer {
-    provider: ethers.Provider;
-    waitPollRate: number;
-    deltaBlocksLog: number;
-    fromBlockLog: number;
-    constructor(options: ProviderRelayerOptions);
-    abstract getFeeOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<{
-        options: FeeOption[];
-        quote?: FeeQuote;
-    }>;
-    abstract getFeeOptionsRaw(entrypoint: string, data: ethers.BytesLike, options?: {
-        simulate?: boolean;
-    }): Promise<{
-        options: FeeOption[];
-        quote?: FeeQuote;
-    }>;
-    abstract gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
-    abstract relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean): Promise<commons.transaction.TransactionResponse>;
-    abstract getTransactionCost(projectId: number, from: string, to: string): Promise<{
-        cost: number;
-    }>;
-    abstract getMetaTransactions(projectId: number, page?: proto.Page): Promise<{
-        page: proto.Page;
-        transactions: proto.MetaTxnLog[];
-    }>;
-    abstract listGasSponsors(args: proto.ListGasSponsorsArgs): Promise<proto.ListGasSponsorsReturn>;
-    abstract addGasSponsor(args: proto.AddGasSponsorArgs): Promise<proto.AddGasSponsorReturn>;
-    abstract updateGasSponsor(args: proto.UpdateGasSponsorArgs): Promise<proto.UpdateGasSponsorReturn>;
-    abstract removeGasSponsor(args: proto.RemoveGasSponsorArgs): Promise<proto.RemoveGasSponsorReturn>;
-    simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]>;
-    getNonce(address: string, space?: ethers.BigNumberish, blockTag?: ethers.BlockTag): Promise<ethers.BigNumberish>;
-    wait(metaTxnId: string | commons.transaction.SignedTransactionBundle, timeoutDuration?: number, delay?: number, maxFails?: number): Promise<ethers.TransactionResponse & {
-        receipt: ethers.TransactionReceipt;
-    }>;
-}

package/dist/declarations/src/rpc-relayer/index.d.ts

@@ -1,72 +0,0 @@
-import { ethers } from 'ethers';
-import { FeeOption, FeeQuote, Relayer, SimulateResult } from "../index.js";
-import * as proto from "./relayer.gen.js";
-import { commons } from '@0xsequence/core';
-export { proto };
-export interface RpcRelayerOptions {
-    provider: ethers.AbstractProvider | {
-        url: string;
-    };
-    url: string;
-    projectAccessKey?: string;
-    jwtAuth?: string;
-}
-export declare function isRpcRelayerOptions(obj: any): obj is RpcRelayerOptions;
-export declare class RpcRelayer implements Relayer {
-    options: RpcRelayerOptions;
-    private readonly service;
-    readonly provider: ethers.Provider;
-    constructor(options: RpcRelayerOptions);
-    _fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
-    waitReceipt(metaTxnId: string | commons.transaction.SignedTransactionBundle, delay?: number, maxFails?: number, isCancelled?: () => boolean): Promise<proto.GetMetaTxnReceiptReturn>;
-    simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]>;
-    getFeeOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<{
-        options: FeeOption[];
-        quote?: FeeQuote;
-    }>;
-    getFeeOptionsRaw(entrypoint: string, data: ethers.BytesLike, options?: {
-        simulate?: boolean;
-        projectAccessKey?: string;
-    }): Promise<{
-        options: FeeOption[];
-        quote?: FeeQuote;
-    }>;
-    gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>;
-    getNonce(address: string, space?: ethers.BigNumberish): Promise<ethers.BigNumberish>;
-    relay(signedTxs: commons.transaction.IntendedTransactionBundle, quote?: FeeQuote, waitForReceipt?: boolean, projectAccessKey?: string): Promise<commons.transaction.TransactionResponse<RelayerTxReceipt>>;
-    wait(metaTxnId: string | commons.transaction.SignedTransactionBundle, timeout?: number, delay?: number, maxFails?: number): Promise<commons.transaction.TransactionResponse<RelayerTxReceipt>>;
-    getMetaTransactions(projectId: number, page?: proto.Page): Promise<{
-        page: proto.Page;
-        transactions: proto.MetaTxnLog[];
-    }>;
-    getTransactionCost(projectId: number, from: string, to: string): Promise<{
-        cost: number;
-    }>;
-    listGasSponsors(args: proto.ListGasSponsorsArgs): Promise<proto.ListGasSponsorsReturn>;
-    addGasSponsor(args: proto.AddGasSponsorArgs): Promise<proto.AddGasSponsorReturn>;
-    updateGasSponsor(args: proto.UpdateGasSponsorArgs): Promise<proto.UpdateGasSponsorReturn>;
-    removeGasSponsor(args: proto.RemoveGasSponsorArgs): Promise<proto.RemoveGasSponsorReturn>;
-}
-export type RelayerTxReceipt = {
-    blockHash: string;
-    blockNumber: string;
-    contractAddress: string;
-    cumulativeGasUsed: string;
-    gasUsed: string;
-    logs: {
-        address: string;
-        blockHash: string;
-        blockNumber: string;
-        data: string;
-        logIndex: string;
-        removed: boolean;
-        topics: string[];
-        transactionHash: string;
-        transactionIndex: string;
-    }[];
-    logsBloom: string;
-    root: string;
-    status: string;
-    transactionHash: string;
-    transactionIndex: string;
-};

package/src/local-relayer.ts

@@ -1,125 +0,0 @@
-import { ethers } from 'ethers'
-import { logger } from '@0xsequence/utils'
-import { FeeOption, FeeQuote, proto, Relayer } from '.'
-import { ProviderRelayer, ProviderRelayerOptions } from './provider-relayer'
-import { commons } from '@0xsequence/core'
-
-export type LocalRelayerOptions = Omit<ProviderRelayerOptions, 'provider'> & {
-  signer: ethers.Signer
-}
-
-export function isLocalRelayerOptions(obj: any): obj is LocalRelayerOptions {
-  return typeof obj === 'object' && isAbstractSigner(obj.signer)
-}
-
-export class LocalRelayer extends ProviderRelayer implements Relayer {
-  private signer: ethers.Signer
-  private txnOptions: ethers.TransactionRequest
-
-  constructor(options: LocalRelayerOptions | ethers.AbstractSigner) {
-    super(isAbstractSigner(options) ? { provider: options.provider! } : { ...options, provider: options.signer.provider! })
-    this.signer = isAbstractSigner(options) ? options : options.signer
-    if (!this.signer.provider) throw new Error('Signer must have a provider')
-  }
-
-  async getFeeOptions(_address: string, ..._transactions: commons.transaction.Transaction[]): Promise<{ options: FeeOption[] }> {
-    return { options: [] }
-  }
-
-  async getFeeOptionsRaw(
-    _entrypoint: string,
-    _data: ethers.BytesLike,
-    _options?: {
-      simulate?: boolean
-    }
-  ): Promise<{ options: FeeOption[] }> {
-    return { options: [] }
-  }
-
-  async gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]> {
-    const { options } = await this.getFeeOptions(address, ...transactions)
-    return options
-  }
-
-  setTransactionOptions(transactionRequest: ethers.TransactionRequest) {
-    this.txnOptions = transactionRequest
-  }
-
-  async relay(
-    signedTxs: commons.transaction.IntendedTransactionBundle,
-    quote?: FeeQuote,
-    waitForReceipt: boolean = true
-  ): Promise<commons.transaction.TransactionResponse<ethers.TransactionReceipt>> {
-    if (quote !== undefined) {
-      logger.warn(`LocalRelayer doesn't accept fee quotes`)
-    }
-
-    const data = commons.transaction.encodeBundleExecData(signedTxs)
-
-    // TODO: think about computing gas limit individually, summing together and passing across
-    // NOTE: we expect that all txns have set their gasLimit ahead of time through proper estimation
-    // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum + tx.gasLimit, 0n)
-    // txRequest.gasLimit = gasLimit
-
-    const responsePromise = this.signer.sendTransaction({
-      to: signedTxs.entrypoint,
-      data,
-      ...this.txnOptions,
-      gasLimit: 9000000
-    })
-
-    if (waitForReceipt) {
-      const response: commons.transaction.TransactionResponse = await responsePromise
-      response.receipt = await response.wait()
-      return response
-    } else {
-      return responsePromise
-    }
-  }
-
-  async getMetaTransactions(
-    projectId: number,
-    page?: proto.Page
-  ): Promise<{
-    page: proto.Page
-    transactions: proto.MetaTxnLog[]
-  }> {
-    return { page: { page: 0, pageSize: 100 }, transactions: [] }
-  }
-
-  async getTransactionCost(
-    projectId: number,
-    from: string,
-    to: string
-  ): Promise<{
-    cost: number
-  }> {
-    return { cost: 0 }
-  }
-
-  async listGasSponsors(args: proto.ListGasSponsorsArgs): Promise<proto.ListGasSponsorsReturn> {
-    return { page: { page: 0, pageSize: 100 }, gasSponsors: [] }
-  }
-
-  async addGasSponsor(args: proto.AddGasSponsorArgs): Promise<proto.AddGasSponsorReturn> {
-    return { status: true, gasSponsor: {} as proto.GasSponsor }
-  }
-
-  async updateGasSponsor(args: proto.UpdateGasSponsorArgs): Promise<proto.UpdateGasSponsorReturn> {
-    return { status: true, gasSponsor: {} as proto.GasSponsor }
-  }
-
-  async removeGasSponsor(args: proto.RemoveGasSponsorArgs): Promise<proto.RemoveGasSponsorReturn> {
-    return { status: true }
-  }
-}
-
-function isAbstractSigner(signer: any): signer is ethers.AbstractSigner {
-  return (
-    signer &&
-    typeof signer === 'object' &&
-    typeof signer.provider === 'object' &&
-    typeof signer.getAddress === 'function' &&
-    typeof signer.connect === 'function'
-  )
-}

package/src/provider-relayer.ts

@@ -1,284 +0,0 @@
-import { ethers } from 'ethers'
-import { walletContracts } from '@0xsequence/abi'
-import { FeeOption, FeeQuote, proto, Relayer, SimulateResult } from '.'
-import { logger, Optionals } from '@0xsequence/utils'
-import { commons } from '@0xsequence/core'
-
-const DEFAULT_GAS_LIMIT = 800000n
-
-export interface ProviderRelayerOptions {
-  provider: ethers.Provider
-  waitPollRate?: number
-  deltaBlocksLog?: number
-  fromBlockLog?: number
-}
-
-export const ProviderRelayerDefaults: Required<Optionals<ProviderRelayerOptions>> = {
-  waitPollRate: 1000,
-  deltaBlocksLog: 12,
-  fromBlockLog: -1024
-}
-
-export function isProviderRelayerOptions(obj: any): obj is ProviderRelayerOptions {
-  return typeof obj === 'object' && isAbstractProvider(obj.provider)
-}
-
-export abstract class ProviderRelayer implements Relayer {
-  public provider: ethers.Provider
-  public waitPollRate: number
-  public deltaBlocksLog: number
-  public fromBlockLog: number
-
-  constructor(options: ProviderRelayerOptions) {
-    const opts = { ...ProviderRelayerDefaults, ...options }
-
-    this.provider = opts.provider
-    this.waitPollRate = opts.waitPollRate
-    this.deltaBlocksLog = opts.deltaBlocksLog
-    this.fromBlockLog = opts.fromBlockLog
-  }
-
-  abstract getFeeOptions(
-    address: string,
-    ...transactions: commons.transaction.Transaction[]
-  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }>
-
-  abstract getFeeOptionsRaw(
-    entrypoint: string,
-    data: ethers.BytesLike,
-    options?: {
-      simulate?: boolean
-    }
-  ): Promise<{ options: FeeOption[]; quote?: FeeQuote }>
-
-  abstract gasRefundOptions(address: string, ...transactions: commons.transaction.Transaction[]): Promise<FeeOption[]>
-
-  abstract relay(
-    signedTxs: commons.transaction.IntendedTransactionBundle,
-    quote?: FeeQuote,
-    waitForReceipt?: boolean
-  ): Promise<commons.transaction.TransactionResponse>
-
-  abstract getTransactionCost(
-    projectId: number,
-    from: string,
-    to: string
-  ): Promise<{
-    cost: number
-  }>
-
-  abstract getMetaTransactions(
-    projectId: number,
-    page?: proto.Page
-  ): Promise<{
-    page: proto.Page
-    transactions: proto.MetaTxnLog[]
-  }>
-
-  abstract listGasSponsors(args: proto.ListGasSponsorsArgs): Promise<proto.ListGasSponsorsReturn>
-
-  abstract addGasSponsor(args: proto.AddGasSponsorArgs): Promise<proto.AddGasSponsorReturn>
-
-  abstract updateGasSponsor(args: proto.UpdateGasSponsorArgs): Promise<proto.UpdateGasSponsorReturn>
-
-  abstract removeGasSponsor(args: proto.RemoveGasSponsorArgs): Promise<proto.RemoveGasSponsorReturn>
-
-  async simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]> {
-    return (
-      await Promise.all(
-        transactions.map(async tx => {
-          // Respect gasLimit request of the transaction (as long as its not 0)
-          if (tx.gasLimit && BigInt(tx.gasLimit || 0) !== 0n) {
-            return tx.gasLimit
-          }
-
-          // Fee can't be estimated locally for delegateCalls
-          if (tx.delegateCall) {
-            return DEFAULT_GAS_LIMIT
-          }
-
-          // Fee can't be estimated for self-called if wallet hasn't been deployed
-          if (tx.to === wallet && (await this.provider.getCode(wallet).then(code => ethers.getBytes(code).length === 0))) {
-            return DEFAULT_GAS_LIMIT
-          }
-
-          if (!this.provider) {
-            throw new Error('signer.provider is not set, but is required')
-          }
-
-          // TODO: If the wallet address has been deployed, gas limits can be
-          // estimated with more accurately by using self-calls with the batch transactions one by one
-          return this.provider.estimateGas({
-            from: wallet,
-            to: tx.to,
-            data: tx.data,
-            value: tx.value
-          })
-        })
-      )
-    ).map(gasLimit => ({
-      executed: true,
-      succeeded: true,
-      gasUsed: Number(gasLimit),
-      gasLimit: Number(gasLimit)
-    }))
-  }
-
-  async getNonce(address: string, space?: ethers.BigNumberish, blockTag?: ethers.BlockTag): Promise<ethers.BigNumberish> {
-    if (!this.provider) {
-      throw new Error('provider is not set')
-    }
-
-    if ((await this.provider.getCode(address)) === '0x') {
-      return 0
-    }
-
-    if (space === undefined) {
-      space = 0
-    }
-
-    const module = new ethers.Contract(address, walletContracts.mainModule.abi, this.provider)
-    const nonce = await module.readNonce(space, { blockTag: blockTag })
-    return commons.transaction.encodeNonce(space, nonce)
-  }
-
-  async wait(
-    metaTxnId: string | commons.transaction.SignedTransactionBundle,
-    timeoutDuration?: number,
-    delay: number = this.waitPollRate,
-    maxFails: number = 5
-  ): Promise<ethers.TransactionResponse & { receipt: ethers.TransactionReceipt }> {
-    if (typeof metaTxnId !== 'string') {
-      metaTxnId = commons.transaction.intendedTransactionID(metaTxnId)
-    }
-
-    let timedOut = false
-
-    const retry = async <T>(f: () => Promise<T>, errorMessage: string): Promise<T> => {
-      let fails = 0
-
-      while (!timedOut) {
-        try {
-          return await f()
-        } catch (error) {
-          fails++
-
-          if (maxFails !== undefined && fails >= maxFails) {
-            logger.error(`giving up after ${fails} failed attempts${errorMessage ? `: ${errorMessage}` : ''}`, error)
-            throw error
-          } else {
-            logger.warn(`attempt #${fails} failed${errorMessage ? `: ${errorMessage}` : ''}`, error)
-          }
-        }
-
-        if (delay > 0) {
-          await new Promise(resolve => setTimeout(resolve, delay))
-        }
-      }
-
-      throw new Error(`timed out after ${fails} failed attempts${errorMessage ? `: ${errorMessage}` : ''}`)
-    }
-
-    const waitReceipt = async (): Promise<ethers.TransactionResponse & { receipt: ethers.TransactionReceipt }> => {
-      // Transactions can only get executed on nonce change
-      // get all nonce changes and look for metaTxnIds in between logs
-      let lastBlock: number = this.fromBlockLog
-
-      if (lastBlock < 0) {
-        const block = await retry(() => this.provider.getBlockNumber(), 'unable to get latest block number')
-        lastBlock = block + lastBlock
-      }
-
-      if (typeof metaTxnId !== 'string') {
-        throw new Error('impossible')
-      }
-
-      const normalMetaTxnId = metaTxnId.replace('0x', '')
-
-      while (!timedOut) {
-        const block = await retry(() => this.provider.getBlockNumber(), 'unable to get latest block number')
-
-        const logs = await retry(
-          () =>
-            this.provider.getLogs({
-              fromBlock: Math.max(0, lastBlock - this.deltaBlocksLog),
-              toBlock: block,
-              // Nonce change event topic
-              topics: ['0x1f180c27086c7a39ea2a7b25239d1ab92348f07ca7bb59d1438fcf527568f881']
-            }),
-          `unable to get NonceChange logs for blocks ${Math.max(0, lastBlock - this.deltaBlocksLog)} to ${block}`
-        )
-
-        lastBlock = block
-
-        // Get receipts of all transactions
-        const txs = await Promise.all(
-          logs.map(l =>
-            retry(
-              () => this.provider.getTransactionReceipt(l.transactionHash),
-              `unable to get receipt for transaction ${l.transactionHash}`
-            )
-          )
-        )
-
-        // Find a transaction with a TxExecuted log
-        const found = txs.find(tx =>
-          tx?.logs.find(
-            l =>
-              (l.topics.length === 0 && l.data.replace('0x', '') === normalMetaTxnId) ||
-              (l.topics.length === 1 &&
-                // TxFailed event topic
-                l.topics[0] === '0x3dbd1590ea96dd3253a91f24e64e3a502e1225d602a5731357bc12643070ccd7' &&
-                l.data.length >= 64 &&
-                l.data.replace('0x', '').startsWith(normalMetaTxnId))
-          )
-        )
-
-        // If found return that
-        if (found) {
-          const response = await retry(() => this.provider.getTransaction(found.hash), `unable to get transaction ${found.hash}`)
-          if (!response) {
-            throw new Error(`Transaction response not found for  ${metaTxnId}`)
-          }
-
-          // NOTE: we have to do this, because ethers-v6 uses private fields
-          // and we can't just extend the class and override the method, so
-          // we just modify the response object directly by adding the receipt to it.
-          const out: any = response
-          out.receipt = found
-          return out
-        }
-
-        // Otherwise wait and try again
-        if (!timedOut) {
-          await new Promise(r => setTimeout(r, delay))
-        }
-      }
-
-      throw new Error(`Timeout waiting for transaction receipt ${metaTxnId}`)
-    }
-
-    if (timeoutDuration !== undefined) {
-      return Promise.race([
-        waitReceipt(),
-        new Promise<ethers.TransactionResponse & { receipt: ethers.TransactionReceipt }>((_, reject) =>
-          setTimeout(() => {
-            timedOut = true
-            reject(`Timeout waiting for transaction receipt ${metaTxnId}`)
-          }, timeoutDuration)
-        )
-      ])
-    } else {
-      return waitReceipt()
-    }
-  }
-}
-
-function isAbstractProvider(provider: any): provider is ethers.AbstractProvider {
-  return (
-    provider &&
-    typeof provider === 'object' &&
-    typeof provider.getNetwork === 'function' &&
-    typeof provider.getBlockNumber === 'function'
-  )
-}