openethereum/js/packages/api/local/accounts/accounts.js

224 lines
4.9 KiB
JavaScript
Raw Normal View History

2017-03-29 17:07:58 +02:00
// Copyright 2015-2017 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
import Account from './account';
import localStore from 'store';
import { debounce } from 'lodash';
import { decryptPrivateKey } from '../ethkey';
2017-03-29 17:07:58 +02:00
const NULL_ADDRESS = '0x0000000000000000000000000000000000000000';
const LS_STORE_KEY = '_parity::localAccounts';
export default class Accounts {
persist = debounce(() => {
this._lastState = JSON.stringify(this);
localStore.set(LS_STORE_KEY, this);
}, 100);
2017-03-29 17:07:58 +02:00
constructor (data = localStore.get(LS_STORE_KEY) || {}) {
this._lastState = JSON.stringify(data);
window.addEventListener('storage', ({ key, newValue }) => {
if (key !== LS_STORE_KEY) {
return;
}
if (newValue !== this._lastState) {
console.log('Data changed in a second tab, syncing state');
this.restore(JSON.parse(newValue));
}
});
this.restore(data);
}
restore (data) {
2017-03-29 17:07:58 +02:00
const {
last = NULL_ADDRESS,
dappsDefault = NULL_ADDRESS,
store = {}
2017-03-29 17:07:58 +02:00
} = data;
this._last = last;
this._dappsDefaultAddress = dappsDefault;
this._store = {};
if (Array.isArray(store)) {
// Recover older version that stored accounts as an array
store.forEach((data) => {
const account = new Account(this.persist, data);
this._store[account.address] = account;
});
} else {
Object.keys(store).forEach((key) => {
this._store[key] = new Account(this.persist, store[key]);
});
}
}
_addAccount = (account) => {
const { address } = account;
if (address in this._store && this._store[address].uuid) {
throw new Error(`Account ${address} already exists!`);
}
this._store[address] = account;
this.lastAddress = address;
this.persist();
return account.address;
2017-03-29 17:07:58 +02:00
}
create (secret, password) {
const privateKey = Buffer.from(secret.slice(2), 'hex');
2017-04-04 11:49:36 +02:00
return Account
.fromPrivateKey(this.persist, privateKey, password)
.then(this._addAccount);
}
2017-03-29 17:07:58 +02:00
restoreFromWallet (wallet, password) {
return decryptPrivateKey(wallet, password)
.then((privateKey) => {
if (!privateKey) {
throw new Error('Invalid password');
2017-04-03 18:50:11 +02:00
}
return Account.fromPrivateKey(this.persist, privateKey, password);
})
.then(this._addAccount);
2017-03-29 17:07:58 +02:00
}
set lastAddress (value) {
this._last = value.toLowerCase();
}
get lastAddress () {
return this._last;
}
get dappsDefaultAddress () {
if (this._dappsDefaultAddress === NULL_ADDRESS) {
return this._last;
}
if (this._dappsDefaultAddress in this._store) {
return this._dappsDefaultAddress;
}
return NULL_ADDRESS;
}
set dappsDefaultAddress (value) {
this._dappsDefaultAddress = value.toLowerCase();
this.persist();
}
2017-03-29 17:07:58 +02:00
get (address) {
address = address.toLowerCase();
const account = this._store[address];
2017-03-29 17:07:58 +02:00
if (!account) {
throw new Error(`Account not found: ${address}`);
}
this.lastAddress = address;
2017-03-29 17:07:58 +02:00
return account;
}
getLazyCreate (address) {
address = address.toLowerCase();
this.lastAddress = address;
if (!(address in this._store)) {
this._store[address] = new Account(this.persist);
}
return this._store[address];
}
2017-03-29 17:07:58 +02:00
remove (address, password) {
address = address.toLowerCase();
2017-04-03 18:50:11 +02:00
const account = this.get(address);
2017-03-29 17:07:58 +02:00
2017-04-03 18:50:11 +02:00
if (!account) {
2017-03-29 17:07:58 +02:00
return false;
}
2017-04-04 11:49:36 +02:00
return account
.isValidPassword(password)
2017-04-03 18:50:11 +02:00
.then((isValid) => {
if (!isValid) {
return false;
}
2017-03-29 17:07:58 +02:00
2017-04-03 18:50:11 +02:00
if (address === this.lastAddress) {
this.lastAddress = NULL_ADDRESS;
}
this.removeUnsafe(address);
2017-03-29 17:07:58 +02:00
2017-04-03 18:50:11 +02:00
return true;
});
}
removeUnsafe (address) {
address = address.toLowerCase();
delete this._store[address];
2017-03-29 17:07:58 +02:00
this.persist();
}
allAddresses () {
return Object.keys(this._store);
2017-03-29 17:07:58 +02:00
}
accountAddresses () {
return Object
.keys(this._store)
.filter((address) => this._store[address].uuid);
}
map (mapper) {
2017-03-29 17:07:58 +02:00
const result = {};
Object.keys(this._store).forEach((key) => {
result[key] = mapper(this._store[key]);
2017-03-29 17:07:58 +02:00
});
return result;
}
toJSON () {
return {
last: this._last,
dappsDefault: this._dappsDefaultAddress,
2017-03-29 17:07:58 +02:00
store: this._store
};
}
}