@0xsequence/relayer 0.40.5 → 0.41.0

package/src/rpc-relayer/index.ts

@@ -21,7 +21,14 @@ import * as proto from './relayer.gen'
 
 export { proto }
 
-const FAILED_STATUSES = [proto.ETHTxnStatus.FAILED, proto.ETHTxnStatus.PARTIALLY_FAILED, proto.ETHTxnStatus.DROPPED]
+const FINAL_STATUSES = [
+  proto.ETHTxnStatus.DROPPED,
+  proto.ETHTxnStatus.SUCCEEDED,
+  proto.ETHTxnStatus.PARTIALLY_FAILED,
+  proto.ETHTxnStatus.FAILED
+]
+
+const FAILED_STATUSES = [proto.ETHTxnStatus.DROPPED, proto.ETHTxnStatus.PARTIALLY_FAILED, proto.ETHTxnStatus.FAILED]
 
 export interface RpcRelayerOptions extends BaseRelayerOptions {
   url: string
@@ -39,32 +46,51 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
     this.service = new proto.Relayer(options.url, fetchPonyfill().fetch)
   }
 
-  async waitReceipt(metaTxnHash: string | SignedTransactions, wait: number = 1000): Promise<proto.GetMetaTxnReceiptReturn> {
-    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: string | SignedTransactions,
+    delay: number = 1000,
+    maxFails: number = 5,
+    isCancelled?: () => boolean
+  ): Promise<proto.GetMetaTxnReceiptReturn> {
+    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
-    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 })
+    logger.info(`[rpc-relayer/waitReceipt] waiting for ${metaTxnId}`)
+
+    let fails = 0
+
+    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 as proto.ETHTxnStatus)) {
+          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: string, ...transactions: Transaction[]): Promise<SimulateResult[]> {
@@ -180,7 +206,11 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
     return nonce
   }
 
-  async relay(signedTxs: SignedTransactions, quote?: FeeQuote): Promise<TransactionResponse> {
+  async relay(
+    signedTxs: SignedTransactions,
+    quote?: FeeQuote,
+    waitForReceipt: boolean = true
+  ): Promise<TransactionResponse<RelayerTxReceipt>> {
     logger.info(
       `[rpc-relayer/relay] relaying signed meta-transactions ${JSON.stringify(signedTxs)} with quote ${JSON.stringify(quote)}`
     )
@@ -213,11 +243,58 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
 
     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?: number): Promise<ethers.providers.TransactionReceipt> => Promise.reject(new Error('impossible'))
+      }
+
+      const wait = async (confirmations?: number): Promise<ethers.providers.TransactionReceipt> => {
+        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?.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 as TransactionResponse
+    }
   }
 
-  async wait(metaTxnHash: string | SignedTransactions, wait: number = 1000): Promise<TransactionResponse<RelayerTxReceipt>> {
-    const { receipt } = await this.waitReceipt(metaTxnHash, wait)
+  async wait(
+    metaTxnId: string | SignedTransactions,
+    timeout?: number,
+    delay: number = 1000,
+    maxFails: number = 5
+  ): Promise<TransactionResponse<RelayerTxReceipt>> {
+    let timedOut = false
+
+    const { receipt } = await (timeout !== undefined
+      ? Promise.race([
+          this.waitReceipt(metaTxnId, delay, maxFails, () => timedOut),
+          new Promise<proto.GetMetaTxnReceiptReturn>((_, 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 as proto.ETHTxnStatus)) {
       throw new MetaTransactionResponseException(receipt)
@@ -229,7 +306,7 @@ export class RpcRelayer extends BaseRelayer implements Relayer {
       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