@0xsequence/relayer 0.40.6 → 0.41.0

package/dist/0xsequence-relayer.esm.js

@@ -229,50 +229,95 @@ class ProviderRelayer extends BaseRelayer {
     return encodeNonce(space, nonce);
   }
 
-  async wait(metaTxnId, timeout) {
+  async wait(metaTxnId, timeout, delay = this.waitPollRate, maxFails = 5) {
+    var _this2 = this;
+
     if (typeof metaTxnId !== 'string') {
-      logger.info("computing id", metaTxnId.config, metaTxnId.context, metaTxnId.chainId, ...metaTxnId.transactions);
-      return this.wait(computeMetaTxnHash(addressOf(metaTxnId.config, metaTxnId.context), metaTxnId.chainId, ...metaTxnId.transactions), timeout);
-    } // Transactions can only get executed on nonce change
-    // get all nonce changes and look for metaTxnIds in between logs
+      logger.info('computing id', metaTxnId.config, metaTxnId.context, metaTxnId.chainId, ...metaTxnId.transactions);
+      metaTxnId = computeMetaTxnHash(addressOf(metaTxnId.config, metaTxnId.context), metaTxnId.chainId, ...metaTxnId.transactions);
+    }
 
+    let timedOut = false;
 
-    const timeoutTime = new Date().getTime() + timeout;
-    let lastBlock = this.fromBlockLog;
+    const retry = async function retry(f, errorMessage) {
+      let fails = 0;
 
-    if (lastBlock < 0) {
-      const block = await this.provider.getBlockNumber();
-      lastBlock = block + lastBlock;
-    }
+      while (!timedOut) {
+        try {
+          return await f();
+        } catch (error) {
+          fails++;
 
-    const normalMetaTxnId = metaTxnId.replace('0x', '');
+          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);
+          }
+        }
 
-    while (new Date().getTime() < timeoutTime) {
-      const block = await this.provider.getBlockNumber();
-      const logs = await this.provider.getLogs({
-        fromBlock: Math.max(0, lastBlock - this.deltaBlocksLog),
-        toBlock: block,
-        // Nonce change event topic
-        topics: ['0x1f180c27086c7a39ea2a7b25239d1ab92348f07ca7bb59d1438fcf527568f881']
-      });
-      lastBlock = block; // Get receipts of all transactions
+        if (delay > 0) {
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
 
-      const txs = await Promise.all(logs.map(l => this.provider.getTransactionReceipt(l.transactionHash))); // Find a transaction with a TxExecuted log
+      throw new Error(`timed out after ${fails} failed attempts${errorMessage ? `: ${errorMessage}` : ''}`);
+    };
 
-      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
+    const waitReceipt = async function waitReceipt() {
+      // Transactions can only get executed on nonce change
+      // get all nonce changes and look for metaTxnIds in between logs
+      let lastBlock = _this2.fromBlockLog;
 
-      if (found) {
-        return _extends({
-          receipt: found
-        }, await this.provider.getTransaction(found.transactionHash));
-      } // Otherwise wait and try again
+      if (lastBlock < 0) {
+        const block = await retry(() => _this2.provider.getBlockNumber(), 'unable to get latest block number');
+        lastBlock = block + lastBlock;
+      }
+
+      if (typeof metaTxnId !== 'string') {
+        throw new Error('impossible');
+      }
 
+      const normalMetaTxnId = metaTxnId.replace('0x', '');
 
-      await new Promise(r => setTimeout(r, this.waitPollRate));
-    }
+      while (!timedOut) {
+        const block = await retry(() => _this2.provider.getBlockNumber(), 'unable to get latest block number');
+        const logs = await retry(() => _this2.provider.getLogs({
+          fromBlock: Math.max(0, lastBlock - _this2.deltaBlocksLog),
+          toBlock: block,
+          // Nonce change event topic
+          topics: ['0x1f180c27086c7a39ea2a7b25239d1ab92348f07ca7bb59d1438fcf527568f881']
+        }), `unable to get NonceChange logs for blocks ${Math.max(0, lastBlock - _this2.deltaBlocksLog)} to ${block}`);
+        lastBlock = block; // Get receipts of all transactions
+
+        const txs = await Promise.all(logs.map(l => retry(() => _this2.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) {
+          return _extends({
+            receipt: found
+          }, await retry(() => _this2.provider.getTransaction(found.transactionHash), `unable to get transaction ${found.transactionHash}`));
+        } // Otherwise wait and try again
 
-    throw new Error(`Timeout waiting for transaction receipt ${metaTxnId}`);
+
+        if (!timedOut) {
+          await new Promise(r => setTimeout(r, delay));
+        }
+      }
+
+      throw new Error(`Timeout waiting for transaction receipt ${metaTxnId}`);
+    };
+
+    if (timeout !== undefined) {
+      return Promise.race([waitReceipt(), new Promise((_, reject) => setTimeout(() => {
+        timedOut = true;
+        reject(`Timeout waiting for transaction receipt ${metaTxnId}`);
+      }, timeout))]);
+    } else {
+      return waitReceipt();
+    }
   }
 
 }
@@ -321,7 +366,7 @@ class LocalRelayer extends ProviderRelayer {
     this.txnOptions = transactionRequest;
   }
 
-  async relay(signedTxs, quote) {
+  async relay(signedTxs, quote, waitForReceipt = true) {
     if (quote !== undefined) {
       logger.warn(`LocalRelayer doesn't accept fee quotes`);
     }
@@ -340,10 +385,18 @@ class LocalRelayer extends ProviderRelayer {
     // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum.add(tx.gasLimit), ethers.BigNumber.from(0))
     // txRequest.gasLimit = gasLimit
 
-    return this.signer.sendTransaction(_extends({
+    const responsePromise = this.signer.sendTransaction(_extends({
       to,
       data
     }, this.txnOptions));
+
+    if (waitForReceipt) {
+      const response = await responsePromise;
+      response.receipt = await response.wait();
+      return response;
+    } else {
+      return responsePromise;
+    }
   }
 
 }
@@ -618,7 +671,8 @@ var relayer_gen = /*#__PURE__*/Object.freeze({
   Relayer: Relayer
 });
 
-const FAILED_STATUSES = [ETHTxnStatus.FAILED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.DROPPED];
+const FINAL_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.SUCCEEDED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
+const FAILED_STATUSES = [ETHTxnStatus.DROPPED, ETHTxnStatus.PARTIALLY_FAILED, ETHTxnStatus.FAILED];
 function isRpcRelayerOptions(obj) {
   return obj.url !== undefined && typeof obj.url === 'string';
 }
@@ -629,26 +683,50 @@ class RpcRelayer extends BaseRelayer {
     this.service = new Relayer(options.url, fetchPonyfill().fetch);
   }
 
-  async waitReceipt(metaTxnHash, wait = 1000) {
-    if (typeof metaTxnHash !== 'string') {
-      logger.info('computing id', metaTxnHash.config, metaTxnHash.context, metaTxnHash.chainId, ...metaTxnHash.transactions);
-      return this.waitReceipt(computeMetaTxnHash(addressOf(metaTxnHash.config, metaTxnHash.context), metaTxnHash.chainId, ...metaTxnHash.transactions));
+  async waitReceipt(metaTxnId, delay = 1000, maxFails = 5, isCancelled) {
+    if (typeof metaTxnId !== 'string') {
+      logger.info('computing id', metaTxnId.config, metaTxnId.context, metaTxnId.chainId, ...metaTxnId.transactions);
+      metaTxnId = computeMetaTxnHash(addressOf(metaTxnId.config, metaTxnId.context), metaTxnId.chainId, ...metaTxnId.transactions);
     }
 
-    logger.info(`[rpc-relayer/waitReceipt] waiting for ${metaTxnHash}`);
-    let result = await this.service.getMetaTxnReceipt({
-      metaTxID: metaTxnHash
-    }); // TODO: remove check for 'UNKNOWN' status when 'QUEUED' status is supported
-    // TODO: fix backend to not return literal 'null' txnReceipt
+    logger.info(`[rpc-relayer/waitReceipt] waiting for ${metaTxnId}`);
+    let fails = 0;
 
-    while (!result.receipt || !result.receipt.txnReceipt || result.receipt.txnReceipt === 'null' || result.receipt.status === 'UNKNOWN' || result.receipt.status === 'QUEUED' || result.receipt.status === 'SENT') {
-      await new Promise(r => setTimeout(r, wait));
-      result = await this.service.getMetaTxnReceipt({
-        metaTxID: metaTxnHash
-      });
+    while (isCancelled === undefined || !isCancelled()) {
+      try {
+        const {
+          receipt
+        } = await this.service.getMetaTxnReceipt({
+          metaTxID: metaTxnId
+        });
+
+        if (!receipt) {
+          throw new Error('missing expected receipt');
+        }
+
+        if (!receipt.txnReceipt) {
+          throw new Error('missing expected transaction receipt');
+        }
+
+        if (FINAL_STATUSES.includes(receipt.status)) {
+          return {
+            receipt
+          };
+        }
+      } catch (e) {
+        fails++;
+
+        if (fails === maxFails) {
+          throw e;
+        }
+      }
+
+      if (isCancelled === undefined || !isCancelled()) {
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
     }
 
-    return result;
+    throw new Error(`Cancelled waiting for transaction receipt ${metaTxnId}`);
   }
 
   async simulate(wallet, ...transactions) {
@@ -773,7 +851,9 @@ class RpcRelayer extends BaseRelayer {
     return nonce;
   }
 
-  async relay(signedTxs, quote) {
+  async relay(signedTxs, quote, waitForReceipt = true) {
+    var _this = this;
+
     logger.info(`[rpc-relayer/relay] relaying signed meta-transactions ${JSON.stringify(signedTxs)} with quote ${JSON.stringify(quote)}`);
     let typecheckedQuote;
 
@@ -806,15 +886,50 @@ class RpcRelayer extends BaseRelayer {
       quote: typecheckedQuote
     });
     logger.info(`[rpc-relayer/relay] got relay result ${JSON.stringify(metaTxn)}`);
-    return this.wait(metaTxn.txnHash);
+
+    if (waitForReceipt) {
+      return this.wait(metaTxn.txnHash);
+    } else {
+      const response = {
+        hash: metaTxn.txnHash,
+        confirmations: 0,
+        from: walletAddress,
+        wait: _confirmations => Promise.reject(new Error('impossible'))
+      };
+
+      const wait = async function wait(confirmations) {
+        var _waitResponse$receipt;
+
+        if (!_this.provider) {
+          throw new Error('cannot wait for receipt, relayer has no provider set');
+        }
+
+        const waitResponse = await _this.wait(metaTxn.txnHash);
+        const transactionHash = (_waitResponse$receipt = waitResponse.receipt) == null ? void 0 : _waitResponse$receipt.transactionHash;
+
+        if (!transactionHash) {
+          throw new Error('cannot wait for receipt, unknown native transaction hash');
+        }
+
+        Object.assign(response, waitResponse);
+        return _this.provider.waitForTransaction(transactionHash, confirmations);
+      };
+
+      response.wait = wait;
+      return response;
+    }
   }
 
-  async wait(metaTxnHash, wait = 1000) {
-    var _this = this;
+  async wait(metaTxnId, timeout, delay = 1000, maxFails = 5) {
+    var _this2 = this;
 
+    let timedOut = false;
     const {
       receipt
-    } = await this.waitReceipt(metaTxnHash, wait);
+    } = await (timeout !== undefined ? Promise.race([this.waitReceipt(metaTxnId, delay, maxFails, () => timedOut), new Promise((_, reject) => setTimeout(() => {
+      timedOut = true;
+      reject(`Timeout waiting for transaction receipt ${metaTxnId}`);
+    }, timeout))]) : this.waitReceipt(metaTxnId, delay, maxFails));
 
     if (!receipt.txnReceipt || FAILED_STATUSES.includes(receipt.status)) {
       throw new MetaTransactionResponseException(receipt);
@@ -825,13 +940,13 @@ class RpcRelayer extends BaseRelayer {
       blockHash: txReceipt.blockHash,
       blockNumber: ethers.BigNumber.from(txReceipt.blockNumber).toNumber(),
       confirmations: 1,
-      from: typeof metaTxnHash === 'string' ? undefined : addressOf(metaTxnHash.config, metaTxnHash.context),
+      from: typeof metaTxnId === 'string' ? undefined : addressOf(metaTxnId.config, metaTxnId.context),
       hash: txReceipt.transactionHash,
       raw: receipt.txnReceipt,
       receipt: txReceipt,
       // extended type which is Sequence-specific. Contains the decoded metaTxReceipt
       wait: async function (confirmations) {
-        return _this.provider.waitForTransaction(txReceipt.transactionHash, confirmations);
+        return _this2.provider.waitForTransaction(txReceipt.transactionHash, confirmations);
       }
     };
   }

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

@@ -12,8 +12,8 @@ export interface Relayer {
     }>;
     gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
     getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish, blockTag?: providers.BlockTag): Promise<ethers.BigNumberish>;
-    relay(signedTxs: SignedTransactions, quote?: FeeQuote): Promise<TransactionResponse>;
-    wait(metaTxnId: string | SignedTransactions, timeout: number): Promise<TransactionResponse>;
+    relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse>;
+    wait(metaTxnId: string | SignedTransactions, timeout?: number, delay?: number, maxFails?: number): Promise<TransactionResponse>;
 }
 export * from './local-relayer';
 export * from './base-relayer';

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

@@ -1,4 +1,4 @@
-import { TransactionRequest } from '@ethersproject/providers';
+import { TransactionReceipt, TransactionRequest } from '@ethersproject/providers';
 import { Signer as AbstractSigner } from 'ethers';
 import { SignedTransactions, Transaction, TransactionResponse } from '@0xsequence/transactions';
 import { WalletContext } from '@0xsequence/network';
@@ -19,5 +19,5 @@ export declare class LocalRelayer extends ProviderRelayer implements Relayer {
     }>;
     gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
     setTransactionOptions(transactionRequest: TransactionRequest): void;
-    relay(signedTxs: SignedTransactions, quote?: FeeQuote): Promise<TransactionResponse>;
+    relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse<TransactionReceipt>>;
 }

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

@@ -25,11 +25,11 @@ export declare abstract class ProviderRelayer extends BaseRelayer implements Rel
         quote?: FeeQuote;
     }>;
     abstract gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
-    abstract relay(signedTxs: SignedTransactions, quote?: FeeQuote): Promise<TransactionResponse>;
+    abstract relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse>;
     simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>;
     estimateGasLimits(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<Transaction[]>;
     getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish, blockTag?: BlockTag): Promise<ethers.BigNumberish>;
-    wait(metaTxnId: string | SignedTransactions, timeout: number): Promise<providers.TransactionResponse & {
+    wait(metaTxnId: string | SignedTransactions, timeout?: number, delay?: number, maxFails?: number): Promise<providers.TransactionResponse & {
         receipt: providers.TransactionReceipt;
     }>;
 }

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

@@ -13,7 +13,7 @@ export declare function isRpcRelayerOptions(obj: any): obj is RpcRelayerOptions;
 export declare class RpcRelayer extends BaseRelayer implements Relayer {
     private readonly service;
     constructor(options: RpcRelayerOptions);
-    waitReceipt(metaTxnHash: string | SignedTransactions, wait?: number): Promise<proto.GetMetaTxnReceiptReturn>;
+    waitReceipt(metaTxnId: string | SignedTransactions, delay?: number, maxFails?: number, isCancelled?: () => boolean): Promise<proto.GetMetaTxnReceiptReturn>;
     simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]>;
     estimateGasLimits(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<Transaction[]>;
     getFeeOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<{
@@ -22,8 +22,8 @@ export declare class RpcRelayer extends BaseRelayer implements Relayer {
     }>;
     gasRefundOptions(config: WalletConfig, context: WalletContext, ...transactions: Transaction[]): Promise<FeeOption[]>;
     getNonce(config: WalletConfig, context: WalletContext, space?: ethers.BigNumberish): Promise<ethers.BigNumberish>;
-    relay(signedTxs: SignedTransactions, quote?: FeeQuote): Promise<TransactionResponse>;
-    wait(metaTxnHash: string | SignedTransactions, wait?: number): Promise<TransactionResponse<RelayerTxReceipt>>;
+    relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse<RelayerTxReceipt>>;
+    wait(metaTxnId: string | SignedTransactions, timeout?: number, delay?: number, maxFails?: number): Promise<TransactionResponse<RelayerTxReceipt>>;
 }
 export declare type RelayerTxReceipt = {
     blockHash: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/relayer",
-  "version": "0.40.6",
+  "version": "0.41.0",
   "description": "relayer sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/relayer",
   "source": "src/index.ts",
@@ -17,10 +17,10 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@0xsequence/abi": "^0.40.6",
-    "@0xsequence/config": "^0.40.6",
-    "@0xsequence/transactions": "^0.40.6",
-    "@0xsequence/utils": "^0.40.6",
+    "@0xsequence/abi": "^0.41.0",
+    "@0xsequence/config": "^0.41.0",
+    "@0xsequence/transactions": "^0.41.0",
+    "@0xsequence/utils": "^0.41.0",
     "@ethersproject/providers": "^5.5.1",
     "ethers": "^5.5.2",
     "fetch-ponyfill": "^7.1.0"

package/src/index.ts

@@ -39,10 +39,14 @@ export interface Relayer {
 
   // relayer will submit the transaction(s) to the network and return the transaction response.
   // The quote should be the one returned from getFeeOptions, if any.
-  relay(signedTxs: SignedTransactions, quote?: FeeQuote): Promise<TransactionResponse>
+  // waitForReceipt must default to true.
+  relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse>
 
   // wait for transaction confirmation
-  wait(metaTxnId: string | SignedTransactions, timeout: number): Promise<TransactionResponse>
+  // timeout is the maximum time to wait for the transaction response
+  // delay is the polling interval, i.e. the time to wait between requests
+  // maxFails is the maximum number of hard failures to tolerate before giving up
+  wait(metaTxnId: string | SignedTransactions, timeout?: number, delay?: number, maxFails?: number): Promise<TransactionResponse>
 }
 
 export * from './local-relayer'

package/src/local-relayer.ts

@@ -1,4 +1,4 @@
-import { TransactionRequest } from '@ethersproject/providers'
+import { TransactionReceipt, TransactionRequest } from '@ethersproject/providers'
 import { Signer as AbstractSigner, ethers } from 'ethers'
 import { walletContracts } from '@0xsequence/abi'
 import { SignedTransactions, Transaction, sequenceTxAbiEncode, TransactionResponse } from '@0xsequence/transactions'
@@ -57,7 +57,7 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
     this.txnOptions = transactionRequest
   }
 
-  async relay(signedTxs: SignedTransactions, quote?: FeeQuote): Promise<TransactionResponse> {
+  async relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt: boolean = true): Promise<TransactionResponse<TransactionReceipt>> {
     if (quote !== undefined) {
       logger.warn(`LocalRelayer doesn't accept fee quotes`)
     }
@@ -80,6 +80,14 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
     // const gasLimit = signedTxs.transactions.reduce((sum, tx) => sum.add(tx.gasLimit), ethers.BigNumber.from(0))
     // txRequest.gasLimit = gasLimit
 
-    return this.signer.sendTransaction({ to, data, ...this.txnOptions })
+    const responsePromise = this.signer.sendTransaction({ to, data, ...this.txnOptions })
+
+    if (waitForReceipt) {
+      const response: TransactionResponse = await responsePromise
+      response.receipt = await response.wait()
+      return response
+    } else {
+      return responsePromise
+    }
   }
 }

package/src/provider-relayer.ts

@@ -54,7 +54,7 @@ export abstract class ProviderRelayer extends BaseRelayer implements Relayer {
     ...transactions: Transaction[]
   ): Promise<FeeOption[]>
 
-  abstract relay(signedTxs: SignedTransactions, quote?: FeeQuote): Promise<TransactionResponse>
+  abstract relay(signedTxs: SignedTransactions, quote?: FeeQuote, waitForReceipt?: boolean): Promise<TransactionResponse>
 
   async simulate(wallet: string, ...transactions: Transaction[]): Promise<SimulateResult[]> {
     return (await Promise.all(transactions.map(async tx => {
@@ -128,66 +128,132 @@ export abstract class ProviderRelayer extends BaseRelayer implements Relayer {
     return encodeNonce(space, nonce)
   }
 
-  async wait(metaTxnId: string | SignedTransactions, timeout: number): Promise<providers.TransactionResponse & { receipt: providers.TransactionReceipt }> {
+  async wait(
+    metaTxnId: string | SignedTransactions,
+    timeout?: number,
+    delay: number = this.waitPollRate,
+    maxFails: number = 5
+  ): Promise<providers.TransactionResponse & { receipt: providers.TransactionReceipt }> {
     if (typeof metaTxnId !== 'string') {
-      logger.info("computing id", metaTxnId.config, metaTxnId.context, metaTxnId.chainId, ...metaTxnId.transactions)
-      return this.wait(
-        computeMetaTxnHash(addressOf(metaTxnId.config, metaTxnId.context), metaTxnId.chainId, ...metaTxnId.transactions),
-        timeout
-      )
+      logger.info('computing id', metaTxnId.config, metaTxnId.context, metaTxnId.chainId, ...metaTxnId.transactions)
+
+      metaTxnId = computeMetaTxnHash(addressOf(metaTxnId.config, metaTxnId.context), metaTxnId.chainId, ...metaTxnId.transactions)
     }
-  
-    // Transactions can only get executed on nonce change
-    // get all nonce changes and look for metaTxnIds in between logs
-    const timeoutTime = new Date().getTime() + timeout
-    let lastBlock: number = this.fromBlockLog
-
-    if (lastBlock < 0) {
-      const block = await this.provider.getBlockNumber()
-      lastBlock = block + lastBlock
+
+    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 normalMetaTxnId = metaTxnId.replace('0x', '')
+    const waitReceipt = async (): Promise<providers.TransactionResponse & { receipt: providers.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
 
-    while (new Date().getTime() < timeoutTime) {
-      const block = await this.provider.getBlockNumber()
-      const logs = await this.provider.getLogs({
-        fromBlock: Math.max(0, lastBlock - this.deltaBlocksLog),
-        toBlock: block,
-        // Nonce change event topic
-        topics: ['0x1f180c27086c7a39ea2a7b25239d1ab92348f07ca7bb59d1438fcf527568f881']
-      })
+      if (lastBlock < 0) {
+        const block = await retry(() => this.provider.getBlockNumber(), 'unable to get latest block number')
+        lastBlock = block + lastBlock
+      }
 
-      lastBlock = block
-
-      // Get receipts of all transactions
-      const txs = await Promise.all(logs.map((l) => this.provider.getTransactionReceipt(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 (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}`
+            )
+          )
         )
-      )))
 
-      // If found return that
-      if (found) {
-        return {
-          receipt: found,
-          ...await this.provider.getTransaction(found.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) {
+          return {
+            receipt: found,
+            ...(await retry(
+              () => this.provider.getTransaction(found.transactionHash),
+              `unable to get transaction ${found.transactionHash}`
+            ))
+          }
+        }
+
+        // Otherwise wait and try again
+        if (!timedOut) {
+          await new Promise(r => setTimeout(r, delay))
         }
       }
 
-      // Otherwise wait and try again
-      await new Promise(r => setTimeout(r, this.waitPollRate))
+      throw new Error(`Timeout waiting for transaction receipt ${metaTxnId}`)
     }
 
-    throw new Error(`Timeout waiting for transaction receipt ${metaTxnId}`)
+    if (timeout !== undefined) {
+      return Promise.race([
+        waitReceipt(),
+        new Promise<providers.TransactionResponse & { receipt: providers.TransactionReceipt }>((_, reject) =>
+          setTimeout(() => {
+            timedOut = true
+            reject(`Timeout waiting for transaction receipt ${metaTxnId}`)
+          }, timeout)
+        )
+      ])
+    } else {
+      return waitReceipt()
+    }
   }
 }