more cleanup

src/store/actions.js

@@ -28,7 +28,7 @@ import { remove } from '../utils/httpHelpers'
 import { fakeStream, generateAddressFromPrivateKey, getIFrameOriginObject, isMain, toChecksumAddressByChainId } from '../utils/utils'
 import {
   accountTrackerHandler,
-  announcemenstHandler,
+  announcementsHandler,
   assetControllerHandler,
   billboardHandler,
   detectTokensControllerHandler,
@@ -148,7 +148,7 @@ export default {
     resetStore(prefsController.billboardStore, billboardHandler)
     resetStore(prefsController.successStore, successMessageHandler)
     resetStore(prefsController.errorStore, errorMessageHandler)
-    resetStore(prefsController.announcementsStore, announcemenstHandler)
+    resetStore(prefsController.announcementsStore, announcementsHandler)
     await walletConnectController.disconnect()
     resetStore(walletConnectController.store, walletConnectHandler, {})
     resetStore(txController.etherscanTxStore, etherscanTxHandler, [])
@@ -527,7 +527,7 @@ export default {
     prefsController.errorStore.subscribe(errorMessageHandler)
     prefsController.billboardStore.subscribe(billboardHandler)
     prefsController.store.subscribe(prefsControllerHandler)
-    prefsController.announcementsStore.subscribe(announcemenstHandler)
+    prefsController.announcementsStore.subscribe(announcementsHandler)
     txController.etherscanTxStore.subscribe(etherscanTxHandler)
     walletConnectController.store.subscribe(walletConnectHandler)
     encryptionPublicKeyManager.store.subscribe(encryptionPublicKeyHandler)

src/store/controllerSubscriptions.js

@@ -152,6 +152,6 @@ export function unapprovedAssetMsgsHandler({ unApprovedAssets }) {
   getStore().commit('setUnapprovedAssets', unApprovedAssets)
 }
 
-export function announcemenstHandler(state) {
+export function announcementsHandler(state) {
   getStore().commit('setAnnouncements', state)
 }

src/store/setupStoreChannels.js

@@ -3,8 +3,7 @@ import log from 'loglevel'
 import pump from 'pump'
 import stream from 'stream'
 
-import { injectStore as onloadInjection } from '../onload'
-import torus from '../torus'
+import torus, { injectStore as onloadInjection } from '../torus'
 import { SUPPORTED_NETWORK_TYPES } from '../utils/enums'
 import { broadcastChannelOptions, isMain } from '../utils/utils'
 import { injectStore as controllerInjection } from './controllerSubscriptions'

src/torus.js

@@ -1,5 +1,109 @@
-import onloadTorus from './onload'
+import { BasePostMessageStream } from '@toruslabs/openlogin-jrpc'
+import { randomId } from '@toruslabs/openlogin-utils'
+import log from 'loglevel'
+import Web3 from 'web3'
 
-const torus = onloadTorus()
+import config from './config'
+import TorusController from './controllers/TorusController'
+import setupMultiplex from './controllers/utils/setupMultiplex'
+import { MAINNET, SUPPORTED_NETWORK_TYPES } from './utils/enums'
+import { getIFrameOrigin, getIFrameOriginObject, isMain } from './utils/utils'
+// import store from './store'
+let storeReference
+let deferredDispatch = []
+function getStore() {
+  return (
+    storeReference || {
+      dispatch(...arguments_) {
+        deferredDispatch.push(() => {
+          storeReference.dispatch(...arguments_)
+        })
+      },
+    }
+  )
+}
+
+export function injectStore(s) {
+  storeReference = s
+  deferredDispatch.forEach((fn) => fn())
+  deferredDispatch = []
+}
+
+function triggerUi(type, payload, request) {
+  log.info(`TRIGGERUI:${type}`, payload, request)
+  getStore().dispatch('showPopup', { payload, request })
+}
+
+const torus = {
+  instanceId: randomId(),
+}
+let sessionData
+
+if (config.localStorageAvailable) {
+  const storage = !isMain ? (config.isCustomLogin === null ? window.sessionStorage : window.localStorage) : window.localStorage
+  const storageKey = config.isCustomLogin === true ? `torus_app_${getIFrameOriginObject().hostname}` : 'torus-app'
+  sessionData = storage.getItem(storageKey)
+}
+
+const sessionCachedNetwork = (sessionData && JSON.parse(sessionData).networkType) || SUPPORTED_NETWORK_TYPES[MAINNET]
+const customNetworks = (sessionData && JSON.parse(sessionData).customNetworks) || {}
+
+const torusController = new TorusController({
+  initState: {
+    NetworkController: {
+      provider: sessionCachedNetwork,
+      customNetworks,
+    },
+  },
+  showUnconfirmedMessage: triggerUi.bind(window, 'showUnconfirmedMessage'),
+  unlockAccountMessage: triggerUi.bind(window, 'unlockAccountMessage'),
+  showUnapprovedTx: triggerUi.bind(window, 'showUnapprovedTx'),
+  openPopup: triggerUi.bind(window, 'bindopenPopup'),
+  storeProps: () => {
+    const { state } = getStore()
+    const { selectedAddress, wallet } = state || {}
+    return { selectedAddress, wallet }
+  },
+  storeDispatch: () => getStore().dispatch,
+})
+
+torus.torusController = torusController
+
+torusController.provider.setMaxListeners(100)
+torus.web3 = new Web3(torusController.provider)
+log.info('torus network', process.env.VUE_APP_PROXY_NETWORK)
+
+// we use this to start accounttracker balances
+torusController.setupControllerConnection()
+
+if (!isMain) {
+  const iframeOrigin = getIFrameOrigin()
+  log.info('iframe origin', iframeOrigin)
+  const metamaskStream = new BasePostMessageStream({
+    name: 'iframe_metamask',
+    target: 'embed_metamask',
+    targetWindow: window.parent,
+    targetOrigin: iframeOrigin,
+  })
+
+  const communicationStream = new BasePostMessageStream({
+    name: 'iframe_comm',
+    target: 'embed_comm',
+    targetWindow: window.parent,
+    targetOrigin: iframeOrigin,
+  })
+
+  torus.metamaskMux = setupMultiplex(metamaskStream)
+  torus.communicationMux = setupMultiplex(communicationStream)
+  torus.communicationMux.setMaxListeners(50)
+
+  const providerOutStream = torus.metamaskMux.getStream('provider')
+
+  torusController.setupUntrustedCommunication(providerOutStream, iframeOrigin)
+
+  const publicConfOutStream = torus.metamaskMux.getStream('publicConfig')
+
+  torusController.setupPublicConfig(publicConfOutStream)
+}
 
 export default torus