src/background.js

   1 import { LocalStream } from 'extension-streams'
   2 import InternalMessage from '@/messages/internal'
   3 import * as MsgTypes from './messages/types'
   4 import NotificationService from './services/NotificationService'
   5 import StorageService from './services/StorageService'
   6 import Prompt from './prompts/Prompt';
   7 import * as PromptTypes from './prompts/PromptTypes'
   8
   9 import Error from './utils/errors/Error'
  10
  11 let prompt = null;
  12
  13 export default class Background {
  14   constructor() {
  15     this.setupInternalMessaging()
  16   }
  17
  18   setupInternalMessaging() {
  19     LocalStream.watch((request, sendResponse) => {
  20       console.log(request)
  21       const message = InternalMessage.fromJson(request)
  22       this.dispatchMessage(sendResponse, message)
  23     })
  24   }
  25
  26   dispatchMessage(sendResponse, message) {
  27     switch (message.type) {
  28       case MsgTypes.TRANSFER:
  29         this.transfer(sendResponse, message.payload)
  30         break
  31       case MsgTypes.ADVTRANSFER:
  32         this.advancedTransfer(sendResponse, message.payload)
  33         break
  34       case MsgTypes.SEND:
  35         this.send(sendResponse, message.payload)
  36         break
  37       case MsgTypes.SIGNMESSAGE:
  38         this.signMessage(sendResponse, message.payload)
  39         break
  40       case MsgTypes.REQUEST_CURRENT_ACCOUNT:
  41         this.requestCurrentAccount(sendResponse, message.payload)
  42         break
  43       case MsgTypes.REQUEST_CURRENT_NETWORK:
  44         this.requestCurrentNetwork(sendResponse)
  45         break
  46       case MsgTypes.ENABLE:
  47         Background.authenticate(sendResponse, message.payload)
  48         break
  49       case MsgTypes.SET_PROMPT:
  50         Background.setPrompt(sendResponse, message.payload);
  51         break;
  52       case MsgTypes.GET_PROMPT:
  53         Background.getPrompt(sendResponse);
  54         break;
  55       case MsgTypes.LOAD:
  56         Background.load(sendResponse);
  57         break;
  58       case MsgTypes.UPDATE:
  59         Background.update(sendResponse, message.payload);
  60         break;
  61     }
  62   }
  63
  64   static setPrompt(sendResponse, notification){
  65     prompt = notification;
  66     sendResponse(true);
  67   }
  68
  69   static getPrompt(sendResponse){
  70     sendResponse(prompt);
  71   }
  72
  73   signMessage(sendResponse, payload) {
  74     if(payload.address === undefined){
  75       sendResponse(Error.typeMissed('address'));
  76       return false;
  77     }
  78     if(payload.message === undefined){
  79       sendResponse(Error.typeMissed('message'));
  80       return false;
  81     }
  82
  83     NotificationService.open(new Prompt(PromptTypes.REQUEST_SIGN, '', payload ,approved => {
  84      sendResponse(approved);
  85     }));
  86   }
  87
  88   transfer(sendResponse, payload) {
  89     var promptURL = chrome.extension.getURL('pages/prompt.html')
  90     var requestBody = payload
  91     requestBody.type = "popup"
  92     var queryString = new URLSearchParams(requestBody).toString()
  93     console.log(promptURL, queryString)
  94
  95     if(requestBody.from === undefined){
  96       sendResponse(Error.typeMissed('from'));
  97       return false;
  98     }
  99     if(requestBody.to === undefined){
 100       sendResponse(Error.typeMissed('to'));
 101       return false;
 102     }
 103     if(requestBody.asset === undefined){
 104       sendResponse(Error.typeMissed('asset'));
 105       return false;
 106     }
 107     if(requestBody.amount === undefined){
 108       sendResponse(Error.typeMissed('amount'));
 109       return false;
 110     }
 111
 112
 113       chrome.windows.create(
 114       {
 115         url: `${promptURL}#transfer?${queryString}`,
 116         type: 'popup',
 117         width: 360,
 118         height: 623,
 119         top: 0,
 120         left: 0
 121       },
 122       (window) => {
 123         chrome.runtime.onMessage.addListener(function(request, sender) {
 124           if(sender.tab.windowId === window.id){
 125             switch (request.method){
 126               case 'transfer':
 127                 if (request.action === 'success'){
 128                   sendResponse(request.message);
 129                   return true;
 130                 } else if (request.action === 'reject'){
 131                   sendResponse(request.message);
 132                   return false;
 133                 }
 134             }
 135           }
 136         });
 137
 138         chrome.windows.onRemoved.addListener(function(windowId){
 139           if(windowId === window.id) {
 140             sendResponse(Error.promptClosedWithoutAction());
 141             return false;
 142           }
 143         });
 144       }
 145     )
 146   }
 147
 148   advancedTransfer(sendResponse, payload) {
 149
 150     if(payload.input === undefined){
 151       sendResponse(Error.typeMissed('input'));
 152       return false;
 153     }
 154     if(payload.output === undefined){
 155       sendResponse(Error.typeMissed('output'));
 156       return false;
 157     }
 158     if(payload.gas === undefined){
 159       sendResponse(Error.typeMissed('gas'));
 160       return false;
 161     }
 162
 163     NotificationService.open(new Prompt(PromptTypes.REQUEST_ADVANCED_TRANSFER, '', payload ,approved => {
 164       sendResponse(approved);
 165     }));
 166
 167   }
 168
 169   requestCurrentAccount(sendResponse, payload){
 170     Background.load(bytom => {
 171       const domain = payload.domain;
 172       if(bytom.settings.domains.find(_domain => _domain === domain)) {
 173         const currentAccount =  Object.assign({}, bytom.currentAccount)
 174         delete(currentAccount['label'])
 175         delete(currentAccount['net'])
 176         currentAccount['accountId'] = currentAccount['guid']
 177         delete(currentAccount['guid'])
 178         delete(currentAccount['balance'])
 179
 180         sendResponse(currentAccount);
 181       } else{
 182         sendResponse(null);
 183         return false;
 184       }
 185     })
 186
 187   }
 188
 189   requestCurrentNetwork(sendResponse){
 190     Background.load(bytom => {
 191         sendResponse(bytom.settings.network);
 192     })
 193   }
 194
 195   send(sendResponse, payload) {
 196     const action = payload.action
 197     if(action){
 198       let promise
 199       switch (action){
 200         case 'listAllAccount':
 201           promise = accountAction.list()
 202           break
 203       }
 204       if(promise){
 205         promise.then(resp =>
 206         {
 207           sendResponse(resp)
 208         })
 209       }
 210     }
 211   }
 212
 213   /***
 214    * Returns the saved instance of Bytom from the storage
 215    * @param sendResponse - Delegating response handler
 216    * @returns {Bytom}
 217    */
 218   static load(sendResponse){
 219     StorageService.get().then(bytom => {
 220       sendResponse(bytom)
 221     })
 222   }
 223
 224   /***
 225    * Updates the Scatter instance inside persistent storage
 226    * @param sendResponse - Delegating response handler
 227    * @param bytom - The updated cleartext Scatter instance
 228    * @returns {boolean}
 229    */
 230   static update(sendResponse, bytom){
 231     StorageService.save(bytom).then(saved => {
 232       sendResponse(bytom)
 233     })
 234   }
 235
 236   static authenticate(sendResponse, payload){
 237     Background.load(bytom => {
 238       const domain = payload.domain;
 239       const currentAccount = Object.assign({}, bytom.currentAccount)
 240       delete(currentAccount['label'])
 241       delete(currentAccount['net'])
 242       currentAccount['accountId'] = currentAccount['guid']
 243       delete(currentAccount['guid'])
 244       delete(currentAccount['balance'])
 245
 246       if(bytom.settings.domains.find(_domain => _domain === domain)) {
 247         sendResponse(currentAccount);
 248       } else{
 249         NotificationService.open(new Prompt(PromptTypes.REQUEST_AUTH, payload.domain, {}, approved => {
 250           if(approved === false || approved.hasOwnProperty('isError')) sendResponse(approved);
 251           else {
 252             bytom.settings.domains.unshift(domain);
 253             if(approved === true){
 254               this.update(() => sendResponse(currentAccount), bytom);
 255             }else{
 256               this.update(() => sendResponse(approved), bytom);
 257             }
 258           }
 259         }));
 260       }
 261     })
 262   }
 263
 264
 265 }
 266
 267 new Background()