import assert from 'assert' import sinon from 'sinon' import { cloneDeep } from 'lodash' import nock from 'nock' import ethUtil from 'ethereumjs-util' import { obj as createThoughStream } from 'through2' import blacklistJSON from 'eth-phishing-detect/src/config' import firstTimeState from '../../localhostState' import createTxMeta from '../../../lib/createTxMeta' import EthQuery from 'eth-query' const threeBoxSpies = { init: sinon.stub(), getThreeBoxSyncingState: sinon.stub().returns(true), turnThreeBoxSyncingOn: sinon.stub(), _registerUpdates: sinon.spy(), } import proxyquire from 'proxyquire' class ThreeBoxControllerMock { constructor () { this.store = { subscribe: () => {}, getState: () => ({}), } this.init = threeBoxSpies.init this.getThreeBoxSyncingState = threeBoxSpies.getThreeBoxSyncingState this.turnThreeBoxSyncingOn = threeBoxSpies.turnThreeBoxSyncingOn this._registerUpdates = threeBoxSpies._registerUpdates } } const ExtensionizerMock = { runtime: { id: 'fake-extension-id', }, } const MetaMaskController = proxyquire('../../../../app/scripts/metamask-controller', { './controllers/threebox': { default: ThreeBoxControllerMock }, 'extensionizer': ExtensionizerMock, }).default const currentNetworkId = 42 const DEFAULT_LABEL = 'Account 1' const DEFAULT_LABEL_2 = 'Account 2' const TEST_SEED = 'debris dizzy just program just float decrease vacant alarm reduce speak stadium' const TEST_ADDRESS = '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc' const TEST_ADDRESS_2 = '0xec1adf982415d2ef5ec55899b9bfb8bc0f29251b' const TEST_ADDRESS_3 = '0xeb9e64b93097bc15f01f13eae97015c57ab64823' const TEST_SEED_ALT = 'setup olympic issue mobile velvet surge alcohol burger horse view reopen gentle' const TEST_ADDRESS_ALT = '0xc42edfcc21ed14dda456aa0756c153f7985d8813' const CUSTOM_RPC_URL = 'http://localhost:8545' describe('MetaMaskController', function () { let metamaskController const sandbox = sinon.createSandbox() const noop = () => {} beforeEach(function () { nock('https://api.infura.io') .persist() .get('/v2/blacklist') .reply(200, blacklistJSON) nock('https://api.infura.io') .get('/v1/ticker/ethusd') .reply(200, '{"base": "ETH", "quote": "USD", "bid": 288.45, "ask": 288.46, "volume": 112888.17569277, "exchange": "bitfinex", "total_volume": 272175.00106721005, "num_exchanges": 8, "timestamp": 1506444677}') nock('https://api.infura.io') .get('/v1/ticker/ethjpy') .reply(200, '{"base": "ETH", "quote": "JPY", "bid": 32300.0, "ask": 32400.0, "volume": 247.4616071, "exchange": "kraken", "total_volume": 247.4616071, "num_exchanges": 1, "timestamp": 1506444676}') nock('https://api.infura.io') .persist() .get(/.*/) .reply(200) nock('https://min-api.cryptocompare.com') .persist() .get(/.*/) .reply(200, '{"JPY":12415.9}') metamaskController = new MetaMaskController({ showUnapprovedTx: noop, showUnconfirmedMessage: noop, encryptor: { encrypt: function (_, object) { this.object = object return Promise.resolve('mock-encrypted') }, decrypt: function () { return Promise.resolve(this.object) }, }, initState: cloneDeep(firstTimeState), platform: { showTransactionNotification: () => {} }, }) // disable diagnostics metamaskController.diagnostics = null // add sinon method spies sandbox.spy(metamaskController.keyringController, 'createNewVaultAndKeychain') sandbox.spy(metamaskController.keyringController, 'createNewVaultAndRestore') sandbox.spy(metamaskController.txController, 'newUnapprovedTransaction') }) afterEach(function () { nock.cleanAll() sandbox.restore() }) describe('#getAccounts', function () { it('returns first address when dapp calls web3.eth.getAccounts', async function () { const password = 'a-fake-password' await metamaskController.createNewVaultAndRestore(password, TEST_SEED) metamaskController.networkController._baseProviderParams.getAccounts((err, res) => { assert.ifError(err) assert.equal(res.length, 1) assert.equal(res[0], '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc') }) }) }) describe('#importAccountWithStrategy', function () { const importPrivkey = '4cfd3e90fc78b0f86bf7524722150bb8da9c60cd532564d7ff43f5716514f553' beforeEach(async function () { const password = 'a-fake-password' await metamaskController.createNewVaultAndRestore(password, TEST_SEED) await metamaskController.importAccountWithStrategy('Private Key', [ importPrivkey ]) }) it('adds private key to keyrings in KeyringController', async function () { const simpleKeyrings = metamaskController.keyringController.getKeyringsByType('Simple Key Pair') const privKeyBuffer = simpleKeyrings[0].wallets[0]._privKey const pubKeyBuffer = simpleKeyrings[0].wallets[0]._pubKey const addressBuffer = ethUtil.pubToAddress(pubKeyBuffer) const privKey = ethUtil.bufferToHex(privKeyBuffer) const pubKey = ethUtil.bufferToHex(addressBuffer) assert.equal(privKey, ethUtil.addHexPrefix(importPrivkey)) assert.equal(pubKey, '0xe18035bf8712672935fdb4e5e431b1a0183d2dfc') }) it('adds 1 account', async function () { const keyringAccounts = await metamaskController.keyringController.getAccounts() assert.equal(keyringAccounts[keyringAccounts.length - 1], '0xe18035bf8712672935fdb4e5e431b1a0183d2dfc') }) }) describe('submitPassword', function () { const password = 'password' beforeEach(async function () { await metamaskController.createNewVaultAndKeychain(password) threeBoxSpies.init.reset() threeBoxSpies.turnThreeBoxSyncingOn.reset() }) it('removes any identities that do not correspond to known accounts.', async function () { const fakeAddress = '0xbad0' metamaskController.preferencesController.addAddresses([fakeAddress]) await metamaskController.submitPassword(password) const identities = Object.keys(metamaskController.preferencesController.store.getState().identities) const addresses = await metamaskController.keyringController.getAccounts() identities.forEach((identity) => { assert.ok(addresses.includes(identity), `addresses should include all IDs: ${identity}`) }) addresses.forEach((address) => { assert.ok(identities.includes(address), `identities should include all Addresses: ${address}`) }) }) it('gets the address from threebox and creates a new 3box instance', async function () { await metamaskController.submitPassword(password) assert(threeBoxSpies.init.calledOnce) assert(threeBoxSpies.turnThreeBoxSyncingOn.calledOnce) }) }) describe('#getGasPrice', function () { it('gives the 50th percentile lowest accepted gas price from recentBlocksController', async function () { const realRecentBlocksController = metamaskController.recentBlocksController metamaskController.recentBlocksController = { store: { getState: () => { return { recentBlocks: [ { gasPrices: [ '0x3b9aca00', '0x174876e800'] }, { gasPrices: [ '0x3b9aca00', '0x174876e800'] }, { gasPrices: [ '0x174876e800', '0x174876e800' ] }, { gasPrices: [ '0x174876e800', '0x174876e800' ] }, ], } }, }, } const gasPrice = metamaskController.getGasPrice() assert.equal(gasPrice, '0x174876e800', 'accurately estimates 65th percentile accepted gas price') metamaskController.recentBlocksController = realRecentBlocksController }) }) describe('#createNewVaultAndKeychain', function () { it('can only create new vault on keyringController once', async function () { const selectStub = sandbox.stub(metamaskController, 'selectFirstIdentity') const password = 'a-fake-password' await metamaskController.createNewVaultAndKeychain(password) await metamaskController.createNewVaultAndKeychain(password) assert(metamaskController.keyringController.createNewVaultAndKeychain.calledOnce) selectStub.reset() }) }) describe('#createNewVaultAndRestore', function () { it('should be able to call newVaultAndRestore despite a mistake.', async function () { const password = 'what-what-what' sandbox.stub(metamaskController, 'getBalance') metamaskController.getBalance.callsFake(() => { return Promise.resolve('0x0') }) await metamaskController.createNewVaultAndRestore(password, TEST_SEED.slice(0, -1)).catch(() => null) await metamaskController.createNewVaultAndRestore(password, TEST_SEED) assert(metamaskController.keyringController.createNewVaultAndRestore.calledTwice) }) it('should clear previous identities after vault restoration', async function () { sandbox.stub(metamaskController, 'getBalance') metamaskController.getBalance.callsFake(() => { return Promise.resolve('0x0') }) let startTime = Date.now() await metamaskController.createNewVaultAndRestore('foobar1337', TEST_SEED) let endTime = Date.now() const firstVaultIdentities = cloneDeep(metamaskController.getState().identities) assert.ok( ( firstVaultIdentities[TEST_ADDRESS].lastSelected >= startTime && firstVaultIdentities[TEST_ADDRESS].lastSelected <= endTime ), `'${firstVaultIdentities[TEST_ADDRESS].lastSelected}' expected to be between '${startTime}' and '${endTime}'` ) delete firstVaultIdentities[TEST_ADDRESS].lastSelected assert.deepEqual(firstVaultIdentities, { [TEST_ADDRESS]: { address: TEST_ADDRESS, name: DEFAULT_LABEL }, }) await metamaskController.preferencesController.setAccountLabel(TEST_ADDRESS, 'Account Foo') const labelledFirstVaultIdentities = cloneDeep(metamaskController.getState().identities) delete labelledFirstVaultIdentities[TEST_ADDRESS].lastSelected assert.deepEqual(labelledFirstVaultIdentities, { [TEST_ADDRESS]: { address: TEST_ADDRESS, name: 'Account Foo' }, }) startTime = Date.now() await metamaskController.createNewVaultAndRestore('foobar1337', TEST_SEED_ALT) endTime = Date.now() const secondVaultIdentities = cloneDeep(metamaskController.getState().identities) assert.ok( ( secondVaultIdentities[TEST_ADDRESS_ALT].lastSelected >= startTime && secondVaultIdentities[TEST_ADDRESS_ALT].lastSelected <= endTime ), `'${secondVaultIdentities[TEST_ADDRESS_ALT].lastSelected}' expected to be between '${startTime}' and '${endTime}'` ) delete secondVaultIdentities[TEST_ADDRESS_ALT].lastSelected assert.deepEqual(secondVaultIdentities, { [TEST_ADDRESS_ALT]: { address: TEST_ADDRESS_ALT, name: DEFAULT_LABEL }, }) }) it('should restore any consecutive accounts with balances', async function () { sandbox.stub(metamaskController, 'getBalance') metamaskController.getBalance.withArgs(TEST_ADDRESS).callsFake(() => { return Promise.resolve('0x14ced5122ce0a000') }) metamaskController.getBalance.withArgs(TEST_ADDRESS_2).callsFake(() => { return Promise.resolve('0x0') }) metamaskController.getBalance.withArgs(TEST_ADDRESS_3).callsFake(() => { return Promise.resolve('0x14ced5122ce0a000') }) const startTime = Date.now() await metamaskController.createNewVaultAndRestore('foobar1337', TEST_SEED) const identities = cloneDeep(metamaskController.getState().identities) assert.ok(identities[TEST_ADDRESS].lastSelected >= startTime && identities[TEST_ADDRESS].lastSelected <= Date.now()) delete identities[TEST_ADDRESS].lastSelected assert.deepEqual(identities, { [TEST_ADDRESS]: { address: TEST_ADDRESS, name: DEFAULT_LABEL }, [TEST_ADDRESS_2]: { address: TEST_ADDRESS_2, name: DEFAULT_LABEL_2 }, }) }) }) describe('#getBalance', function () { it('should return the balance known by accountTracker', async function () { const accounts = {} const balance = '0x14ced5122ce0a000' accounts[TEST_ADDRESS] = { balance: balance } metamaskController.accountTracker.store.putState({ accounts: accounts }) const gotten = await metamaskController.getBalance(TEST_ADDRESS) assert.equal(balance, gotten) }) it('should ask the network for a balance when not known by accountTracker', async function () { const accounts = {} const balance = '0x14ced5122ce0a000' const ethQuery = new EthQuery() sinon.stub(ethQuery, 'getBalance').callsFake((_, callback) => { callback(undefined, balance) }) metamaskController.accountTracker.store.putState({ accounts: accounts }) const gotten = await metamaskController.getBalance(TEST_ADDRESS, ethQuery) assert.equal(balance, gotten) }) }) describe('#getApi', function () { it('getState', function (done) { let state const getApi = metamaskController.getApi() getApi.getState((err, res) => { if (err) { done(err) } else { state = res } }) assert.deepEqual(state, metamaskController.getState()) done() }) }) describe('preferencesController', function () { it('defaults useBlockie to false', function () { assert.equal(metamaskController.preferencesController.store.getState().useBlockie, false) }) it('setUseBlockie to true', function () { metamaskController.setUseBlockie(true, noop) assert.equal(metamaskController.preferencesController.store.getState().useBlockie, true) }) }) describe('#selectFirstIdentity', function () { let identities, address beforeEach(function () { address = '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc' identities = { '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc': { 'address': address, 'name': 'Account 1', }, '0xc42edfcc21ed14dda456aa0756c153f7985d8813': { 'address': '0xc42edfcc21ed14dda456aa0756c153f7985d8813', 'name': 'Account 2', }, } metamaskController.preferencesController.store.updateState({ identities }) metamaskController.selectFirstIdentity() }) it('changes preferences controller select address', function () { const preferenceControllerState = metamaskController.preferencesController.store.getState() assert.equal(preferenceControllerState.selectedAddress, address) }) it('changes metamask controller selected address', function () { const metamaskState = metamaskController.getState() assert.equal(metamaskState.selectedAddress, address) }) }) describe('connectHardware', function () { it('should throw if it receives an unknown device name', async function () { try { await metamaskController.connectHardware('Some random device name', 0, `m/44/0'/0'`) } catch (e) { assert.equal(e, 'Error: MetamaskController:getKeyringForDevice - Unknown device') } }) it('should add the Trezor Hardware keyring', async function () { sinon.spy(metamaskController.keyringController, 'addNewKeyring') await metamaskController.connectHardware('trezor', 0).catch(() => null) const keyrings = await metamaskController.keyringController.getKeyringsByType( 'Trezor Hardware' ) assert.equal(metamaskController.keyringController.addNewKeyring.getCall(0).args, 'Trezor Hardware') assert.equal(keyrings.length, 1) }) it('should add the Ledger Hardware keyring', async function () { sinon.spy(metamaskController.keyringController, 'addNewKeyring') await metamaskController.connectHardware('ledger', 0).catch(() => null) const keyrings = await metamaskController.keyringController.getKeyringsByType( 'Ledger Hardware' ) assert.equal(metamaskController.keyringController.addNewKeyring.getCall(0).args, 'Ledger Hardware') assert.equal(keyrings.length, 1) }) }) describe('checkHardwareStatus', function () { it('should throw if it receives an unknown device name', async function () { try { await metamaskController.checkHardwareStatus('Some random device name', `m/44/0'/0'`) } catch (e) { assert.equal(e, 'Error: MetamaskController:getKeyringForDevice - Unknown device') } }) it('should be locked by default', async function () { await metamaskController.connectHardware('trezor', 0).catch(() => null) const status = await metamaskController.checkHardwareStatus('trezor') assert.equal(status, false) }) }) describe('forgetDevice', function () { it('should throw if it receives an unknown device name', async function () { try { await metamaskController.forgetDevice('Some random device name') } catch (e) { assert.equal(e, 'Error: MetamaskController:getKeyringForDevice - Unknown device') } }) it('should wipe all the keyring info', async function () { await metamaskController.connectHardware('trezor', 0).catch(() => null) await metamaskController.forgetDevice('trezor') const keyrings = await metamaskController.keyringController.getKeyringsByType( 'Trezor Hardware' ) assert.deepEqual(keyrings[0].accounts, []) assert.deepEqual(keyrings[0].page, 0) assert.deepEqual(keyrings[0].isUnlocked(), false) }) }) describe('unlockHardwareWalletAccount', function () { let accountToUnlock let windowOpenStub let addNewAccountStub let getAccountsStub beforeEach(async function () { accountToUnlock = 10 windowOpenStub = sinon.stub(window, 'open') windowOpenStub.returns(noop) addNewAccountStub = sinon.stub(metamaskController.keyringController, 'addNewAccount') addNewAccountStub.returns({}) getAccountsStub = sinon.stub(metamaskController.keyringController, 'getAccounts') // Need to return different address to mock the behavior of // adding a new account from the keyring getAccountsStub.onCall(0).returns(Promise.resolve(['0x1'])) getAccountsStub.onCall(1).returns(Promise.resolve(['0x2'])) getAccountsStub.onCall(2).returns(Promise.resolve(['0x3'])) getAccountsStub.onCall(3).returns(Promise.resolve(['0x4'])) sinon.spy(metamaskController.preferencesController, 'setAddresses') sinon.spy(metamaskController.preferencesController, 'setSelectedAddress') sinon.spy(metamaskController.preferencesController, 'setAccountLabel') await metamaskController.connectHardware('trezor', 0, `m/44/0'/0'`).catch(() => null) await metamaskController.unlockHardwareWalletAccount(accountToUnlock, 'trezor', `m/44/0'/0'`) }) afterEach(function () { window.open.restore() metamaskController.keyringController.addNewAccount.restore() metamaskController.keyringController.getAccounts.restore() metamaskController.preferencesController.setAddresses.restore() metamaskController.preferencesController.setSelectedAddress.restore() metamaskController.preferencesController.setAccountLabel.restore() }) it('should set unlockedAccount in the keyring', async function () { const keyrings = await metamaskController.keyringController.getKeyringsByType( 'Trezor Hardware' ) assert.equal(keyrings[0].unlockedAccount, accountToUnlock) }) it('should call keyringController.addNewAccount', async function () { assert(metamaskController.keyringController.addNewAccount.calledOnce) }) it('should call keyringController.getAccounts ', async function () { assert(metamaskController.keyringController.getAccounts.called) }) it('should call preferencesController.setAddresses', async function () { assert(metamaskController.preferencesController.setAddresses.calledOnce) }) it('should call preferencesController.setSelectedAddress', async function () { assert(metamaskController.preferencesController.setSelectedAddress.calledOnce) }) it('should call preferencesController.setAccountLabel', async function () { assert(metamaskController.preferencesController.setAccountLabel.calledOnce) }) }) describe('#setCustomRpc', function () { let rpcTarget beforeEach(function () { rpcTarget = metamaskController.setCustomRpc(CUSTOM_RPC_URL) }) it('returns custom RPC that when called', async function () { assert.equal(await rpcTarget, CUSTOM_RPC_URL) }) it('changes the network controller rpc', function () { const networkControllerState = metamaskController.networkController.store.getState() assert.equal(networkControllerState.provider.rpcTarget, CUSTOM_RPC_URL) }) }) describe('#setCurrentCurrency', function () { let defaultMetaMaskCurrency beforeEach(function () { defaultMetaMaskCurrency = metamaskController.currencyRateController.state.currentCurrency }) it('defaults to usd', function () { assert.equal(defaultMetaMaskCurrency, 'usd') }) it('sets currency to JPY', function () { metamaskController.setCurrentCurrency('JPY', noop) assert.equal(metamaskController.currencyRateController.state.currentCurrency, 'JPY') }) }) describe('#addNewAccount', function () { it('errors when an primary keyring is does not exist', async function () { const addNewAccount = metamaskController.addNewAccount() try { await addNewAccount assert.fail('should throw') } catch (e) { assert.equal(e.message, 'MetamaskController - No HD Key Tree found') } }) }) describe('#verifyseedPhrase', function () { it('errors when no keying is provided', async function () { try { await metamaskController.verifySeedPhrase() } catch (error) { assert.equal(error.message, 'MetamaskController - No HD Key Tree found') } }) beforeEach(async function () { await metamaskController.createNewVaultAndKeychain('password') }) it('#addNewAccount', async function () { await metamaskController.addNewAccount() const getAccounts = await metamaskController.keyringController.getAccounts() assert.equal(getAccounts.length, 2) }) }) describe('#resetAccount', function () { it('wipes transactions from only the correct network id and with the selected address', async function () { const selectedAddressStub = sinon.stub(metamaskController.preferencesController, 'getSelectedAddress') const getNetworkstub = sinon.stub(metamaskController.txController.txStateManager, 'getNetwork') selectedAddressStub.returns('0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc') getNetworkstub.returns(42) metamaskController.txController.txStateManager._saveTxList([ createTxMeta({ id: 1, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: { from: '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc' } }), createTxMeta({ id: 1, status: 'unapproved', metamaskNetworkId: currentNetworkId, txParams: { from: '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc' } }), createTxMeta({ id: 2, status: 'rejected', metamaskNetworkId: 32 }), createTxMeta({ id: 3, status: 'submitted', metamaskNetworkId: currentNetworkId, txParams: { from: '0xB09d8505E1F4EF1CeA089D47094f5DD3464083d4' } }), ]) await metamaskController.resetAccount() assert.equal(metamaskController.txController.txStateManager.getTx(1), undefined) }) }) describe('#removeAccount', function () { let ret const addressToRemove = '0x1' beforeEach(async function () { sinon.stub(metamaskController.preferencesController, 'removeAddress') sinon.stub(metamaskController.accountTracker, 'removeAccount') sinon.stub(metamaskController.keyringController, 'removeAccount') ret = await metamaskController.removeAccount(addressToRemove) }) afterEach(function () { metamaskController.keyringController.removeAccount.restore() metamaskController.accountTracker.removeAccount.restore() metamaskController.preferencesController.removeAddress.restore() }) it('should call preferencesController.removeAddress', async function () { assert(metamaskController.preferencesController.removeAddress.calledWith(addressToRemove)) }) it('should call accountTracker.removeAccount', async function () { assert(metamaskController.accountTracker.removeAccount.calledWith([addressToRemove])) }) it('should call keyringController.removeAccount', async function () { assert(metamaskController.keyringController.removeAccount.calledWith(addressToRemove)) }) it('should return address', async function () { assert.equal(ret, '0x1') }) }) describe('#setCurrentLocale', function () { it('checks the default currentLocale', function () { const preferenceCurrentLocale = metamaskController.preferencesController.store.getState().currentLocale assert.equal(preferenceCurrentLocale, undefined) }) it('sets current locale in preferences controller', function () { metamaskController.setCurrentLocale('ja', noop) const preferenceCurrentLocale = metamaskController.preferencesController.store.getState().currentLocale assert.equal(preferenceCurrentLocale, 'ja') }) }) describe('#newUnsignedMessage', function () { let msgParams, metamaskMsgs, messages, msgId const address = '0xc42edfcc21ed14dda456aa0756c153f7985d8813' const data = '0x43727970746f6b697474696573' beforeEach(async function () { sandbox.stub(metamaskController, 'getBalance') metamaskController.getBalance.callsFake(() => { return Promise.resolve('0x0') }) await metamaskController.createNewVaultAndRestore('foobar1337', TEST_SEED_ALT) msgParams = { 'from': address, 'data': data, } const promise = metamaskController.newUnsignedMessage(msgParams) // handle the promise so it doesn't throw an unhandledRejection promise.then(noop).catch(noop) metamaskMsgs = metamaskController.messageManager.getUnapprovedMsgs() messages = metamaskController.messageManager.messages msgId = Object.keys(metamaskMsgs)[0] messages[0].msgParams.metamaskId = parseInt(msgId) }) it('persists address from msg params', function () { assert.equal(metamaskMsgs[msgId].msgParams.from, address) }) it('persists data from msg params', function () { assert.equal(metamaskMsgs[msgId].msgParams.data, data) }) it('sets the status to unapproved', function () { assert.equal(metamaskMsgs[msgId].status, 'unapproved') }) it('sets the type to eth_sign', function () { assert.equal(metamaskMsgs[msgId].type, 'eth_sign') }) it('rejects the message', function () { const msgIdInt = parseInt(msgId) metamaskController.cancelMessage(msgIdInt, noop) assert.equal(messages[0].status, 'rejected') }) it('errors when signing a message', async function () { try { await metamaskController.signMessage(messages[0].msgParams) } catch (error) { assert.equal(error.message, 'message length is invalid') } }) }) describe('#newUnsignedPersonalMessage', function () { let msgParams, metamaskPersonalMsgs, personalMessages, msgId const address = '0xc42edfcc21ed14dda456aa0756c153f7985d8813' const data = '0x43727970746f6b697474696573' beforeEach(async function () { sandbox.stub(metamaskController, 'getBalance') metamaskController.getBalance.callsFake(() => { return Promise.resolve('0x0') }) await metamaskController.createNewVaultAndRestore('foobar1337', TEST_SEED_ALT) msgParams = { 'from': address, 'data': data, } const promise = metamaskController.newUnsignedPersonalMessage(msgParams) // handle the promise so it doesn't throw an unhandledRejection promise.then(noop).catch(noop) metamaskPersonalMsgs = metamaskController.personalMessageManager.getUnapprovedMsgs() personalMessages = metamaskController.personalMessageManager.messages msgId = Object.keys(metamaskPersonalMsgs)[0] personalMessages[0].msgParams.metamaskId = parseInt(msgId) }) it('errors with no from in msgParams', async function () { const msgParams = { 'data': data, } try { await metamaskController.newUnsignedPersonalMessage(msgParams) assert.fail('should have thrown') } catch (error) { assert.equal(error.message, 'MetaMask Message Signature: from field is required.') } }) it('persists address from msg params', function () { assert.equal(metamaskPersonalMsgs[msgId].msgParams.from, address) }) it('persists data from msg params', function () { assert.equal(metamaskPersonalMsgs[msgId].msgParams.data, data) }) it('sets the status to unapproved', function () { assert.equal(metamaskPersonalMsgs[msgId].status, 'unapproved') }) it('sets the type to personal_sign', function () { assert.equal(metamaskPersonalMsgs[msgId].type, 'personal_sign') }) it('rejects the message', function () { const msgIdInt = parseInt(msgId) metamaskController.cancelPersonalMessage(msgIdInt, noop) assert.equal(personalMessages[0].status, 'rejected') }) it('errors when signing a message', async function () { await metamaskController.signPersonalMessage(personalMessages[0].msgParams) assert.equal(metamaskPersonalMsgs[msgId].status, 'signed') assert.equal(metamaskPersonalMsgs[msgId].rawSig, '0x6a1b65e2b8ed53cf398a769fad24738f9fbe29841fe6854e226953542c4b6a173473cb152b6b1ae5f06d601d45dd699a129b0a8ca84e78b423031db5baa734741b') }) }) describe('#setupUntrustedCommunication', function () { it('sets up phishing stream for untrusted communication ', async function () { const phishingMessageSender = { url: 'http://myethereumwalletntw.com', tab: {}, } await metamaskController.phishingController.updatePhishingLists() const { promise, resolve } = deferredPromise() const streamTest = createThoughStream((chunk, _, cb) => { if (chunk.name !== 'phishing') { return cb() } assert.equal(chunk.data.hostname, (new URL(phishingMessageSender.url)).hostname) resolve() cb() }) metamaskController.setupUntrustedCommunication(streamTest, phishingMessageSender) await promise streamTest.end() }) it('adds a tabId and origin to requests', function (done) { const messageSender = { url: 'http://mycrypto.com', tab: { id: 456 }, } const streamTest = createThoughStream((chunk, _, cb) => { if (chunk.data && chunk.data.method) { cb(null, chunk) } else { cb() } }) metamaskController.setupUntrustedCommunication(streamTest, messageSender) const message = { id: 1999133338649204, jsonrpc: '2.0', params: ['mock tx params'], method: 'eth_sendTransaction', } streamTest.write({ name: 'provider', data: message, }, null, () => { setTimeout(() => { assert.deepStrictEqual( metamaskController.txController.newUnapprovedTransaction.getCall(0).args, [ 'mock tx params', { ...message, origin: 'mycrypto.com', tabId: 456, }, ] ) done() }) }) }) it('should add only origin to request if tabId not provided', function (done) { const messageSender = { url: 'http://mycrypto.com', } const streamTest = createThoughStream((chunk, _, cb) => { if (chunk.data && chunk.data.method) { cb(null, chunk) } else { cb() } }) metamaskController.setupUntrustedCommunication(streamTest, messageSender) const message = { id: 1999133338649204, jsonrpc: '2.0', params: ['mock tx params'], method: 'eth_sendTransaction', } streamTest.write({ name: 'provider', data: message, }, null, () => { setTimeout(() => { assert.deepStrictEqual( metamaskController.txController.newUnapprovedTransaction.getCall(0).args, [ 'mock tx params', { ...message, origin: 'mycrypto.com', }, ] ) done() }) }) }) }) describe('#setupTrustedCommunication', function () { it('sets up controller dnode api for trusted communication', async function () { const messageSender = { url: 'http://mycrypto.com', tab: {}, } const { promise, resolve } = deferredPromise() const streamTest = createThoughStream((chunk, _, cb) => { assert.equal(chunk.name, 'controller') resolve() cb() }) metamaskController.setupTrustedCommunication(streamTest, messageSender) await promise streamTest.end() }) }) describe('#markPasswordForgotten', function () { it('adds and sets forgottenPassword to config data to true', function () { metamaskController.markPasswordForgotten(noop) const state = metamaskController.getState() assert.equal(state.forgottenPassword, true) }) }) describe('#unMarkPasswordForgotten', function () { it('adds and sets forgottenPassword to config data to false', function () { metamaskController.unMarkPasswordForgotten(noop) const state = metamaskController.getState() assert.equal(state.forgottenPassword, false) }) }) describe('#_onKeyringControllerUpdate', function () { it('should do nothing if there are no keyrings in state', async function () { const syncAddresses = sinon.fake() const syncWithAddresses = sinon.fake() sandbox.replace(metamaskController, 'preferencesController', { syncAddresses, }) sandbox.replace(metamaskController, 'accountTracker', { syncWithAddresses, }) const oldState = metamaskController.getState() await metamaskController._onKeyringControllerUpdate({ keyrings: [] }) assert.ok(syncAddresses.notCalled) assert.ok(syncWithAddresses.notCalled) assert.deepEqual(metamaskController.getState(), oldState) }) it('should sync addresses if there are keyrings in state', async function () { const syncAddresses = sinon.fake() const syncWithAddresses = sinon.fake() sandbox.replace(metamaskController, 'preferencesController', { syncAddresses, }) sandbox.replace(metamaskController, 'accountTracker', { syncWithAddresses, }) const oldState = metamaskController.getState() await metamaskController._onKeyringControllerUpdate({ keyrings: [{ accounts: ['0x1', '0x2'], }], }) assert.deepEqual(syncAddresses.args, [[['0x1', '0x2']]]) assert.deepEqual(syncWithAddresses.args, [[['0x1', '0x2']]]) assert.deepEqual(metamaskController.getState(), oldState) }) it('should NOT update selected address if already unlocked', async function () { const syncAddresses = sinon.fake() const syncWithAddresses = sinon.fake() sandbox.replace(metamaskController, 'preferencesController', { syncAddresses, }) sandbox.replace(metamaskController, 'accountTracker', { syncWithAddresses, }) const oldState = metamaskController.getState() await metamaskController._onKeyringControllerUpdate({ isUnlocked: true, keyrings: [{ accounts: ['0x1', '0x2'], }], }) assert.deepEqual(syncAddresses.args, [[['0x1', '0x2']]]) assert.deepEqual(syncWithAddresses.args, [[['0x1', '0x2']]]) assert.deepEqual(metamaskController.getState(), oldState) }) }) }) function deferredPromise () { let resolve const promise = new Promise((_resolve) => { resolve = _resolve }) return { promise, resolve } }