1771 lines
36 KiB
JavaScript
1771 lines
36 KiB
JavaScript
/*!
|
|
* walletdb.js - storage for wallets
|
|
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
|
|
* Copyright (c) 2014-2016, Christopher Jeffrey (MIT License).
|
|
* https://github.com/bcoin-org/bcoin
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
/*
|
|
* Database Layout:
|
|
* (inherits all from txdb)
|
|
* W/[address] -> id & path data
|
|
* w/[id] -> wallet
|
|
* a/[id]/[index] -> account
|
|
* i/[id]/[name] -> account index
|
|
*/
|
|
|
|
var bcoin = require('./env');
|
|
var AsyncObject = require('./async');
|
|
var utils = require('./utils');
|
|
var assert = utils.assert;
|
|
var constants = bcoin.protocol.constants;
|
|
var BufferReader = require('./reader');
|
|
var BufferWriter = require('./writer');
|
|
|
|
/**
|
|
* WalletDB
|
|
* @exports WalletDB
|
|
* @constructor
|
|
* @param {Object} options
|
|
* @param {String?} options.name - Database name.
|
|
* @param {String?} options.location - Database file location.
|
|
* @param {String?} options.db - Database backend (`"leveldb"` by default).
|
|
* @param {Boolean?} options.verify - Verify transactions as they
|
|
* come in (note that this will not happen on the worker pool).
|
|
* @property {Boolean} loaded
|
|
*/
|
|
|
|
function WalletDB(options) {
|
|
if (!(this instanceof WalletDB))
|
|
return new WalletDB(options);
|
|
|
|
if (!options)
|
|
options = {};
|
|
|
|
AsyncObject.call(this);
|
|
|
|
this.options = options;
|
|
this.network = bcoin.network.get(options.network);
|
|
this.fees = options.fees;
|
|
this.logger = options.logger || bcoin.defaultLogger;
|
|
this.batches = {};
|
|
this.watchers = {};
|
|
this.workerPool = null;
|
|
|
|
// We need one read lock for `get` and `create`.
|
|
// It will hold locks specific to wallet ids.
|
|
this.readLock = new ReadLock(this);
|
|
|
|
this.walletCache = new bcoin.lru(10000, 1);
|
|
this.accountCache = new bcoin.lru(10000, 1);
|
|
this.pathCache = new bcoin.lru(100000, 1);
|
|
|
|
this.db = bcoin.ldb({
|
|
location: this.options.location,
|
|
db: this.options.db,
|
|
cacheSize: 8 << 20,
|
|
writeBufferSize: 4 << 20
|
|
});
|
|
|
|
this.tx = new bcoin.txdb(this, {
|
|
verify: this.options.verify,
|
|
useCheckpoints: this.options.useCheckpoints,
|
|
useFilter: true,
|
|
});
|
|
|
|
if (bcoin.useWorkers)
|
|
this.workerPool = new bcoin.workers();
|
|
|
|
this._init();
|
|
}
|
|
|
|
utils.inherits(WalletDB, AsyncObject);
|
|
|
|
/**
|
|
* Initialize wallet db.
|
|
* @private
|
|
*/
|
|
|
|
WalletDB.prototype._init = function _init() {
|
|
var self = this;
|
|
|
|
this.tx.on('error', function(err) {
|
|
self.emit('error', err);
|
|
});
|
|
|
|
if (bcoin.useWorkers) {
|
|
this.workerPool.on('error', function(err) {
|
|
self.emit('error', err);
|
|
});
|
|
}
|
|
|
|
function handleEvent(event, tx, map) {
|
|
var i, path;
|
|
|
|
self.emit(event, tx, map);
|
|
|
|
for (i = 0; i < map.accounts.length; i++) {
|
|
path = map.accounts[i];
|
|
self.fire(path.id, event, tx, path.name);
|
|
}
|
|
}
|
|
|
|
this.tx.on('tx', function(tx, map) {
|
|
handleEvent('tx', tx, map);
|
|
});
|
|
|
|
this.tx.on('conflict', function(tx, map) {
|
|
handleEvent('conflict', tx, map);
|
|
});
|
|
|
|
this.tx.on('confirmed', function(tx, map) {
|
|
handleEvent('confirmed', tx, map);
|
|
});
|
|
|
|
this.tx.on('unconfirmed', function(tx, map) {
|
|
handleEvent('unconfirmed', tx, map);
|
|
});
|
|
|
|
this.tx.on('updated', function(tx, map) {
|
|
handleEvent('updated', tx, map);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Open the walletdb, wait for the database to load.
|
|
* @alias WalletDB#open
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype._open = function open(callback) {
|
|
var self = this;
|
|
|
|
this.db.open(function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
self.db.checkVersion('V', 0, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
self.tx.writeGenesis(function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
self.tx.loadFilter(callback);
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Close the walletdb, wait for the database to close.
|
|
* @alias WalletDB#close
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype._close = function close(callback) {
|
|
var self = this;
|
|
var keys = Object.keys(this.watchers);
|
|
var watcher;
|
|
|
|
utils.forEachSerial(keys, function(key, next) {
|
|
watcher = self.watchers[key];
|
|
watcher.refs = 1;
|
|
watcher.object.destroy(next);
|
|
}, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
self.db.close(callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Invoke mutex lock.
|
|
* @returns {Function} unlock
|
|
*/
|
|
|
|
WalletDB.prototype._lock = function lock(id, func, args, force) {
|
|
return this.readLock.lock(id, func, args, force);
|
|
};
|
|
|
|
/**
|
|
* Start batch.
|
|
* @private
|
|
* @param {WalletID} id
|
|
*/
|
|
|
|
WalletDB.prototype.start = function start(id) {
|
|
assert(utils.isAlpha(id), 'Bad ID for batch.');
|
|
assert(!this.batches[id], 'Batch already started.');
|
|
this.batches[id] = this.db.batch();
|
|
};
|
|
|
|
/**
|
|
* Drop batch.
|
|
* @private
|
|
* @param {WalletID} id
|
|
*/
|
|
|
|
WalletDB.prototype.drop = function drop(id) {
|
|
var batch = this.batch(id);
|
|
batch.clear();
|
|
delete this.batches[id];
|
|
};
|
|
|
|
/**
|
|
* Get batch.
|
|
* @private
|
|
* @param {WalletID} id
|
|
* @returns {Leveldown.Batch}
|
|
*/
|
|
|
|
WalletDB.prototype.batch = function batch(id) {
|
|
var batch;
|
|
assert(utils.isAlpha(id), 'Bad ID for batch.');
|
|
batch = this.batches[id];
|
|
assert(batch, 'Batch does not exist.');
|
|
return batch;
|
|
};
|
|
|
|
/**
|
|
* Save batch.
|
|
* @private
|
|
* @param {WalletID} id
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.commit = function commit(id, callback) {
|
|
var batch = this.batch(id);
|
|
delete this.batches[id];
|
|
batch.write(callback);
|
|
};
|
|
|
|
/**
|
|
* Emit balance events after a tx is saved.
|
|
* @private
|
|
* @param {TX} tx
|
|
* @param {WalletMap} map
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.updateBalances = function updateBalances(tx, map, callback) {
|
|
var self = this;
|
|
var balances = {};
|
|
var i, id, keys;
|
|
|
|
utils.forEachSerial(map.getOutputWallets(), function(id, next) {
|
|
if (self.listeners('balances').length === 0
|
|
&& !self.hasListener(id, 'balance')) {
|
|
return next();
|
|
}
|
|
|
|
self.getBalance(id, function(err, balance) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
balances[id] = balance;
|
|
|
|
next();
|
|
});
|
|
}, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
keys = Object.keys(balances);
|
|
|
|
for (i = 0; i < keys.length; i++) {
|
|
id = keys[i];
|
|
self.fire(id, 'balance', balances[id]);
|
|
}
|
|
|
|
self.emit('balances', balances, map);
|
|
|
|
return callback(null, balances);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Derive new addresses after a tx is saved.
|
|
* @private
|
|
* @param {TX} tx
|
|
* @param {WalletMap} map
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.syncOutputs = function syncOutputs(tx, map, callback) {
|
|
var self = this;
|
|
|
|
utils.forEachSerial(map.getOutputWallets(), function(id, next) {
|
|
self.syncOutputDepth(id, map, function(err, receive, change) {
|
|
if (err)
|
|
return next(err);
|
|
self.fire(id, 'address', receive, change);
|
|
self.emit('address', receive, change, map);
|
|
next();
|
|
});
|
|
}, callback);
|
|
};
|
|
|
|
/**
|
|
* Derive new addresses and emit balance.
|
|
* @private
|
|
* @param {TX} tx
|
|
* @param {WalletMap} map
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.handleTX = function handleTX(tx, map, callback) {
|
|
var self = this;
|
|
this.syncOutputs(tx, map, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
self.updateBalances(tx, map, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Dump database (for debugging).
|
|
* @param {Function} callback - Returns [Error, Object].
|
|
*/
|
|
|
|
WalletDB.prototype.dump = function dump(callback) {
|
|
var records = {};
|
|
|
|
var iter = this.db.iterator({
|
|
gte: 'w',
|
|
lte: 'w~',
|
|
keys: true,
|
|
values: true,
|
|
fillCache: false,
|
|
keyAsBuffer: false,
|
|
valueAsBuffer: true
|
|
});
|
|
|
|
callback = utils.ensure(callback);
|
|
|
|
(function next() {
|
|
iter.next(function(err, key, value) {
|
|
if (err) {
|
|
return iter.end(function() {
|
|
callback(err);
|
|
});
|
|
}
|
|
|
|
if (key === undefined) {
|
|
return iter.end(function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
return callback(null, records);
|
|
});
|
|
}
|
|
|
|
records[key] = value;
|
|
|
|
next();
|
|
});
|
|
})();
|
|
};
|
|
|
|
/**
|
|
* Register an object with the walletdb.
|
|
* @param {Object} object
|
|
*/
|
|
|
|
WalletDB.prototype.register = function register(object) {
|
|
var id = object.id;
|
|
|
|
if (!this.watchers[id])
|
|
this.watchers[id] = { object: object, refs: 0 };
|
|
|
|
// Should never happen, and if it does, I will cry.
|
|
assert(this.watchers[id].object === object, 'I\'m crying.');
|
|
|
|
// We do some reference counting here
|
|
// because we're thug like that (police
|
|
// have a fit when your papers legit).
|
|
this.watchers[id].refs++;
|
|
};
|
|
|
|
/**
|
|
* Unregister a object with the walletdb.
|
|
* @param {Object} object
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
WalletDB.prototype.unregister = function unregister(object) {
|
|
var id = object.id;
|
|
var watcher = this.watchers[id];
|
|
|
|
if (!watcher)
|
|
return false;
|
|
|
|
assert(watcher.object === object);
|
|
assert(watcher.refs !== 0, '`destroy()` called twice!');
|
|
|
|
if (--watcher.refs === 0) {
|
|
delete this.watchers[id];
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Watch an object (increment reference count).
|
|
* @param {Object} object
|
|
*/
|
|
|
|
WalletDB.prototype.watch = function watch(object) {
|
|
var id = object.id;
|
|
var watcher = this.watchers[id];
|
|
|
|
if (!watcher)
|
|
return;
|
|
|
|
watcher.refs++;
|
|
};
|
|
|
|
/**
|
|
* Fire an event for a registered object.
|
|
* @param {WalletID} id
|
|
* @param {...Object} args
|
|
*/
|
|
|
|
WalletDB.prototype.fire = function fire(id) {
|
|
var watcher = this.watchers[id];
|
|
var i, args;
|
|
|
|
if (!watcher)
|
|
return;
|
|
|
|
args = new Array(arguments.length - 1);
|
|
|
|
for (i = 1; i < arguments.length; i++)
|
|
args[i - 1] = arguments[i];
|
|
|
|
watcher.object.emit.apply(watcher.object, args);
|
|
};
|
|
|
|
/**
|
|
* Test for a listener on a registered object.
|
|
* @param {WalletID} id
|
|
* @param {String} event
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
WalletDB.prototype.hasListener = function hasListener(id, event) {
|
|
var watcher = this.watchers[id];
|
|
|
|
if (!watcher)
|
|
return false;
|
|
|
|
if (watcher.object.listeners(event).length !== 0)
|
|
return true;
|
|
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* Get a wallet from the database, setup watcher.
|
|
* @param {WalletID} id
|
|
* @param {Function} callback - Returns [Error, {@link Wallet}].
|
|
*/
|
|
|
|
WalletDB.prototype.get = function get(id, callback) {
|
|
var self = this;
|
|
var unlock, watcher;
|
|
|
|
unlock = this._lock(id, get, [id, callback]);
|
|
|
|
if (!unlock)
|
|
return;
|
|
|
|
callback = utils.wrap(callback, unlock);
|
|
|
|
if (!id)
|
|
return callback();
|
|
|
|
watcher = this.watchers[id];
|
|
|
|
if (watcher) {
|
|
watcher.refs++;
|
|
return callback(null, watcher.object);
|
|
}
|
|
|
|
this._get(id, function(err, wallet) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!wallet)
|
|
return callback();
|
|
|
|
try {
|
|
self.register(wallet);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
wallet.open(function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
return callback(null, wallet);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get a wallet from the database, do not setup watcher.
|
|
* @private
|
|
* @param {WalletID} id
|
|
* @param {Function} callback - Returns [Error, {@link Wallet}].
|
|
*/
|
|
|
|
WalletDB.prototype._get = function get(id, callback) {
|
|
var self = this;
|
|
var wallet;
|
|
|
|
if (!id)
|
|
return callback();
|
|
|
|
wallet = this.walletCache.get(id);
|
|
|
|
if (wallet)
|
|
return callback(null, wallet);
|
|
|
|
this.db.get('w/' + id, function(err, data) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!data)
|
|
return callback();
|
|
|
|
try {
|
|
wallet = bcoin.wallet.fromRaw(self, data);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
self.walletCache.set(id, wallet);
|
|
|
|
return callback(null, wallet);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Save a wallet to the database.
|
|
* @param {Wallet} wallet
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.save = function save(wallet) {
|
|
var batch = this.batch(wallet.id);
|
|
this.walletCache.set(wallet.id, wallet);
|
|
batch.put('w/' + wallet.id, wallet.toRaw());
|
|
};
|
|
|
|
/**
|
|
* Test an api key against a wallet's api key.
|
|
* @param {WalletID} id
|
|
* @param {String} token
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.auth = function auth(id, token, callback) {
|
|
this._get(id, function(err, wallet) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!wallet)
|
|
return callback(new Error('Wallet not found.'));
|
|
|
|
if (typeof token === 'string') {
|
|
if (!utils.isHex(token))
|
|
return callback(new Error('Authentication error.'));
|
|
token = new Buffer(token, 'hex');
|
|
}
|
|
|
|
// Compare in constant time:
|
|
if (!utils.ccmp(token, wallet.token))
|
|
return callback(new Error('Authentication error.'));
|
|
|
|
return callback();
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Create a new wallet, save to database, setup watcher.
|
|
* @param {Object} options - See {@link Wallet}.
|
|
* @param {Function} callback - Returns [Error, {@link Wallet}].
|
|
*/
|
|
|
|
WalletDB.prototype.create = function create(options, callback) {
|
|
var self = this;
|
|
var wallet, unlock;
|
|
|
|
if (typeof options === 'function') {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
|
|
unlock = this._lock(options.id, create, [options, callback]);
|
|
|
|
if (!unlock)
|
|
return;
|
|
|
|
callback = utils.wrap(callback, unlock);
|
|
|
|
this.has(options.id, function(err, exists) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (exists)
|
|
return callback(new Error('Wallet already exists.'));
|
|
|
|
try {
|
|
wallet = bcoin.wallet.fromOptions(self, options);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
try {
|
|
self.register(wallet);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
wallet.init(options, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
self.logger.info('Created wallet %s.', wallet.id);
|
|
|
|
return callback(null, wallet);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Test for the existence of a wallet.
|
|
* @param {WalletID?} id
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.has = function has(id, callback) {
|
|
if (!id)
|
|
return callback(null, false);
|
|
|
|
if (this.watchers[id])
|
|
return callback(null, true);
|
|
|
|
if (this.walletCache.has(id))
|
|
return callback(null, true);
|
|
|
|
this.db.has('w/' + id, callback);
|
|
};
|
|
|
|
/**
|
|
* Attempt to create wallet, return wallet if already exists.
|
|
* @param {WalletID?} id
|
|
* @param {Object} options - See {@link Wallet}.
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.ensure = function ensure(options, callback) {
|
|
var self = this;
|
|
|
|
this.get(options.id, function(err, wallet) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (wallet)
|
|
return callback(null, wallet);
|
|
|
|
self.create(options, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get an account from the database.
|
|
* @param {WalletID} id
|
|
* @param {String|Number} name - Account name/index.
|
|
* @param {Function} callback - Returns [Error, {@link Wallet}].
|
|
*/
|
|
|
|
WalletDB.prototype.getAccount = function getAccount(id, name, callback) {
|
|
var self = this;
|
|
|
|
this.getAccountIndex(id, name, function(err, index) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (index === -1)
|
|
return callback();
|
|
|
|
self._getAccount(id, index, function(err, account) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!account)
|
|
return callback();
|
|
|
|
account.open(function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
return callback(null, account);
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get an account from the database. Do not setup watcher.
|
|
* @private
|
|
* @param {WalletID} id
|
|
* @param {Number} index - Account index.
|
|
* @param {Function} callback - Returns [Error, {@link Wallet}].
|
|
*/
|
|
|
|
WalletDB.prototype._getAccount = function getAccount(id, index, callback) {
|
|
var self = this;
|
|
var key = id + '/' + index;
|
|
var account = this.accountCache.get(key);
|
|
|
|
if (account)
|
|
return callback(null, account);
|
|
|
|
this.db.get('a/' + key, function(err, data) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!data)
|
|
return callback();
|
|
|
|
try {
|
|
account = bcoin.account.fromRaw(self, data);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
self.accountCache.set(key, account);
|
|
|
|
return callback(null, account);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* List account names and indexes from the db.
|
|
* @param {WalletID} id
|
|
* @param {Function} callback - Returns [Error, Array].
|
|
*/
|
|
|
|
WalletDB.prototype.getAccounts = function getAccounts(id, callback) {
|
|
var map = [];
|
|
var i, accounts;
|
|
|
|
if (!utils.isAlpha(id))
|
|
return callback(new Error('Wallet IDs must be alphanumeric.'));
|
|
|
|
this.db.iterate({
|
|
gte: 'i/' + id + '/',
|
|
lte: 'i/' + id + '/~',
|
|
values: true,
|
|
parse: function(value, key) {
|
|
var name = key.split('/')[2];
|
|
var index = value.readUInt32LE(0, true);
|
|
map[index] = name;
|
|
}
|
|
}, function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
// Get it out of hash table mode.
|
|
accounts = new Array(map.length);
|
|
|
|
for (i = 0; i < map.length; i++) {
|
|
assert(map[i] != null);
|
|
accounts[i] = map[i];
|
|
}
|
|
|
|
return callback(null, accounts);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Lookup the corresponding account name's index.
|
|
* @param {WalletID} id
|
|
* @param {String|Number} name - Account name/index.
|
|
* @param {Function} callback - Returns [Error, Number].
|
|
*/
|
|
|
|
WalletDB.prototype.getAccountIndex = function getAccountIndex(id, name, callback) {
|
|
if (!id)
|
|
return callback(null, -1);
|
|
|
|
if (name == null)
|
|
return callback(null, -1);
|
|
|
|
if (typeof name === 'number')
|
|
return callback(null, name);
|
|
|
|
this.db.get('i/' + id + '/' + name, function(err, index) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!index)
|
|
return callback(null, -1);
|
|
|
|
return callback(null, index.readUInt32LE(0, true));
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Save an account to the database.
|
|
* @param {Account} account
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.saveAccount = function saveAccount(account) {
|
|
var batch = this.batch(account.id);
|
|
var index = new Buffer(4);
|
|
var key = account.id + '/' + account.accountIndex;
|
|
|
|
index.writeUInt32LE(account.accountIndex, 0, true);
|
|
|
|
batch.put('a/' + key, account.toRaw());
|
|
batch.put('i/' + account.id + '/' + account.name, index);
|
|
|
|
this.accountCache.set(key, account);
|
|
};
|
|
|
|
/**
|
|
* Create an account.
|
|
* @param {Object} options - See {@link Account} options.
|
|
* @param {Function} callback - Returns [Error, {@link Account}].
|
|
*/
|
|
|
|
WalletDB.prototype.createAccount = function createAccount(options, callback) {
|
|
var self = this;
|
|
var account;
|
|
|
|
this.hasAccount(options.id, options.accountIndex, function(err, exists) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (exists)
|
|
return callback(new Error('Account already exists.'));
|
|
|
|
try {
|
|
account = bcoin.account.fromOptions(self, options);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
account.init(function(err) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
self.logger.info('Created account %s/%s/%d.',
|
|
account.id,
|
|
account.name,
|
|
account.accountIndex);
|
|
|
|
return callback(null, account);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Test for the existence of an account.
|
|
* @param {WalletID} id
|
|
* @param {String|Number} account
|
|
* @param {Function} callback - Returns [Error, Boolean].
|
|
*/
|
|
|
|
WalletDB.prototype.hasAccount = function hasAccount(id, account, callback) {
|
|
var self = this;
|
|
var key;
|
|
|
|
if (!id)
|
|
return callback(null, false);
|
|
|
|
this.getAccountIndex(id, account, function(err, index) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (index === -1)
|
|
return callback(null, false);
|
|
|
|
key = id + '/' + index;
|
|
|
|
if (self.accountCache.has(key))
|
|
return callback(null, true);
|
|
|
|
self.db.has('a/' + key, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Save an address to the path map.
|
|
* The path map exists in the form of:
|
|
* `W/[address-hash] -> {walletid1=path1, walletid2=path2, ...}`
|
|
* @param {WalletID} id
|
|
* @param {KeyRing[]} addresses
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.saveAddress = function saveAddress(id, addresses, callback) {
|
|
var self = this;
|
|
var items = [];
|
|
var batch = this.batch(id);
|
|
var i, address, path;
|
|
|
|
if (!Array.isArray(addresses))
|
|
addresses = [addresses];
|
|
|
|
for (i = 0; i < addresses.length; i++) {
|
|
address = addresses[i];
|
|
path = Path.fromKeyRing(address);
|
|
|
|
items.push([address.getKeyAddress(), path]);
|
|
|
|
if (address.type === 'multisig')
|
|
items.push([address.getScriptAddress(), path]);
|
|
|
|
if (address.witness)
|
|
items.push([address.getProgramAddress(), path]);
|
|
}
|
|
|
|
utils.forEachSerial(items, function(item, next) {
|
|
var address = item[0];
|
|
var path = item[1];
|
|
var hash = address.getHash('hex');
|
|
|
|
if (self.tx.filter)
|
|
self.tx.filter.add(hash, 'hex');
|
|
|
|
self.emit('save address', address, path);
|
|
|
|
self._getPaths(hash, function(err, paths) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!paths)
|
|
paths = {};
|
|
|
|
if (paths[id])
|
|
return next();
|
|
|
|
paths[id] = path;
|
|
|
|
self.pathCache.set(hash, paths);
|
|
|
|
batch.put('W/' + hash, serializePaths(paths));
|
|
|
|
next();
|
|
});
|
|
}, callback);
|
|
};
|
|
|
|
/**
|
|
* Retrieve paths by hash.
|
|
* @param {Hash} hash
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype._getPaths = function _getPaths(hash, callback) {
|
|
var self = this;
|
|
var paths;
|
|
|
|
if (!hash)
|
|
return callback();
|
|
|
|
paths = this.pathCache.get(hash);
|
|
|
|
if (paths)
|
|
return callback(null, paths);
|
|
|
|
this.db.fetch('W/' + hash, parsePaths, function(err, paths) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!paths)
|
|
return callback();
|
|
|
|
self.pathCache.set(hash, paths);
|
|
|
|
return callback(null, paths);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Test whether an address hash exists in the
|
|
* path map and is relevant to the wallet id.
|
|
* @param {WalletID} id
|
|
* @param {Hash} address
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.hasAddress = function hasAddress(id, address, callback) {
|
|
this.getAddress(address, function(err, paths) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!paths || !paths[id])
|
|
return callback(null, false);
|
|
|
|
return callback(null, true);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get path data for the specified address hash.
|
|
* @param {Hash} address
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.getAddress = function getAddress(address, callback) {
|
|
this._getPaths(address, callback);
|
|
};
|
|
|
|
/**
|
|
* Get all address hashes.
|
|
* @param {WalletId} id
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.getAddresses = function getAddresses(id, callback) {
|
|
if (!callback) {
|
|
callback = id;
|
|
id = null;
|
|
}
|
|
|
|
this.db.iterate({
|
|
gte: 'W',
|
|
lte: 'W~',
|
|
values: true,
|
|
parse: function(value, key) {
|
|
var paths = parsePaths(value);
|
|
|
|
if (id && !paths[id])
|
|
return;
|
|
|
|
return key.split('/')[1];
|
|
}
|
|
}, callback);
|
|
};
|
|
|
|
/**
|
|
* Rescan the blockchain.
|
|
* @param {ChainDB} chaindb
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.rescan = function rescan(chaindb, callback) {
|
|
var self = this;
|
|
this.tx.getTip(function(err, hash) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!hash)
|
|
return callback(new Error('Best hash not found.'));
|
|
|
|
self.getAddresses(function(err, hashes) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
self.logger.info('Scanning for %d addresses.', hashes.length);
|
|
|
|
chaindb.scan(hash, hashes, function(tx, block, next) {
|
|
self.tx.add(tx, function(err) {
|
|
if (err)
|
|
return next(err);
|
|
self.tx.writeTip(block.hash, next);
|
|
});
|
|
}, callback);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Get the corresponding path for an address hash.
|
|
* @param {WalletID} id
|
|
* @param {Hash} address
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.getPath = function getPath(id, address, callback) {
|
|
this.getAddress(address, function(err, paths) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!paths || !paths[id])
|
|
return callback();
|
|
|
|
return callback(null, paths[id]);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#add}.
|
|
*/
|
|
|
|
WalletDB.prototype.addTX = function addTX(tx, callback) {
|
|
return this.tx.add(tx, callback);
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#getTX}.
|
|
*/
|
|
|
|
WalletDB.prototype.getTX = function getTX(hash, callback) {
|
|
return this.tx.getTX(hash, callback);
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#getCoin}.
|
|
*/
|
|
|
|
WalletDB.prototype.getCoin = function getCoin(hash, index, callback) {
|
|
return this.tx.getCoin(hash, index, callback);
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#getHistory}.
|
|
*/
|
|
|
|
WalletDB.prototype.getHistory = function getHistory(id, account, callback) {
|
|
var self = this;
|
|
this._getKey(id, account, callback, function(id, callback) {
|
|
self.tx.getHistory(id, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#getCoins}.
|
|
*/
|
|
|
|
WalletDB.prototype.getCoins = function getCoins(id, account, callback) {
|
|
var self = this;
|
|
this._getKey(id, account, callback, function(id, callback) {
|
|
self.tx.getCoins(id, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#getUnconfirmed}.
|
|
*/
|
|
|
|
WalletDB.prototype.getUnconfirmed = function getUnconfirmed(id, account, callback) {
|
|
var self = this;
|
|
this._getKey(id, account, callback, function(id, callback) {
|
|
self.tx.getUnconfirmed(id, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#getBalance}.
|
|
*/
|
|
|
|
WalletDB.prototype.getBalance = function getBalance(id, account, callback) {
|
|
var self = this;
|
|
this._getKey(id, account, callback, function(id, callback) {
|
|
self.tx.getBalance(id, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#getLastTime}.
|
|
*/
|
|
|
|
WalletDB.prototype.getLastTime = function getLastTime(id, account, callback) {
|
|
var self = this;
|
|
|
|
if (typeof account === 'function') {
|
|
callback = account;
|
|
account = null;
|
|
}
|
|
|
|
this._getKey(id, account, callback, function(id, callback) {
|
|
self.tx.getLastTime(id, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#getLast}.
|
|
*/
|
|
|
|
WalletDB.prototype.getLast = function getLast(id, account, limit, callback) {
|
|
var self = this;
|
|
|
|
if (typeof limit === 'function') {
|
|
callback = limit;
|
|
limit = account;
|
|
account = null;
|
|
}
|
|
|
|
this._getKey(id, account, callback, function(id, callback) {
|
|
self.tx.getLast(id, limit, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.getTimeRange = function getTimeRange(id, account, options, callback) {
|
|
var self = this;
|
|
|
|
if (typeof options === 'function') {
|
|
callback = options;
|
|
options = account;
|
|
account = null;
|
|
}
|
|
|
|
this._getKey(id, account, callback, function(id, callback) {
|
|
self.tx.getTimeRange(id, options, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#getRange}.
|
|
*/
|
|
|
|
WalletDB.prototype.getRange = function getRange(id, account, options, callback) {
|
|
var self = this;
|
|
|
|
if (typeof options === 'function') {
|
|
callback = options;
|
|
options = account;
|
|
account = null;
|
|
}
|
|
|
|
this._getKey(id, account, callback, function(id, callback) {
|
|
self.tx.getRange(id, options, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#fillHistory}.
|
|
*/
|
|
|
|
WalletDB.prototype.fillHistory = function fillHistory(tx, callback) {
|
|
this.tx.fillHistory(tx, callback);
|
|
};
|
|
|
|
/**
|
|
* @see {@link TXDB#fillCoins}.
|
|
*/
|
|
|
|
WalletDB.prototype.fillCoins = function fillCoins(tx, callback) {
|
|
this.tx.fillCoins(tx, callback);
|
|
};
|
|
|
|
/**
|
|
* Zap all walletdb transactions.
|
|
* @see {@link TXDB#zap}.
|
|
*/
|
|
|
|
WalletDB.prototype.zap = function zap(id, account, age, callback) {
|
|
var self = this;
|
|
|
|
if (typeof age === 'function') {
|
|
callback = age;
|
|
age = account;
|
|
account = null;
|
|
}
|
|
|
|
this._getKey(id, account, callback, function(id, callback) {
|
|
self.tx.zap(id, age, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Parse arguments and return an id
|
|
* consisting of `walletid/accountname`.
|
|
* @private
|
|
* @param {WalletID} id
|
|
* @param {String|Number} account
|
|
* @param {Function} errback
|
|
* @param {Function} callback - Returns [String, Function].
|
|
*/
|
|
|
|
WalletDB.prototype._getKey = function _getKey(id, account, errback, callback) {
|
|
if (typeof account === 'function') {
|
|
errback = account;
|
|
account = null;
|
|
}
|
|
|
|
if (account == null)
|
|
return callback(id, errback);
|
|
|
|
this.getAccountIndex(id, account, function(err, index) {
|
|
if (err)
|
|
return errback(err);
|
|
|
|
if (index === -1)
|
|
return errback(new Error('Account not found.'));
|
|
|
|
return callback(id + '/' + index, errback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Add a block's transactions and write the new best hash.
|
|
* @param {Block} block
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.addBlock = function addBlock(block, txs, callback) {
|
|
this.tx.addBlock(block, txs, callback);
|
|
};
|
|
|
|
/**
|
|
* Unconfirm a block's transactions and write the new best hash.
|
|
* @param {Block} block
|
|
* @param {Function} callback
|
|
*/
|
|
|
|
WalletDB.prototype.removeBlock = function removeBlock(block, callback) {
|
|
this.tx.removeBlock(block, callback);
|
|
};
|
|
|
|
/**
|
|
* Helper function to get a wallet.
|
|
* @private
|
|
* @param {WalletID} id
|
|
* @param {Function} callback
|
|
* @param {Function} handler
|
|
*/
|
|
|
|
WalletDB.prototype.fetchWallet = function fetchWallet(id, callback, handler) {
|
|
this.get(id, function(err, wallet) {
|
|
if (err)
|
|
return callback(err);
|
|
|
|
if (!wallet)
|
|
return callback(new Error('No wallet.'));
|
|
|
|
handler(wallet, function(err, res1, res2) {
|
|
// Kill the reference.
|
|
wallet.destroy();
|
|
|
|
if (err)
|
|
return callback(err);
|
|
|
|
callback(null, res1, res2);
|
|
});
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.syncOutputDepth = function syncOutputDepth(id, map, callback) {
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.syncOutputDepth(map, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.createAddress = function createAddress(id, name, change, callback) {
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.createAddress(name, change, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.fund = function fund(id, tx, options, callback) {
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.fund(tx, options, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.scriptInputs = function scriptInputs(id, tx, callback) {
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.scriptInputs(tx, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.sign = function sign(id, tx, options, callback) {
|
|
if (typeof options === 'function') {
|
|
callback = options;
|
|
options = {};
|
|
}
|
|
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.sign(tx, options, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.createTX = function createTX(id, options, callback) {
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.createTX(options, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.addKey = function addKey(id, name, key, callback) {
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.addKey(name, key, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.removeKey = function removeKey(id, name, key, callback) {
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.removeKey(name, key, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.setPassphrase = function setPassphrase(id, old, new_, callback) {
|
|
if (typeof new_ === 'function') {
|
|
callback = new_;
|
|
new_ = old;
|
|
old = null;
|
|
}
|
|
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.setPassphrase(old, new_, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.retoken = function retoken(id, passphrase, callback) {
|
|
if (typeof passphrase === 'function') {
|
|
callback = passphrase;
|
|
passphrase = null;
|
|
}
|
|
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.retoken(passphrase, callback);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.getInfo = function getInfo(id, callback) {
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
callback(null, wallet);
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.ensureAccount = function ensureAccount(id, options, callback) {
|
|
var self = this;
|
|
var account = options.name || options.account;
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
self.hasAccount(wallet.id, account, function(err, exists) {
|
|
if (err)
|
|
return callback(err);
|
|
if (exists)
|
|
return wallet.getAccount(account, callback);
|
|
return wallet.createAccount(options, callback);
|
|
});
|
|
});
|
|
};
|
|
|
|
WalletDB.prototype.getRedeem = function getRedeem(id, hash, callback) {
|
|
this.fetchWallet(id, callback, function(wallet, callback) {
|
|
wallet.getRedeem(hash, callback);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Path
|
|
* @constructor
|
|
* @private
|
|
* @property {WalletID} id
|
|
* @property {String} name - Account name.
|
|
* @property {Number} account - Account index.
|
|
* @property {Number} change - Change index.
|
|
* @property {Number} index - Address index.
|
|
* @property {Address|null} address
|
|
*/
|
|
|
|
function Path() {
|
|
if (!(this instanceof Path))
|
|
return new Path();
|
|
|
|
this.id = null;
|
|
this.name = null;
|
|
this.account = 0;
|
|
this.change = 0;
|
|
this.index = 0;
|
|
this.address = null;
|
|
}
|
|
|
|
/**
|
|
* Inject properties from serialized data.
|
|
* @private
|
|
* @param {Buffer} data
|
|
*/
|
|
|
|
Path.prototype.fromRaw = function fromRaw(data) {
|
|
var p = new BufferReader(data);
|
|
this.id = p.readVarString('utf8');
|
|
this.name = p.readVarString('utf8');
|
|
this.account = p.readU32();
|
|
this.change = p.readU32();
|
|
this.index = p.readU32();
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Instantiate path from serialized data.
|
|
* @param {Buffer} data
|
|
* @returns {Path}
|
|
*/
|
|
|
|
Path.fromRaw = function fromRaw(data) {
|
|
return new Path().fromRaw(data);
|
|
};
|
|
|
|
/**
|
|
* Serialize path.
|
|
* @returns {Buffer}
|
|
*/
|
|
|
|
Path.prototype.toRaw = function toRaw(writer) {
|
|
var p = new BufferWriter(writer);
|
|
|
|
p.writeVarString(this.id, 'utf8');
|
|
p.writeVarString(this.name, 'utf8');
|
|
p.writeU32(this.account);
|
|
p.writeU32(this.change);
|
|
p.writeU32(this.index);
|
|
|
|
if (!writer)
|
|
p = p.render();
|
|
|
|
return p;
|
|
};
|
|
|
|
/**
|
|
* Inject properties from keyring.
|
|
* @private
|
|
* @param {WalletID} id
|
|
* @param {KeyRing} address
|
|
*/
|
|
|
|
Path.prototype.fromKeyRing = function fromKeyRing(address) {
|
|
this.id = address.id;
|
|
this.name = address.name;
|
|
this.account = address.account;
|
|
this.change = address.change;
|
|
this.index = address.index;
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Instantiate path from keyring.
|
|
* @param {WalletID} id
|
|
* @param {KeyRing} address
|
|
* @returns {Path}
|
|
*/
|
|
|
|
Path.fromKeyRing = function fromKeyRing(address) {
|
|
return new Path().fromKeyRing(address);
|
|
};
|
|
|
|
/**
|
|
* Convert path object to string derivation path.
|
|
* @returns {String}
|
|
*/
|
|
|
|
Path.prototype.toPath = function() {
|
|
return 'm/' + this.account
|
|
+ '\'/' + this.change
|
|
+ '/' + this.index;
|
|
};
|
|
|
|
/**
|
|
* Convert path to a json-friendly object.
|
|
* @returns {Object}
|
|
*/
|
|
|
|
Path.prototype.toJSON = function toJSON() {
|
|
return {
|
|
id: this.id,
|
|
name: this.name,
|
|
path: this.toPath()
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Inject properties from json object.
|
|
* @private
|
|
* @param {Object} json
|
|
*/
|
|
|
|
Path.prototype.fromJSON = function fromJSON(json) {
|
|
var indexes = bcoin.hd.parsePath(json.path, constants.hd.MAX_INDEX);
|
|
|
|
assert(indexes.length === 3);
|
|
assert(indexes[0] >= 0);
|
|
indexes[0] -= constants.hd.HARDENED;
|
|
|
|
this.id = json.id;
|
|
this.name = json.name;
|
|
this.account = indexes[0];
|
|
this.change = indexes[1];
|
|
this.index = indexes[2];
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Instantiate path from json object.
|
|
* @param {Object} json
|
|
* @returns {Path}
|
|
*/
|
|
|
|
Path.fromJSON = function fromJSON(json) {
|
|
return new Path().fromJSON(json);
|
|
};
|
|
|
|
/**
|
|
* Convert path to a key in the form of (id|account).
|
|
* @returns {String}
|
|
*/
|
|
|
|
Path.prototype.toKey = function toKey() {
|
|
return this.id + '/' + this.account;
|
|
};
|
|
|
|
/**
|
|
* Convert path to a compact json object.
|
|
* @returns {Object}
|
|
*/
|
|
|
|
Path.prototype.toCompact = function toCompact() {
|
|
return {
|
|
path: 'm/' + this.change + '/' + this.index,
|
|
address: this.address ? this.address.toBase58() : null
|
|
};
|
|
};
|
|
|
|
/**
|
|
* Inject properties from compact json object.
|
|
* @private
|
|
* @param {Object} json
|
|
*/
|
|
|
|
Path.prototype.fromCompact = function fromCompact(json) {
|
|
var indexes = bcoin.hd.parsePath(json.path, constants.hd.MAX_INDEX);
|
|
|
|
assert(indexes.length === 2);
|
|
|
|
this.change = indexes[0];
|
|
this.index = indexes[1];
|
|
this.address = json.address
|
|
? bcoin.address.fromBase58(json.address)
|
|
: null;
|
|
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Instantiate path from compact json object.
|
|
* @param {Object} json
|
|
* @returns {Path}
|
|
*/
|
|
|
|
Path.fromCompact = function fromCompact(json) {
|
|
return new Path().fromCompact(json);
|
|
};
|
|
|
|
/**
|
|
* Inspect the path.
|
|
* @returns {String}
|
|
*/
|
|
|
|
Path.prototype.inspect = function() {
|
|
return '<Path: ' + this.id
|
|
+ '/' + this.name
|
|
+ ': ' + this.toPath()
|
|
+ '>';
|
|
};
|
|
|
|
/*
|
|
* Helpers
|
|
*/
|
|
|
|
function parsePaths(data) {
|
|
var p = new BufferReader(data);
|
|
var out = {};
|
|
var path;
|
|
|
|
while (p.left()) {
|
|
path = Path.fromRaw(p);
|
|
out[path.id] = path;
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
function serializePaths(out) {
|
|
var p = new BufferWriter();
|
|
var keys = Object.keys(out);
|
|
var i, id, path;
|
|
|
|
for (i = 0; i < keys.length; i++) {
|
|
id = keys[i];
|
|
path = out[id];
|
|
path.toRaw(p);
|
|
}
|
|
|
|
return p.render();
|
|
}
|
|
|
|
function ReadLock(parent) {
|
|
if (!(this instanceof ReadLock))
|
|
return new ReadLock(parent);
|
|
|
|
this.parent = parent;
|
|
this.jobs = [];
|
|
this.busy = {};
|
|
}
|
|
|
|
ReadLock.prototype.lock = function lock(id, func, args, force) {
|
|
var self = this;
|
|
var called;
|
|
|
|
if (force || !id) {
|
|
assert(!id || this.busy[id]);
|
|
return function unlock() {
|
|
assert(!called);
|
|
called = true;
|
|
};
|
|
}
|
|
|
|
if (this.busy[id]) {
|
|
this.jobs.push([func, args]);
|
|
return;
|
|
}
|
|
|
|
this.busy[id] = true;
|
|
|
|
return function unlock() {
|
|
var item;
|
|
|
|
assert(!called);
|
|
called = true;
|
|
|
|
delete self.busy[id];
|
|
|
|
if (self.jobs.length === 0)
|
|
return;
|
|
|
|
item = self.jobs.shift();
|
|
|
|
item[0].apply(self.parent, item[1]);
|
|
};
|
|
};
|
|
|
|
/*
|
|
* Expose
|
|
*/
|
|
|
|
exports = WalletDB;
|
|
exports.Path = Path;
|
|
|
|
module.exports = exports;
|