1
0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-12-23 09:52:26 +01:00
metamask-extension/app/scripts/keyring-controller.js

448 lines
12 KiB
JavaScript
Raw Normal View History

const async = require('async')
const EventEmitter = require('events').EventEmitter
2016-10-19 23:55:08 +02:00
const encryptor = require('./lib/encryptor')
const messageManager = require('./lib/message-manager')
2016-10-21 01:44:31 +02:00
const ethUtil = require('ethereumjs-util')
const ethBinToOps = require('eth-bin-to-ops')
const EthQuery = require('eth-query')
const BN = ethUtil.BN
const Transaction = require('ethereumjs-tx')
const createId = require('web3-provider-engine/util/random-id')
2016-10-19 23:55:08 +02:00
2016-10-21 01:44:31 +02:00
// Keyrings:
const SimpleKeyring = require('./keyrings/simple')
const HdKeyring = require('./keyrings/hd')
2016-10-21 01:44:31 +02:00
const keyringTypes = [
SimpleKeyring,
HdKeyring,
2016-10-21 01:44:31 +02:00
]
2016-10-12 00:09:22 +02:00
module.exports = class KeyringController extends EventEmitter {
2016-10-12 00:09:22 +02:00
constructor (opts) {
super()
this.web3 = opts.web3
2016-10-12 00:09:22 +02:00
this.configManager = opts.configManager
this.ethStore = opts.ethStore
this.encryptor = encryptor
this.keyringTypes = keyringTypes
2016-10-21 01:44:31 +02:00
this.keyrings = []
2016-10-21 02:24:03 +02:00
this.identities = {} // Essentially a name hash
this._unconfTxCbs = {}
this._unconfMsgCbs = {}
2016-10-21 23:11:04 +02:00
this.network = null
2016-10-12 00:09:22 +02:00
}
getState() {
2016-10-19 23:55:08 +02:00
return {
2016-10-20 19:28:45 +02:00
isInitialized: !!this.configManager.getVault(),
2016-10-19 23:55:08 +02:00
isUnlocked: !!this.key,
2016-10-21 01:44:31 +02:00
isConfirmed: true, // AUDIT this.configManager.getConfirmed(),
2016-10-19 23:55:08 +02:00
unconfTxs: this.configManager.unconfirmedTxs(),
transactions: this.configManager.getTxList(),
unconfMsgs: messageManager.unconfirmedMsgs(),
messages: messageManager.getMsgList(),
selectedAddress: this.configManager.getSelectedAccount(),
shapeShiftTxList: this.configManager.getShapeShiftTxList(),
currentFiat: this.configManager.getCurrentFiat(),
conversionRate: this.configManager.getConversionRate(),
conversionDate: this.configManager.getConversionDate(),
keyringTypes: this.keyringTypes.map((krt) => krt.type()),
2016-10-21 01:44:31 +02:00
identities: this.identities,
network: this.network,
2016-10-19 23:55:08 +02:00
}
}
setStore(ethStore) {
this.ethStore = ethStore
}
createNewVault(password, entropy, cb) {
const salt = this.encryptor.generateSalt()
2016-10-20 20:33:18 +02:00
this.configManager.setSalt(salt)
2016-10-20 19:28:45 +02:00
this.loadKey(password)
2016-10-19 23:55:08 +02:00
.then((key) => {
return this.encryptor.encryptWithKey(key, [])
2016-10-19 23:55:08 +02:00
})
2016-10-20 20:33:18 +02:00
.then((encryptedString) => {
2016-10-19 23:55:08 +02:00
this.configManager.setVault(encryptedString)
// TEMPORARY SINGLE-KEYRING CONFIG:
this.addNewKeyring('HD Key Tree', null, cb)
// NORMAL BEHAVIOR:
// cb(null, this.getState())
2016-10-19 23:55:08 +02:00
})
.catch((err) => {
cb(err)
})
}
submitPassword(password, cb) {
2016-10-20 19:28:45 +02:00
this.loadKey(password)
.then((key) => {
2016-10-21 01:44:31 +02:00
return this.unlockKeyrings(key)
})
2016-10-21 02:24:03 +02:00
.then(() => {
cb(null, this.getState())
2016-10-20 19:28:45 +02:00
})
.catch((err) => {
cb(err)
})
}
loadKey(password) {
const salt = this.configManager.getSalt() || this.encryptor.generateSalt()
return this.encryptor.keyFromPassword(password + salt)
2016-10-20 19:28:45 +02:00
.then((key) => {
this.key = key
return key
})
}
2016-10-21 01:44:31 +02:00
addNewKeyring(type, opts, cb) {
const Keyring = this.getKeyringClassForType(type)
const keyring = new Keyring(opts)
const accounts = keyring.addAccounts(1)
this.setupAccounts(accounts)
2016-10-21 02:24:03 +02:00
this.keyrings.push(keyring)
2016-10-21 01:44:31 +02:00
this.persistAllKeyrings()
.then(() => {
cb(null, this.getState())
2016-10-21 01:44:31 +02:00
})
.catch((reason) => {
cb(reason)
})
}
addNewAccount(keyRingNum = 0, cb) {
const ring = this.keyrings[keyRingNum]
const accounts = ring.addAccounts(1)
this.setupAccounts(accounts)
cb(null, this.getState())
}
setupAccounts(accounts) {
const i = this.getAccounts().length
accounts.forEach((account) => {
this.loadBalanceAndNickname(account, i)
})
}
2016-10-21 01:44:31 +02:00
// Takes an account address and an iterator representing
2016-10-21 02:24:03 +02:00
// the current number of named accounts.
loadBalanceAndNickname(account, i) {
const address = ethUtil.addHexPrefix(account)
this.ethStore.addAccount(address)
const oldNickname = this.configManager.nicknameForWallet(address)
const name = oldNickname || `Account ${++i}`
this.identities[address] = {
address,
name,
2016-10-21 01:44:31 +02:00
}
2016-10-21 02:24:03 +02:00
this.saveAccountLabel(address, name)
2016-10-21 01:44:31 +02:00
}
saveAccountLabel (account, label, cb) {
2016-10-21 02:24:03 +02:00
const address = ethUtil.addHexPrefix(account)
2016-10-21 01:44:31 +02:00
const configManager = this.configManager
2016-10-21 02:24:03 +02:00
configManager.setNicknameForWallet(address, label)
2016-10-21 01:44:31 +02:00
if (cb) {
cb(null, label)
}
}
persistAllKeyrings() {
2016-10-21 02:24:03 +02:00
const serialized = this.keyrings.map((k) => {
return {
type: k.type,
// keyring.serialize() must return a JSON-encodable object.
data: k.serialize(),
}
})
return this.encryptor.encryptWithKey(this.key, serialized)
2016-10-21 01:44:31 +02:00
.then((encryptedString) => {
this.configManager.setVault(encryptedString)
return true
})
.catch((reason) => {
console.error('Failed to persist keyrings.', reason)
})
}
unlockKeyrings(key) {
const encryptedVault = this.configManager.getVault()
return this.encryptor.decryptWithKey(key, encryptedVault)
2016-10-21 01:44:31 +02:00
.then((vault) => {
2016-10-21 02:24:03 +02:00
this.keyrings = vault.map(this.restoreKeyring.bind(this, 0))
2016-10-21 01:44:31 +02:00
return this.keyrings
})
}
restoreKeyring(i, serialized) {
2016-10-21 02:24:03 +02:00
const { type, data } = serialized
2016-10-21 01:44:31 +02:00
const Keyring = this.getKeyringClassForType(type)
2016-10-21 02:24:03 +02:00
const keyring = new Keyring()
keyring.deserialize(data)
keyring.getAccounts().forEach((account) => {
this.loadBalanceAndNickname(account, i)
})
2016-10-21 01:44:31 +02:00
return keyring
}
getKeyringClassForType(type) {
const Keyring = this.keyringTypes.reduce((res, kr) => {
2016-10-21 01:44:31 +02:00
if (kr.type() === type) {
return kr
} else {
return res
}
})
return Keyring
}
getAccounts() {
2016-10-21 02:24:03 +02:00
const keyrings = this.keyrings || []
return keyrings.map(kr => kr.getAccounts())
2016-10-21 01:44:31 +02:00
.reduce((res, arr) => {
return res.concat(arr)
}, [])
}
setSelectedAddress(address, cb) {
2016-10-21 01:44:31 +02:00
this.configManager.setSelectedAccount(address)
cb(null, address)
}
addUnconfirmedTransaction(txParams, onTxDoneCb, cb) {
var self = this
const configManager = this.configManager
// create txData obj with parameters and meta data
var time = (new Date()).getTime()
var txId = createId()
txParams.metamaskId = txId
txParams.metamaskNetworkId = this.network
var txData = {
id: txId,
txParams: txParams,
time: time,
status: 'unconfirmed',
gasMultiplier: configManager.getGasMultiplier() || 1,
}
console.log('addUnconfirmedTransaction:', txData)
// keep the onTxDoneCb around for after approval/denial (requires user interaction)
// This onTxDoneCb fires completion to the Dapp's write operation.
this._unconfTxCbs[txId] = onTxDoneCb
var provider = this.ethStore._query.currentProvider
var query = new EthQuery(provider)
// calculate metadata for tx
async.parallel([
analyzeForDelegateCall,
estimateGas,
], didComplete)
// perform static analyis on the target contract code
function analyzeForDelegateCall(cb){
if (txParams.to) {
query.getCode(txParams.to, function (err, result) {
if (err) return cb(err)
var code = ethUtil.toBuffer(result)
if (code !== '0x') {
var ops = ethBinToOps(code)
var containsDelegateCall = ops.some((op) => op.name === 'DELEGATECALL')
txData.containsDelegateCall = containsDelegateCall
cb()
} else {
cb()
}
})
} else {
cb()
}
}
function estimateGas(cb){
query.estimateGas(txParams, function(err, result){
if (err) return cb(err)
txData.estimatedGas = self.addGasBuffer(result)
cb()
})
}
function didComplete (err) {
if (err) return cb(err)
configManager.addTx(txData)
// signal update
self.emit('update')
// signal completion of add tx
cb(null, txData)
}
}
addUnconfirmedMessage(msgParams, cb) {
// create txData obj with parameters and meta data
var time = (new Date()).getTime()
var msgId = createId()
var msgData = {
id: msgId,
msgParams: msgParams,
time: time,
status: 'unconfirmed',
}
messageManager.addMsg(msgData)
console.log('addUnconfirmedMessage:', msgData)
// keep the cb around for after approval (requires user interaction)
// This cb fires completion to the Dapp's write operation.
this._unconfMsgCbs[msgId] = cb
// signal update
this.emit('update')
return msgId
}
approveTransaction(txId, cb) {
const configManager = this.configManager
var approvalCb = this._unconfTxCbs[txId] || noop
// accept tx
cb()
approvalCb(null, true)
// clean up
configManager.confirmTx(txId)
delete this._unconfTxCbs[txId]
this.emit('update')
}
cancelTransaction(txId, cb) {
const configManager = this.configManager
var approvalCb = this._unconfTxCbs[txId] || noop
// reject tx
approvalCb(null, false)
// clean up
configManager.rejectTx(txId)
delete this._unconfTxCbs[txId]
if (cb && typeof cb === 'function') {
cb()
}
}
signTransaction(txParams, cb) {
try {
const address = ethUtil.addHexPrefix(txParams.from.toLowercase())
const keyring = this.getKeyringForAccount(address)
// Handle gas pricing
var gasMultiplier = this.configManager.getGasMultiplier() || 1
var gasPrice = new BN(ethUtil.stripHexPrefix(txParams.gasPrice), 16)
gasPrice = gasPrice.mul(new BN(gasMultiplier * 100, 10)).div(new BN(100, 10))
txParams.gasPrice = ethUtil.intToHex(gasPrice.toNumber())
// normalize values
txParams.to = ethUtil.addHexPrefix(txParams.to.toLowerCase())
txParams.from = ethUtil.addHexPrefix(txParams.from.toLowerCase())
txParams.value = ethUtil.addHexPrefix(txParams.value)
txParams.data = ethUtil.addHexPrefix(txParams.data)
txParams.gasLimit = ethUtil.addHexPrefix(txParams.gasLimit || txParams.gas)
txParams.nonce = ethUtil.addHexPrefix(txParams.nonce)
let tx = new Transaction(txParams)
tx = keyring.signTransaction(address, tx)
// Add the tx hash to the persisted meta-tx object
var txHash = ethUtil.bufferToHex(tx.hash())
var metaTx = this.configManager.getTx(txParams.metamaskId)
metaTx.hash = txHash
this.configManager.updateTx(metaTx)
// return raw serialized tx
var rawTx = ethUtil.bufferToHex(tx.serialize())
cb(null, rawTx)
} catch (e) {
cb(e)
}
}
signMessage(msgParams, cb) {
try {
const keyring = this.getKeyringForAccount(msgParams.from)
const address = ethUtil.addHexPrefix(msgParams.from.toLowercase())
const rawSig = keyring.signMessage(address, msgParams.data)
cb(null, rawSig)
} catch (e) {
cb(e)
}
}
getKeyringForAccount(address) {
const hexed = ethUtil.addHexPrefix(address.toLowerCase())
return this.keyrings.find((ring) => {
return ring.getAccounts()
.map(acct => ethUtil.addHexPrefix(acct.toLowerCase()))
.includes(hexed)
})
}
cancelMessage(msgId, cb) {
if (cb && typeof cb === 'function') {
cb()
}
}
setLocked(cb) {
2016-10-21 20:10:36 +02:00
this.key = null
this.keyrings = []
cb()
}
exportAccount(address, cb) {
cb(null, '0xPrivateKey')
}
tryPassword(password, cb) {
cb()
}
getNetwork(err) {
if (err) {
this.network = 'loading'
this.emit('update')
}
this.web3.version.getNetwork((err, network) => {
if (err) {
this.network = 'loading'
return this.emit('update')
}
if (global.METAMASK_DEBUG) {
console.log('web3.getNetwork returned ' + network)
}
this.network = network
this.emit('update')
})
}
addGasBuffer(gasHex) {
var gas = new BN(gasHex, 16)
var buffer = new BN('100000', 10)
var result = gas.add(buffer)
return ethUtil.addHexPrefix(result.toString(16))
}
2016-10-12 00:09:22 +02:00
}
function noop () {}