Merge pull request #13 from getsumer/ih/sdk-api-routes-refactor

Ih/sdk api routes refactor

Author: Isaac Herrera

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "sumer-sdk",
-  "version": "4.2.4",
+  "version": "4.3.0",
   "description": "A package that allows devs to track the errors that may occur in EVM-based Dapps",
   "main": "build/module/index.js",
   "typings": "build/module/index.d.ts",
@@ -35,17 +35,12 @@
   "dependencies": {
     "@ethersproject/abi": "^5.7.0",
     "@ethersproject/providers": "^5.7.0",
-    "axios": "^1.3.3",
-    "babel-jest": "^27.1.5",
     "bowser": "^2.11.0",
-    "ethers": "^5.7.2",
-    "uuid": "^9.0.0"
+    "ethers": "^5.7.2"
   },
   "bundleDependencies": [
     "@ethersproject/abi",
     "@ethersproject/providers",
-    "axios",
-    "babel-jest",
     "bowser",
     "ethers"
   ],

package.json

@@ -7,11 +7,12 @@ interface ContractErrorArguments {
 }
 
 export class ContractError {
-  public contractAddress: string
-  public signerOrProviderAddress: string
-  public name: string
-  public args: any[]
-  public reason: string
+  public readonly contractAddress: string
+  public readonly signerOrProviderAddress: string
+  public readonly name: string
+  public readonly args: any[]
+  public readonly reason: string
+  public readonly type = 'CONTRACT'
 
   constructor({
     contractAddress,

src/Errors/ContractError.ts

@@ -7,10 +7,11 @@ interface ProviderErrorArguments {
 }
 
 export class ProviderError {
-  public message: string
-  public code: number
-  public address: string
-  public eip: EipError
+  public readonly message: string
+  public readonly code: number
+  public readonly address: string
+  public readonly eip: EipError
+  public readonly type = 'WALLET'
 
   constructor({ message, code, address }: ProviderErrorArguments) {
     this.message = message

src/Errors/ProviderError.ts

@@ -1,8 +1,8 @@
 import { ContractError, ProviderError } from '../Errors'
-import { TransactionData } from '../Types/TransactionData'
+import { Transaction } from '../Types/Transaction'
 
 export interface NotifyService {
   trackError(error: ContractError | ProviderError): Promise<void>
-  trackTransaction(transactionData: TransactionData): Promise<void>
+  trackTransaction(transaction: Transaction): Promise<void>
   checkConnection(): Promise<void>
 }

src/Notify/NotifyService.ts

@@ -1,18 +1,42 @@
-import axios, { RawAxiosRequestHeaders } from 'axios'
-import { v4 } from 'uuid'
-import bowser from 'bowser'
+import bowser, { Parser } from 'bowser'
 import { NotifyService } from './NotifyService'
 import { ProviderError, ContractError } from '../Errors'
-import { TransactionData } from '../Types/TransactionData'
+import { Transaction } from '../Types/Transaction'
+
+interface TransactionBody {
+  chainId: number
+  txHash: string
+  functionName: string
+  functionArgs: any
+  metadata: Parser.ParsedResult | Record<string, string>
+}
+
+interface ErrorBody {
+  userAddress: string
+  message: string
+  errorType: string
+  metadata: Parser.ParsedResult | Record<string, string>
+}
+
+interface ContractErrorBody extends ErrorBody {
+  contractAddress: string
+  functionName: string
+  args: any
+}
+
+interface ProviderErrorBody extends ErrorBody {
+  code: number
+}
 
 export class NotifyServiceApi implements NotifyService {
-  private headers: RawAxiosRequestHeaders
+  private headers: HeadersInit
   private url: string
 
   constructor(apikey: string, chainId?: number, dns?: string) {
     this.headers = {
-      Authorization: `${apikey}`,
-      chainId: `${chainId}`,
+      authorization: `${apikey}`,
+      chainid: `${chainId}`,
+      'Content-Type': 'application/json',
     }
     this.url = dns ?? 'https://api.getsumer.com'
   }
@@ -22,51 +46,59 @@ export class NotifyServiceApi implements NotifyService {
     txHash,
     functionName,
     args,
-  }: TransactionData): Promise<void> {
-    const body = {
-      id: v4(),
+  }: Transaction): Promise<void> {
+    this.fetchPost('transactions', {
       chainId,
       txHash,
       functionName,
       functionArgs: args,
       metadata: this.meta(),
-    }
-    return axios.post(`${this.url}/tx/${body.txHash}`, body, { headers: this.headers })
+    })
   }
 
   public async trackError(error: ContractError | ProviderError): Promise<void> {
+    let body: ContractErrorBody | ProviderErrorBody
     if (error instanceof ContractError) {
-      const body = {
-        id: v4(),
+      body = {
         userAddress: error.signerOrProviderAddress,
         contractAddress: error.contractAddress,
         functionName: error.name,
         args: error.args,
         message: error.reason,
+        errorType: error.type,
         metadata: this.meta(),
       }
-      return axios.post(this.url + '/contract_errors', body, { headers: this.headers })
     } else {
-      const body = {
-        id: v4(),
+      body = {
         userAddress: error.address,
         code: error.code,
         message: error.message,
+        errorType: error.type,
         metadata: this.meta(),
       }
-      return axios.post(`${this.url}/exception`, body, { headers: this.headers })
     }
+    this.fetchPost('errors', body)
   }
 
   public async checkConnection(): Promise<void> {
-    return axios.post(
-      `${this.url}/set_status`,
-      { status: 'provider detected' },
-      { headers: this.headers },
-    )
+    fetch(`${this.url}/check`, {
+      method: 'GET',
+      headers: this.headers,
+    })
+  }
+
+  private fetchPost(
+    uriPath: string,
+    body?: TransactionBody | ContractErrorBody | ProviderErrorBody,
+  ) {
+    fetch(`${this.url}/${uriPath}`, {
+      method: 'POST',
+      headers: this.headers,
+      body: body ? JSON.stringify(body) : undefined,
+    })
   }
 
-  private meta() {
+  private meta(): Parser.ParsedResult | Record<string, string> {
     if (window?.navigator?.userAgent) {
       return bowser.parse(window.navigator.userAgent)
     }

src/Notify/NotifyServiceApi.ts

@@ -1,6 +1,6 @@
 import { NotifyService } from './NotifyService'
 import { ContractError, ProviderError } from '../Errors'
-import { TransactionData } from '../Types/TransactionData'
+import { Transaction } from '../Types/Transaction'
 
 export class NotifyServiceLog implements NotifyService {
   private _chainId: number
@@ -9,8 +9,8 @@ export class NotifyServiceLog implements NotifyService {
     return this._chainId
   }
 
-  public async trackTransaction(transactionData: TransactionData): Promise<void> {
-    console.info('trackTransaction Log:', transactionData)
+  public async trackTransaction(transaction: Transaction): Promise<void> {
+    console.info('trackTransaction Log:', transaction)
   }
 
   public async trackError(msg: ContractError | ProviderError): Promise<void> {

src/Notify/NotifyServiceLog.ts

@@ -3,6 +3,7 @@ import { Fragment, JsonFragment } from '@ethersproject/abi'
 import { Provider } from '@ethersproject/providers'
 import { NotifyService } from './Notify'
 import { ContractError } from './Errors'
+import { Transaction } from './Types/Transaction'
 
 interface SumerContractArguments {
   addressOrName: string
@@ -38,13 +39,13 @@ export class SumerContract {
         return async (...args: any) => {
           try {
             const result = await method.apply(this, args)
-
-            notifyService.trackTransaction({
+            const transaction = new Transaction({
               chainId,
               txHash: result.hash,
               functionName: prop,
               args: args,
             })
+            notifyService.trackTransaction(transaction)
             return result
           } catch (err) {
             let signerOrProviderAddress: string

src/SumerContract.ts

@@ -0,0 +1,20 @@
+interface TransactionArguments {
+  chainId: number
+  txHash: string
+  functionName?: string
+  args?: any[]
+}
+
+export class Transaction {
+  public readonly chainId: number
+  public readonly txHash: string
+  public readonly functionName?: string
+  public readonly args?: any[]
+
+  constructor({ chainId, txHash, functionName, args }: TransactionArguments) {
+    this.chainId = chainId
+    this.txHash = txHash
+    this.functionName = functionName
+    this.args = args
+  }
+}