mirror of
https://github.com/kremalicious/metamask-extension.git
synced 2024-11-27 12:56:01 +01:00
645 lines
20 KiB
JavaScript
645 lines
20 KiB
JavaScript
const EventEmitter = require('events')
|
|
const extend = require('xtend')
|
|
const promiseToCallback = require('promise-to-callback')
|
|
const pipe = require('pump')
|
|
const Dnode = require('dnode')
|
|
const ObservableStore = require('obs-store')
|
|
const storeTransform = require('obs-store/lib/transform')
|
|
const EthStore = require('./lib/eth-store')
|
|
const EthQuery = require('eth-query')
|
|
const streamIntoProvider = require('web3-stream-provider/handler')
|
|
const MetaMaskProvider = require('web3-provider-engine/zero.js')
|
|
const setupMultiplex = require('./lib/stream-utils.js').setupMultiplex
|
|
const KeyringController = require('./keyring-controller')
|
|
const PreferencesController = require('./lib/controllers/preferences')
|
|
const NoticeController = require('./notice-controller')
|
|
const MessageManager = require('./lib/message-manager')
|
|
const TxManager = require('./transaction-manager')
|
|
const ConfigManager = require('./lib/config-manager')
|
|
const extension = require('./lib/extension')
|
|
const autoFaucet = require('./lib/auto-faucet')
|
|
const nodeify = require('./lib/nodeify')
|
|
const IdStoreMigrator = require('./lib/idStore-migrator')
|
|
const accountImporter = require('./account-import-strategies')
|
|
|
|
const version = require('../manifest.json').version
|
|
|
|
module.exports = class MetamaskController extends EventEmitter {
|
|
|
|
constructor (opts) {
|
|
super()
|
|
this.opts = opts
|
|
this.state = { network: 'loading' }
|
|
let initState = opts.initState || {}
|
|
|
|
// observable state store
|
|
this.store = new ObservableStore(initState)
|
|
|
|
// config manager
|
|
this.configManager = new ConfigManager({
|
|
store: this.store,
|
|
})
|
|
this.configManager.updateConversionRate()
|
|
|
|
// preferences controller
|
|
this.preferencesController = new PreferencesController({
|
|
initState: initState.PreferencesController,
|
|
})
|
|
|
|
// rpc provider
|
|
this.provider = this.initializeProvider(opts)
|
|
this.provider.on('block', this.logBlock.bind(this))
|
|
this.provider.on('error', this.getNetwork.bind(this))
|
|
|
|
// eth data query tools
|
|
this.ethQuery = new EthQuery(this.provider)
|
|
this.ethStore = new EthStore(this.provider)
|
|
|
|
// key mgmt
|
|
this.keyringController = new KeyringController({
|
|
initState: initState.KeyringController,
|
|
ethStore: this.ethStore,
|
|
configManager: this.configManager,
|
|
getNetwork: this.getStateNetwork.bind(this),
|
|
})
|
|
this.keyringController.on('newAccount', (address) => {
|
|
this.preferencesController.setSelectedAddress(address)
|
|
autoFaucet(address)
|
|
})
|
|
|
|
// tx mgmt
|
|
this.txManager = new TxManager({
|
|
txList: this.configManager.getTxList(),
|
|
txHistoryLimit: 40,
|
|
setTxList: this.configManager.setTxList.bind(this.configManager),
|
|
getSelectedAddress: this.preferencesController.getSelectedAddress.bind(this.preferencesController),
|
|
getGasMultiplier: this.configManager.getGasMultiplier.bind(this.configManager),
|
|
getNetwork: this.getStateNetwork.bind(this),
|
|
signTransaction: this.keyringController.signTransaction.bind(this.keyringController),
|
|
provider: this.provider,
|
|
blockTracker: this.provider,
|
|
})
|
|
|
|
// notices
|
|
this.noticeController = new NoticeController({
|
|
configManager: this.configManager,
|
|
})
|
|
this.noticeController.updateNoticesList()
|
|
// to be uncommented when retrieving notices from a remote server.
|
|
// this.noticeController.startPolling()
|
|
|
|
this.getNetwork()
|
|
this.messageManager = new MessageManager()
|
|
this.publicConfigStore = this.initPublicConfigStore()
|
|
|
|
this.checkTOSChange()
|
|
|
|
this.scheduleConversionInterval()
|
|
|
|
// TEMPORARY UNTIL FULL DEPRECATION:
|
|
this.idStoreMigrator = new IdStoreMigrator({
|
|
configManager: this.configManager,
|
|
})
|
|
|
|
// manual state subscriptions
|
|
this.ethStore.on('update', this.sendUpdate.bind(this))
|
|
this.keyringController.on('update', this.sendUpdate.bind(this))
|
|
this.txManager.on('update', this.sendUpdate.bind(this))
|
|
this.messageManager.on('update', this.sendUpdate.bind(this))
|
|
this.keyringController.store.subscribe((state) => {
|
|
this.store.updateState({ KeyringController: state })
|
|
})
|
|
this.preferencesController.store.subscribe((state) => {
|
|
this.store.updateState({ PreferencesController: state })
|
|
})
|
|
}
|
|
|
|
//
|
|
// Constructor helpers
|
|
//
|
|
|
|
initializeProvider () {
|
|
let provider = MetaMaskProvider({
|
|
static: {
|
|
eth_syncing: false,
|
|
web3_clientVersion: `MetaMask/v${version}`,
|
|
},
|
|
rpcUrl: this.configManager.getCurrentRpcAddress(),
|
|
// account mgmt
|
|
getAccounts: (cb) => {
|
|
let selectedAddress = this.preferencesController.getSelectedAddress()
|
|
let result = selectedAddress ? [selectedAddress] : []
|
|
cb(null, result)
|
|
},
|
|
// tx signing
|
|
processTransaction: (txParams, cb) => this.newUnapprovedTransaction(txParams, cb),
|
|
// msg signing
|
|
processMessage: this.newUnsignedMessage.bind(this),
|
|
})
|
|
return provider
|
|
}
|
|
|
|
initPublicConfigStore () {
|
|
// get init state
|
|
const publicConfigStore = new ObservableStore()
|
|
|
|
// sync publicConfigStore with transform
|
|
pipe(
|
|
this.store,
|
|
storeTransform(selectPublicState),
|
|
publicConfigStore
|
|
)
|
|
|
|
function selectPublicState(state) {
|
|
const result = { selectedAddress: undefined }
|
|
try {
|
|
result.selectedAddress = state.PreferencesController.selectedAddress
|
|
} catch (_) {}
|
|
return result
|
|
}
|
|
|
|
return publicConfigStore
|
|
}
|
|
|
|
//
|
|
// State Management
|
|
//
|
|
|
|
getState () {
|
|
|
|
const wallet = this.configManager.getWallet()
|
|
const vault = this.keyringController.store.getState().vault
|
|
const isInitialized = (!!wallet || !!vault)
|
|
return extend(
|
|
{
|
|
isInitialized,
|
|
},
|
|
this.state,
|
|
this.ethStore.getState(),
|
|
this.txManager.getState(),
|
|
this.messageManager.getState(),
|
|
this.keyringController.getState(),
|
|
this.preferencesController.store.getState(),
|
|
this.noticeController.getState(),
|
|
// config manager
|
|
this.configManager.getConfig(),
|
|
{
|
|
shapeShiftTxList: this.configManager.getShapeShiftTxList(),
|
|
lostAccounts: this.configManager.getLostAccounts(),
|
|
currentFiat: this.configManager.getCurrentFiat(),
|
|
conversionRate: this.configManager.getConversionRate(),
|
|
conversionDate: this.configManager.getConversionDate(),
|
|
}
|
|
)
|
|
}
|
|
|
|
//
|
|
// Remote Features
|
|
//
|
|
|
|
getApi () {
|
|
const keyringController = this.keyringController
|
|
const preferencesController = this.preferencesController
|
|
const txManager = this.txManager
|
|
const messageManager = this.messageManager
|
|
const noticeController = this.noticeController
|
|
|
|
return {
|
|
// etc
|
|
getState: (cb) => cb(null, this.getState()),
|
|
setRpcTarget: this.setRpcTarget.bind(this),
|
|
setProviderType: this.setProviderType.bind(this),
|
|
useEtherscanProvider: this.useEtherscanProvider.bind(this),
|
|
agreeToDisclaimer: this.agreeToDisclaimer.bind(this),
|
|
resetDisclaimer: this.resetDisclaimer.bind(this),
|
|
setCurrentFiat: this.setCurrentFiat.bind(this),
|
|
setTOSHash: this.setTOSHash.bind(this),
|
|
checkTOSChange: this.checkTOSChange.bind(this),
|
|
setGasMultiplier: this.setGasMultiplier.bind(this),
|
|
markAccountsFound: this.markAccountsFound.bind(this),
|
|
// coinbase
|
|
buyEth: this.buyEth.bind(this),
|
|
// shapeshift
|
|
createShapeShiftTx: this.createShapeShiftTx.bind(this),
|
|
|
|
// primary HD keyring management
|
|
addNewAccount: this.addNewAccount.bind(this),
|
|
placeSeedWords: this.placeSeedWords.bind(this),
|
|
clearSeedWordCache: this.clearSeedWordCache.bind(this),
|
|
importAccountWithStrategy: this.importAccountWithStrategy.bind(this),
|
|
|
|
// vault management
|
|
submitPassword: this.submitPassword.bind(this),
|
|
|
|
// PreferencesController
|
|
setSelectedAddress: nodeify(preferencesController.setSelectedAddress).bind(preferencesController),
|
|
|
|
// KeyringController
|
|
setLocked: nodeify(keyringController.setLocked).bind(keyringController),
|
|
createNewVaultAndKeychain: nodeify(keyringController.createNewVaultAndKeychain).bind(keyringController),
|
|
createNewVaultAndRestore: nodeify(keyringController.createNewVaultAndRestore).bind(keyringController),
|
|
addNewKeyring: nodeify(keyringController.addNewKeyring).bind(keyringController),
|
|
saveAccountLabel: nodeify(keyringController.saveAccountLabel).bind(keyringController),
|
|
exportAccount: nodeify(keyringController.exportAccount).bind(keyringController),
|
|
|
|
// signing methods
|
|
approveTransaction: txManager.approveTransaction.bind(txManager),
|
|
cancelTransaction: txManager.cancelTransaction.bind(txManager),
|
|
signMessage: this.signMessage.bind(this),
|
|
cancelMessage: messageManager.rejectMsg.bind(messageManager),
|
|
|
|
// notices
|
|
checkNotices: noticeController.updateNoticesList.bind(noticeController),
|
|
markNoticeRead: noticeController.markNoticeRead.bind(noticeController),
|
|
}
|
|
}
|
|
|
|
setupUntrustedCommunication (connectionStream, originDomain) {
|
|
// setup multiplexing
|
|
var mx = setupMultiplex(connectionStream)
|
|
// connect features
|
|
this.setupProviderConnection(mx.createStream('provider'), originDomain)
|
|
this.setupPublicConfig(mx.createStream('publicConfig'))
|
|
}
|
|
|
|
setupTrustedCommunication (connectionStream, originDomain) {
|
|
// setup multiplexing
|
|
var mx = setupMultiplex(connectionStream)
|
|
// connect features
|
|
this.setupControllerConnection(mx.createStream('controller'))
|
|
this.setupProviderConnection(mx.createStream('provider'), originDomain)
|
|
}
|
|
|
|
setupControllerConnection (outStream) {
|
|
const api = this.getApi()
|
|
const dnode = Dnode(api)
|
|
outStream.pipe(dnode).pipe(outStream)
|
|
dnode.on('remote', (remote) => {
|
|
// push updates to popup
|
|
const sendUpdate = remote.sendUpdate.bind(remote)
|
|
this.on('update', sendUpdate)
|
|
})
|
|
}
|
|
|
|
setupProviderConnection (outStream, originDomain) {
|
|
streamIntoProvider(outStream, this.provider, logger)
|
|
function logger (err, request, response) {
|
|
if (err) return console.error(err)
|
|
if (response.error) {
|
|
console.error('Error in RPC response:\n', response.error)
|
|
}
|
|
if (request.isMetamaskInternal) return
|
|
if (global.METAMASK_DEBUG) {
|
|
console.log(`RPC (${originDomain}):`, request, '->', response)
|
|
}
|
|
}
|
|
}
|
|
|
|
setupPublicConfig (outStream) {
|
|
pipe(
|
|
this.publicConfigStore,
|
|
outStream
|
|
)
|
|
}
|
|
|
|
sendUpdate () {
|
|
this.emit('update', this.getState())
|
|
}
|
|
|
|
//
|
|
// Vault Management
|
|
//
|
|
|
|
submitPassword (password, cb) {
|
|
this.migrateOldVaultIfAny(password)
|
|
.then(this.keyringController.submitPassword.bind(this.keyringController, password))
|
|
.then((newState) => { cb(null, newState) })
|
|
.catch((reason) => { cb(reason) })
|
|
}
|
|
|
|
//
|
|
// Opinionated Keyring Management
|
|
//
|
|
|
|
addNewAccount (cb) {
|
|
const primaryKeyring = this.keyringController.getKeyringsByType('HD Key Tree')[0]
|
|
if (!primaryKeyring) return cb(new Error('MetamaskController - No HD Key Tree found'))
|
|
promiseToCallback(this.keyringController.addNewAccount(primaryKeyring))(cb)
|
|
}
|
|
|
|
// Adds the current vault's seed words to the UI's state tree.
|
|
//
|
|
// Used when creating a first vault, to allow confirmation.
|
|
// Also used when revealing the seed words in the confirmation view.
|
|
placeSeedWords (cb) {
|
|
const primaryKeyring = this.keyringController.getKeyringsByType('HD Key Tree')[0]
|
|
if (!primaryKeyring) return cb(new Error('MetamaskController - No HD Key Tree found'))
|
|
primaryKeyring.serialize()
|
|
.then((serialized) => {
|
|
const seedWords = serialized.mnemonic
|
|
this.configManager.setSeedWords(seedWords)
|
|
promiseToCallback(this.keyringController.fullUpdate())(cb)
|
|
})
|
|
}
|
|
|
|
// ClearSeedWordCache
|
|
//
|
|
// Removes the primary account's seed words from the UI's state tree,
|
|
// ensuring they are only ever available in the background process.
|
|
clearSeedWordCache (cb) {
|
|
this.configManager.setSeedWords(null)
|
|
cb(null, this.preferencesController.getSelectedAddress())
|
|
}
|
|
|
|
importAccountWithStrategy (strategy, args, cb) {
|
|
accountImporter.importAccount(strategy, args)
|
|
.then((privateKey) => {
|
|
return this.keyringController.addNewKeyring('Simple Key Pair', [ privateKey ])
|
|
})
|
|
.then(keyring => keyring.getAccounts())
|
|
.then((accounts) => this.preferencesController.setSelectedAddress(accounts[0]))
|
|
.then(() => { cb(null, this.keyringController.fullUpdate()) })
|
|
.catch((reason) => { cb(reason) })
|
|
}
|
|
|
|
|
|
//
|
|
// Identity Management
|
|
//
|
|
|
|
newUnapprovedTransaction (txParams, cb) {
|
|
const self = this
|
|
self.txManager.addUnapprovedTransaction(txParams, (err, txMeta) => {
|
|
if (err) return cb(err)
|
|
self.sendUpdate()
|
|
self.opts.showUnapprovedTx(txMeta)
|
|
// listen for tx completion (success, fail)
|
|
self.txManager.once(`${txMeta.id}:finished`, (status) => {
|
|
switch (status) {
|
|
case 'submitted':
|
|
return cb(null, txMeta.hash)
|
|
case 'rejected':
|
|
return cb(new Error('MetaMask Tx Signature: User denied transaction signature.'))
|
|
default:
|
|
return cb(new Error(`MetaMask Tx Signature: Unknown problem: ${JSON.stringify(txMeta.txParams)}`))
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
newUnsignedMessage (msgParams, cb) {
|
|
let msgId = this.messageManager.addUnapprovedMessage(msgParams)
|
|
this.sendUpdate()
|
|
this.opts.showUnconfirmedMessage()
|
|
this.messageManager.once(`${msgId}:finished`, (data) => {
|
|
switch (data.status) {
|
|
case 'approved':
|
|
return cb(null, data.rawSig)
|
|
case 'rejected':
|
|
return cb(new Error('MetaMask Message Signature: User denied transaction signature.'))
|
|
default:
|
|
return cb(new Error(`MetaMask Message Signature: Unknown problem: ${JSON.stringify(msgParams)}`))
|
|
}
|
|
})
|
|
}
|
|
|
|
signMessage (msgParams, cb) {
|
|
const msgId = msgParams.metamaskId
|
|
// sets the status op the message to 'approved'
|
|
// and removes the metamaskId for signing
|
|
return this.messageManager.approveMessage(msgParams)
|
|
.then((cleanMsgParams) => {
|
|
// signs the message
|
|
return this.keyringController.signMessage(cleanMsgParams)
|
|
})
|
|
.then((rawSig) => {
|
|
// tells the listener that the message has been signed
|
|
// and can be returned to the dapp
|
|
this.messageManager.brodcastMessage(rawSig, msgId, 'approved')
|
|
}).then(() => {
|
|
cb()
|
|
}).catch((err) => cb(err))
|
|
}
|
|
|
|
|
|
markAccountsFound (cb) {
|
|
this.configManager.setLostAccounts([])
|
|
this.sendUpdate()
|
|
cb(null, this.getState())
|
|
}
|
|
|
|
// Migrate Old Vault If Any
|
|
// @string password
|
|
//
|
|
// returns Promise()
|
|
//
|
|
// Temporary step used when logging in.
|
|
// Checks if old style (pre-3.0.0) Metamask Vault exists.
|
|
// If so, persists that vault in the new vault format
|
|
// with the provided password, so the other unlock steps
|
|
// may be completed without interruption.
|
|
migrateOldVaultIfAny (password) {
|
|
|
|
if (!this.checkIfShouldMigrate()) {
|
|
return Promise.resolve(password)
|
|
}
|
|
|
|
const keyringController = this.keyringController
|
|
|
|
return this.idStoreMigrator.migratedVaultForPassword(password)
|
|
.then(this.restoreOldVaultAccounts.bind(this))
|
|
.then(this.restoreOldLostAccounts.bind(this))
|
|
.then(keyringController.persistAllKeyrings.bind(keyringController, password))
|
|
.then(() => password)
|
|
}
|
|
|
|
checkIfShouldMigrate() {
|
|
return !!this.configManager.getWallet() && !this.configManager.getVault()
|
|
}
|
|
|
|
restoreOldVaultAccounts(migratorOutput) {
|
|
const { serialized } = migratorOutput
|
|
return this.keyringController.restoreKeyring(serialized)
|
|
.then(() => migratorOutput)
|
|
}
|
|
|
|
restoreOldLostAccounts(migratorOutput) {
|
|
const { lostAccounts } = migratorOutput
|
|
if (lostAccounts) {
|
|
this.configManager.setLostAccounts(lostAccounts.map(acct => acct.address))
|
|
return this.importLostAccounts(migratorOutput)
|
|
}
|
|
return Promise.resolve(migratorOutput)
|
|
}
|
|
|
|
// IMPORT LOST ACCOUNTS
|
|
// @Object with key lostAccounts: @Array accounts <{ address, privateKey }>
|
|
// Uses the array's private keys to create a new Simple Key Pair keychain
|
|
// and add it to the keyring controller.
|
|
importLostAccounts ({ lostAccounts }) {
|
|
const privKeys = lostAccounts.map(acct => acct.privateKey)
|
|
return this.keyringController.restoreKeyring({
|
|
type: 'Simple Key Pair',
|
|
data: privKeys,
|
|
})
|
|
}
|
|
|
|
//
|
|
// disclaimer
|
|
//
|
|
|
|
agreeToDisclaimer (cb) {
|
|
try {
|
|
this.configManager.setConfirmedDisclaimer(true)
|
|
cb()
|
|
} catch (err) {
|
|
cb(err)
|
|
}
|
|
}
|
|
|
|
resetDisclaimer () {
|
|
try {
|
|
this.configManager.setConfirmedDisclaimer(false)
|
|
} catch (e) {
|
|
console.error(e)
|
|
}
|
|
}
|
|
|
|
setTOSHash (hash) {
|
|
try {
|
|
this.configManager.setTOSHash(hash)
|
|
} catch (err) {
|
|
console.error('Error in setting terms of service hash.')
|
|
}
|
|
}
|
|
|
|
checkTOSChange () {
|
|
try {
|
|
const storedHash = this.configManager.getTOSHash() || 0
|
|
if (storedHash !== global.TOS_HASH) {
|
|
this.resetDisclaimer()
|
|
this.setTOSHash(global.TOS_HASH)
|
|
}
|
|
} catch (err) {
|
|
console.error('Error in checking TOS change.')
|
|
}
|
|
}
|
|
|
|
//
|
|
// config
|
|
//
|
|
|
|
// Log blocks
|
|
logBlock (block) {
|
|
if (global.METAMASK_DEBUG) {
|
|
console.log(`BLOCK CHANGED: #${block.number.toString('hex')} 0x${block.hash.toString('hex')}`)
|
|
}
|
|
this.verifyNetwork()
|
|
}
|
|
|
|
setCurrentFiat (fiat, cb) {
|
|
try {
|
|
this.configManager.setCurrentFiat(fiat)
|
|
this.configManager.updateConversionRate()
|
|
this.scheduleConversionInterval()
|
|
const data = {
|
|
conversionRate: this.configManager.getConversionRate(),
|
|
currentFiat: this.configManager.getCurrentFiat(),
|
|
conversionDate: this.configManager.getConversionDate(),
|
|
}
|
|
cb(data)
|
|
} catch (err) {
|
|
cb(null, err)
|
|
}
|
|
}
|
|
|
|
scheduleConversionInterval () {
|
|
if (this.conversionInterval) {
|
|
clearInterval(this.conversionInterval)
|
|
}
|
|
this.conversionInterval = setInterval(() => {
|
|
this.configManager.updateConversionRate()
|
|
}, 300000)
|
|
}
|
|
|
|
buyEth (address, amount) {
|
|
if (!amount) amount = '5'
|
|
|
|
var network = this.state.network
|
|
var url = `https://buy.coinbase.com/?code=9ec56d01-7e81-5017-930c-513daa27bb6a&amount=${amount}&address=${address}&crypto_currency=ETH`
|
|
|
|
if (network === '3') {
|
|
url = 'https://faucet.metamask.io/'
|
|
}
|
|
|
|
extension.tabs.create({
|
|
url,
|
|
})
|
|
}
|
|
|
|
createShapeShiftTx (depositAddress, depositType) {
|
|
this.configManager.createShapeShiftTx(depositAddress, depositType)
|
|
}
|
|
|
|
setGasMultiplier (gasMultiplier, cb) {
|
|
try {
|
|
this.configManager.setGasMultiplier(gasMultiplier)
|
|
cb()
|
|
} catch (err) {
|
|
cb(err)
|
|
}
|
|
}
|
|
|
|
//
|
|
// network
|
|
//
|
|
|
|
verifyNetwork () {
|
|
// Check network when restoring connectivity:
|
|
if (this.state.network === 'loading') {
|
|
this.getNetwork()
|
|
}
|
|
}
|
|
|
|
setRpcTarget (rpcTarget) {
|
|
this.configManager.setRpcTarget(rpcTarget)
|
|
extension.runtime.reload()
|
|
this.getNetwork()
|
|
}
|
|
|
|
setProviderType (type) {
|
|
this.configManager.setProviderType(type)
|
|
extension.runtime.reload()
|
|
this.getNetwork()
|
|
}
|
|
|
|
useEtherscanProvider () {
|
|
this.configManager.useEtherscanProvider()
|
|
extension.runtime.reload()
|
|
}
|
|
|
|
getStateNetwork () {
|
|
return this.state.network
|
|
}
|
|
|
|
getNetwork (err) {
|
|
if (err) {
|
|
this.state.network = 'loading'
|
|
this.sendUpdate()
|
|
}
|
|
|
|
this.ethQuery.sendAsync({ method: 'net_version' }, (err, network) => {
|
|
if (err) {
|
|
this.state.network = 'loading'
|
|
return this.sendUpdate()
|
|
}
|
|
if (global.METAMASK_DEBUG) {
|
|
console.log('web3.getNetwork returned ' + network)
|
|
}
|
|
this.state.network = network
|
|
this.sendUpdate()
|
|
})
|
|
}
|
|
|
|
}
|