Extract new relayer endpoints

packages/relayer/src/index.ts

@@ -54,6 +54,17 @@ export interface Relayer {
     delay?: number,
     maxFails?: number
   ): Promise<commons.transaction.TransactionResponse>
+
+  // getMetaTransactions returns a list of meta transactions for a given project and gas tank
+  getMetaTransactions(projectId: number, page?: proto.Page): Promise<{
+    page: proto.Page,
+    transactions: proto.MetaTxnLog[]
+  }>
+
+  // getTransactionCost returns the used fee cost for gas tank during a given period
+  getTransactionCost(projectId: number, from: string, to: string): Promise<{
+    cost: number
+  }>
 }
 
 export * from './local-relayer'

packages/relayer/src/local-relayer.ts

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { logger } from '@0xsequence/utils'
-import { FeeOption, FeeQuote, Relayer } from '.'
+import { FeeOption, FeeQuote, proto, Relayer } from '.'
 import { ProviderRelayer, ProviderRelayerOptions } from './provider-relayer'
 import { commons } from '@0xsequence/core'
 
@@ -76,6 +76,19 @@ export class LocalRelayer extends ProviderRelayer implements Relayer {
       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 }
+  }
 }
 
 function isAbstractSigner(signer: any): signer is ethers.AbstractSigner {

packages/relayer/src/provider-relayer.ts

@@ -1,6 +1,6 @@
 import { ethers } from 'ethers'
 import { walletContracts } from '@0xsequence/abi'
-import { FeeOption, FeeQuote, Relayer, SimulateResult } from '.'
+import { FeeOption, FeeQuote, proto, Relayer, SimulateResult } from '.'
 import { logger, Optionals } from '@0xsequence/utils'
 import { commons } from '@0xsequence/core'
 
@@ -59,6 +59,15 @@ export abstract class ProviderRelayer implements Relayer {
     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[]
+  }>
+
   async simulate(wallet: string, ...transactions: commons.transaction.Transaction[]): Promise<SimulateResult[]> {
     return (
       await Promise.all(
@@ -248,6 +257,8 @@ export abstract class ProviderRelayer implements Relayer {
       return waitReceipt()
     }
   }
+
+
 }
 
 function isAbstractProvider(provider: any): provider is ethers.AbstractProvider {

packages/relayer/src/rpc-relayer/index.ts

@@ -304,6 +304,19 @@ export class RpcRelayer implements Relayer {
       wait: async (confirmations?: number) => this.provider!.waitForTransaction(txReceipt.transactionHash, confirmations)
     } as commons.transaction.TransactionResponse
   }
+
+  async getMetaTransactions(projectId: number,  page?: proto.Page): Promise<{
+    page: proto.Page,
+    transactions: proto.MetaTxnLog[]
+  }> {
+    return this.service.getMetaTransactions({ projectId, page })
+  }
+
+  async getTransactionCost(projectId: number, from: string, to: string): Promise<{
+    cost: number
+  }> {
+    return this.service.getTransactionCost({ projectId, from, to })
+  }
 }
 
 class MetaTransactionResponseException {