Merge pull request #26 from getsumer/mmo/feat-wallet-observer

Mmo/feat wallet observer

src/Sumer.ts

@@ -4,7 +4,7 @@ import { Fragment, JsonFragment } from '@ethersproject/abi'
 import { NotifyService, NotifyFactory } from './services'
 import { SumerContract } from './SumerContract'
 import { SumerTarget } from './SumerTarget'
-import { Observer, ErrorObserver, TransactionObserver } from './observers'
+import { Observer, TransactionObserver } from './observers'
 
 declare global {
   interface Window {
@@ -47,11 +47,7 @@ export class Sumer {
     standalone = true,
   }: SumerInitArguments): void {
     this.notifyService = NotifyFactory.create(dappKey, dns)
-    this.sumerObservers = [
-      ...observers,
-      new ErrorObserver(this.notifyService),
-      new TransactionObserver(this.notifyService),
-    ]
+    this.sumerObservers = [...observers, new TransactionObserver(this.notifyService)]
     this._dappKey = dappKey
     this._dns = dns
     this.initializeWindow(standalone)
@@ -92,8 +88,18 @@ export class Sumer {
   private static initializeWindow(standalone?: boolean) {
     if (typeof window !== 'undefined' && !this.isInitialized) {
       const sumerTarget = new SumerTarget(this.sumerObservers)
+
       if (window.ethereum && standalone) {
-        window.ethereum = sumerTarget.proxy(window.ethereum)
+        const desc = Object.getOwnPropertyDescriptor(window, 'ethereum')
+        const isReadOnly = desc && !desc.writable
+
+        if (!isReadOnly) {
+          window.ethereum = sumerTarget.proxy(window.ethereum)
+        } else {
+          console.warn(
+            'Unable to initialize in standalone mode as window.ethereum is set as readonly.',
+          )
+        }
       }
     }
   }

src/SumerContract.ts

@@ -2,7 +2,6 @@ import { Contract, Signer } from 'ethers'
 import { Fragment, JsonFragment } from '@ethersproject/abi'
 import { Provider } from '@ethersproject/providers'
 import { NotifyService } from './services'
-import { ContractError } from './models'
 
 interface SumerContractArguments {
   addressOrName: string
@@ -47,19 +46,7 @@ export class SumerContract {
             })
             return result
           } catch (err) {
-            let signerOrProviderAddress: string
-            if (Signer.isSigner(signerOrProvider)) {
-              signerOrProviderAddress = await signerOrProvider.getAddress()
-            }
-            const contracError = new ContractError({
-              contractAddress: addressOrName,
-              signerOrProviderAddress,
-              name: prop,
-              args,
-              reason: err.reason,
-            })
-
-            notifyService.trackError(contracError)
+            console.info('trackError log: ', err)
             throw err
           }
         }

src/SumerTarget.ts

@@ -65,6 +65,20 @@ export class SumerTarget implements Target {
     if (prop === Symbol.iterator) {
       return target[Symbol.iterator].bind(target)
     }
+
+    // coinbase wallet installed
+    if (target.selectedProvider && target.selectedProvider[prop]) {
+      target = target.selectedProvider
+    }
+
+    // brave wallet installed
+    if (target.isBraveWallet && typeof target.isBraveWallet === 'boolean') {
+      const _target = target[prop]
+      if (!(typeof _target === 'function' && prop === 'request')) {
+        return _target
+      }
+    }
+
     const method = target[prop]
     const methodType = typeof method
     switch (methodType) {

src/models/Transaction.ts

@@ -1,10 +1,13 @@
+import { Parser } from 'bowser'
+
 export interface Transaction {
-  hash: string
+  hash?: string
 
-  to?: string
-  from?: string
+  toAddress?: string
+  fromAddress?: string
   functionName?: string
   args?: any[]
+  gas?: string
 
   // Transaction Response
   nonce?: number
@@ -25,4 +28,12 @@ export interface Transaction {
   effectiveGasPrice?: string
   cumulativeGasUsed?: string
   status?: number
+
+  // Error
+  error?: {
+    code: number
+    message: string
+  }
+
+  metadata?: Parser.ParsedResult | Record<string, string>
 }

src/models/eip/1193.ts

@@ -1,5 +1,9 @@
 // https://eips.ethereum.org/EIPS/eip-1193
-import { EipError } from '../ProviderError'
+export interface EipError {
+  statusCode: number
+  name: string
+  description: string
+}
 
 export const ProviderErrorsEip1193: EipError[] = [
   {

src/models/eip/1474.ts

@@ -1,5 +1,6 @@
 // https://eips.ethereum.org/EIPS/eip-1474
-import { EipError } from '../ProviderError'
+
+import { EipError } from './1193'
 
 export const RPCErrorsEip1474: EipError[] = [
   { statusCode: -32700, name: 'Parse error', description: 'Invalid JSON' },

src/models/index.ts

@@ -1,3 +1 @@
-export * from './ContractError'
-export * from './ProviderError'
 export * from './Transaction'

src/observers/SumerObserver.ts

@@ -1,12 +1,55 @@
-import { Target } from './Target'
+import { Target, TargetExecution } from './Target'
 import { Observer } from './Observer'
 import { NotifyService } from '../services'
+import bowser, { Parser } from 'bowser'
 
+enum Wallet {
+  BRAVEWALLET = 'isBraveWallet',
+  COINBASE = 'isCoinbaseWallet',
+  METAMASK = 'isMetaMask',
+}
 export abstract class SumerObserver implements Observer {
+  private readonly NULL_ADDRESS = '0x0000000000000000000000000000000000000000'
   protected readonly notifyService: NotifyService
+
   constructor(notifyService: NotifyService) {
     this.notifyService = notifyService
   }
 
   public abstract inspect(_target: Target): Promise<void>
+
+  protected getWallet(_executionTarget: Record<string, string | object>): string | undefined {
+    const wallets = {
+      [Wallet.COINBASE]: { addressKey: '_addresses', nameKey: 'Coinbase' },
+      [Wallet.BRAVEWALLET]: { addressKey: 'selectedAddress', nameKey: 'Brave' },
+      [Wallet.METAMASK]: { addressKey: 'selectedAddress', nameKey: 'Metamask' },
+    }
+
+    for (const [walletKey, { addressKey, nameKey }] of Object.entries(wallets)) {
+      if (
+        _executionTarget?.[walletKey] &&
+        typeof _executionTarget[walletKey] === 'boolean' &&
+        _executionTarget[addressKey]
+      ) {
+        return nameKey
+      }
+    }
+    return undefined
+  }
+  protected meta(): Parser.ParsedResult | Record<string, string> {
+    if (window?.navigator?.userAgent) {
+      return bowser.parse(window.navigator.userAgent)
+    }
+    return {}
+  }
+
+  protected getAddress(execution: TargetExecution): string {
+    if (execution.target.selectedAddress) {
+      return execution.target.selectedAddress.toString()
+    }
+    if (execution.target._addresses && execution.target._addresses[0]) {
+      return execution.target._addresses[0].toString()
+    }
+    return this.NULL_ADDRESS
+  }
 }