923 lines
20 KiB
JavaScript
923 lines
20 KiB
JavaScript
/**
|
|
* http.js - http server for bcoin
|
|
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
|
|
* https://github.com/indutny/bcoin
|
|
*/
|
|
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var StringDecoder = require('string_decoder').StringDecoder;
|
|
var url = require('url');
|
|
var engine;
|
|
|
|
try {
|
|
engine = require('engine.io');
|
|
} catch (e) {
|
|
;
|
|
}
|
|
|
|
var bcoin = require('../bcoin');
|
|
var bn = require('bn.js');
|
|
var constants = bcoin.protocol.constants;
|
|
var network = bcoin.protocol.network;
|
|
var utils = bcoin.utils;
|
|
var assert = utils.assert;
|
|
|
|
/**
|
|
* HTTPServer
|
|
*/
|
|
|
|
function HTTPServer(node, options) {
|
|
var self = this;
|
|
|
|
if (!options)
|
|
options = {};
|
|
|
|
this.options = options;
|
|
this.node = node;
|
|
|
|
this.routes = {
|
|
get: [],
|
|
post: [],
|
|
put: [],
|
|
del: []
|
|
};
|
|
|
|
this.server = options.key
|
|
? require('https').createServer(options)
|
|
: require('http').createServer();
|
|
|
|
this._init();
|
|
}
|
|
|
|
utils.inherits(HTTPServer, EventEmitter);
|
|
|
|
HTTPServer.prototype._init = function _init() {
|
|
var self = this;
|
|
|
|
this._initRouter();
|
|
this._initEngine();
|
|
|
|
this.server.on('connection', function(socket) {
|
|
socket.on('error', function(err) {
|
|
try {
|
|
socket.destroy();
|
|
} catch (e) {
|
|
;
|
|
}
|
|
});
|
|
});
|
|
|
|
this.get('/', function(req, res, next, send) {
|
|
send(200, {
|
|
version: require('../../package.json').version,
|
|
network: self.node.network.type
|
|
});
|
|
});
|
|
|
|
// UTXO by address
|
|
this.get('/coin/address/:address', function(req, res, next, send) {
|
|
var addresses = req.params.address.split(',');
|
|
self.node.getCoinByAddress(addresses, function(err, coins) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!coins.length)
|
|
return send(404);
|
|
|
|
send(200, coins.map(function(coin) { return coin.toJSON(); }));
|
|
});
|
|
});
|
|
|
|
// UTXO by id
|
|
this.get('/coin/:hash/:index', function(req, res, next, send) {
|
|
req.params.hash = utils.revHex(req.params.hash);
|
|
self.node.getCoin(req.params.hash, +req.params.index, function(err, coin) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!coin)
|
|
return send(404);
|
|
|
|
send(200, coin.toJSON());
|
|
});
|
|
});
|
|
|
|
// Bulk read UTXOs
|
|
this.post('/coin/address', function(req, res, next, send) {
|
|
self.node.getCoinByAddress(req.body.addresses, function(err, coins) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!coins.length)
|
|
return send(404);
|
|
|
|
send(200, coins.map(function(coin) { return coin.toJSON(); }));
|
|
});
|
|
});
|
|
|
|
// TX by hash
|
|
this.get('/tx/:hash', function(req, res, next, send) {
|
|
req.params.hash = utils.revHex(req.params.hash);
|
|
self.node.getTX(req.params.hash, function(err, tx) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!tx)
|
|
return send(404);
|
|
|
|
send(200, tx.toJSON());
|
|
});
|
|
});
|
|
|
|
// TX by address
|
|
this.get('/tx/address/:address', function(req, res, next, send) {
|
|
var addresses = req.params.address.split(',');
|
|
self.node.getTXByAddress(addresses, function(err, txs) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!txs.length)
|
|
return send(404);
|
|
|
|
send(200, txs.map(function(tx) { return tx.toJSON(); }));
|
|
});
|
|
});
|
|
|
|
// Bulk read TXs
|
|
this.post('/tx/address', function(req, res, next, send) {
|
|
self.node.getTXByAddress(req.params.addresses, function(err, txs) {
|
|
if (err)
|
|
return next(err);
|
|
if (!txs.length)
|
|
return send(404);
|
|
send(200, txs.map(function(tx) { return tx.toJSON(); }));
|
|
});
|
|
});
|
|
|
|
// Block by hash/height
|
|
this.get('/block/:hash', function(req, res, next, send) {
|
|
var hash = req.params.hash;
|
|
|
|
if (utils.isInt(hash))
|
|
hash = +hash;
|
|
else
|
|
hash = utils.revHex(hash);
|
|
|
|
self.node.getFullBlock(hash, function(err, block) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!block)
|
|
return send(404);
|
|
|
|
send(200, block.toJSON());
|
|
});
|
|
});
|
|
|
|
// Get wallet
|
|
this.get('/wallet/:id', function(req, res, next, send) {
|
|
self.node.walletdb.getJSON(req.params.id, function(err, json) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!json)
|
|
return send(404);
|
|
|
|
send(200, json);
|
|
});
|
|
});
|
|
|
|
// Create/get wallet
|
|
this.post('/wallet/:id', function(req, res, next, send) {
|
|
req.body.id = req.params.id;
|
|
self.node.walletdb.create(req.body, function(err, wallet) {
|
|
var wallet;
|
|
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!wallet)
|
|
return send(404);
|
|
|
|
json = wallet.toJSON();
|
|
wallet.destroy();
|
|
|
|
send(200, json);
|
|
});
|
|
});
|
|
|
|
// Update wallet / sync address depth
|
|
this.put('/wallet/:id', function(req, res, next, send) {
|
|
var id = req.params.id;
|
|
var receive = req.body.receiveDepth >>> 0;
|
|
var change = req.body.changeDepth >>> 0;
|
|
self.node.walletdb.setDepth(id, receive, change, function(err) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!json)
|
|
return send(404);
|
|
|
|
send(200, { success: true });
|
|
});
|
|
});
|
|
|
|
// Wallet Balance
|
|
this.get('/wallet/:id/balance', function(req, res, next, send) {
|
|
var id = req.params.id;
|
|
if (id === '_all')
|
|
id = null;
|
|
self.node.walletdb.getBalance(req.params.id, function(err, balance) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!coins.length)
|
|
return send(404);
|
|
|
|
send(200, { balance: utils.btc(balance) });
|
|
});
|
|
});
|
|
|
|
// Wallet UTXOs
|
|
this.get('/wallet/:id/coin', function(req, res, next, send) {
|
|
var id = req.params.id;
|
|
if (id === '_all')
|
|
id = null;
|
|
self.node.walletdb.getCoins(req.params.id, function(err, coins) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!coins.length)
|
|
return send(404);
|
|
|
|
send(200, coins.map(function(coin) { return coin.toJSON(); }));
|
|
});
|
|
});
|
|
|
|
// Wallet TX
|
|
this.get('/wallet/:id/coin/:hash/:index', function(req, res, next, send) {
|
|
var id = req.params.id;
|
|
if (id === '_all')
|
|
id = null;
|
|
self.node.walletdb.getCoin(req.params.hash, +req.params.index, function(err, coin) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!coin)
|
|
return send(404);
|
|
|
|
send(200, coin.toJSON());
|
|
});
|
|
});
|
|
|
|
// Wallet TXs
|
|
this.get('/wallet/:id/tx/all', function(req, res, next, send) {
|
|
var id = req.params.id;
|
|
if (id === '_all')
|
|
id = null;
|
|
self.node.walletdb.getAll(req.params.id, function(err, txs) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!txs.length)
|
|
return send(404);
|
|
|
|
send(200, txs.map(function(tx) { return tx.toJSON(); }));
|
|
});
|
|
});
|
|
|
|
// Wallet Pending TXs
|
|
this.get('/wallet/:id/tx/pending', function(req, res, next, send) {
|
|
var id = req.params.id;
|
|
if (id === '_all')
|
|
id = null;
|
|
self.node.walletdb.getPending(req.params.id, function(err, txs) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!txs.length)
|
|
return send(404);
|
|
|
|
send(200, txs.map(function(tx) { return tx.toJSON(); }));
|
|
});
|
|
});
|
|
|
|
// Wallet TXs within time range
|
|
this.get('/wallet/:id/tx/range', function(req, res, next, send) {
|
|
var id = req.params.id;
|
|
if (id === '_all')
|
|
id = null;
|
|
|
|
var options = {
|
|
start: +req.query.start,
|
|
end: +req.query.end,
|
|
limit: +req.query.limit
|
|
};
|
|
|
|
self.node.walletdb.getTimeRange(req.params.id, options, function(err, txs) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!txs.length)
|
|
return send(404);
|
|
|
|
send(200, txs.map(function(tx) { return tx.toJSON(); }));
|
|
});
|
|
});
|
|
|
|
// Wallet TXs within time range
|
|
this.get('/wallet/:id/tx/last', function(req, res, next, send) {
|
|
var id = req.params.id;
|
|
if (id === '_all')
|
|
id = null;
|
|
|
|
self.node.walletdb.getTimeRange(id, +req.query.limit, function(err, txs) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!txs.length)
|
|
return send(404);
|
|
|
|
send(200, txs.map(function(tx) { return tx.toJSON(); }));
|
|
});
|
|
});
|
|
|
|
// Wallet TX
|
|
this.get('/wallet/:id/tx/:hash', function(req, res, next, send) {
|
|
self.node.walletdb.getTX(req.params.hash, function(err, tx) {
|
|
if (err)
|
|
return next(err);
|
|
|
|
if (!tx)
|
|
return send(404);
|
|
|
|
send(200, tx.toJSON());
|
|
});
|
|
});
|
|
|
|
this.post('/broadcast', function(req, res, next, send) {
|
|
self.node.pool.broadcast(bcoin.tx.fromRaw(req.body.tx, 'hex'));
|
|
send(200, { success: true });
|
|
});
|
|
};
|
|
|
|
HTTPServer.prototype._initEngine = function _initEngine() {
|
|
var self = this;
|
|
|
|
if (!engine)
|
|
return;
|
|
|
|
this.clients = [];
|
|
|
|
this.engine = new engine.Server();
|
|
|
|
this.engine.attach(this.server);
|
|
|
|
this.engine.on('connection', function(socket) {
|
|
var s = new Socket(self, socket);
|
|
|
|
socket.on('message', function(data) {
|
|
s.parse(data);
|
|
});
|
|
|
|
socket.on('close', function() {
|
|
s.destroy();
|
|
});
|
|
|
|
socket.on('error', function(err) {
|
|
self.emit('error', err);
|
|
});
|
|
|
|
s.on('error', function(err) {
|
|
self.emit('error', err);
|
|
});
|
|
});
|
|
};
|
|
|
|
HTTPServer.prototype.listen = function listen(port, host, callback) {
|
|
var self = this;
|
|
this.server.listen(port, host, function(err) {
|
|
var address;
|
|
|
|
if (err)
|
|
throw err;
|
|
|
|
address = self.server.address();
|
|
|
|
utils.debug('Listening - host=%s port=%d',
|
|
address.address, address.port);
|
|
|
|
if (callback)
|
|
callback();
|
|
});
|
|
};
|
|
|
|
HTTPServer.prototype._initRouter = function _initRouter() {
|
|
var self = this;
|
|
|
|
this.server.on('request', function(req, res) {
|
|
function _send(code, msg) {
|
|
send(res, code, msg);
|
|
}
|
|
|
|
function done(err) {
|
|
if (err) {
|
|
send(res, 400, { error: err.stack + '' });
|
|
try {
|
|
req.destroy();
|
|
req.socket.destroy();
|
|
} catch (e) {
|
|
;
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
parsePath(req);
|
|
} catch (e) {
|
|
done(e);
|
|
}
|
|
|
|
utils.debug('Request from %s path=%s',
|
|
req.socket.remoteAddress, req.pathname);
|
|
|
|
parseBody(req, function(err) {
|
|
var method, routes, i;
|
|
|
|
if (err)
|
|
return done(err);
|
|
|
|
method = (req.method || 'GET').toLowerCase();
|
|
routes = self.routes[method];
|
|
i = 0;
|
|
|
|
if (!routes)
|
|
return done(new Error('No routes found.'));
|
|
|
|
(function next(err) {
|
|
var route, path, callback, compiled, matched;
|
|
|
|
if (err)
|
|
return done(err);
|
|
|
|
if (i === routes.length)
|
|
return done(new Error('Route not found.'));
|
|
|
|
route = routes[i++];
|
|
path = route.path;
|
|
callback = route.callback;
|
|
|
|
if (!route.regex) {
|
|
compiled = compilePath(path);
|
|
route.regex = compiled.regex;
|
|
route.map = compiled.map;
|
|
}
|
|
|
|
matched = route.regex.exec(req.pathname);
|
|
|
|
if (!matched)
|
|
return next();
|
|
|
|
req.params = {};
|
|
matched.slice(1).forEach(function(item, i) {
|
|
if (route.map[i])
|
|
req.params[route.map[i]] = item;
|
|
req.params[i] = item;
|
|
});
|
|
|
|
// Avoid stack overflows
|
|
utils.nextTick(function() {
|
|
try {
|
|
callback(req, res, next, _send);
|
|
} catch (e) {
|
|
done(e);
|
|
}
|
|
});
|
|
})();
|
|
});
|
|
});
|
|
};
|
|
|
|
HTTPServer.prototype.get = function get(path, callback) {
|
|
this.routes.get.push({ path: path, callback: callback });
|
|
};
|
|
|
|
HTTPServer.prototype.post = function post(path, callback) {
|
|
this.routes.post.push({ path: path, callback: callback });
|
|
};
|
|
|
|
HTTPServer.prototype.put = function put(path, callback) {
|
|
this.routes.put.push({ path: path, callback: callback });
|
|
};
|
|
|
|
HTTPServer.prototype.del = function del(path, callback) {
|
|
this.routes.del.push({ path: path, callback: callback });
|
|
};
|
|
|
|
HTTPServer.prototype.sendWebhook = function sendWebhook(msg, callback) {
|
|
var request, body, secret, hmac;
|
|
|
|
callback = utils.ensure(callback);
|
|
|
|
if (!this.options.webhook)
|
|
return callback();
|
|
|
|
try {
|
|
request = require('request');
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
|
|
body = new Buffer(JSON.stringify(msg) + '\n', 'utf8');
|
|
secret = new Buffer(this.options.webhook.secret || '', 'utf8');
|
|
hmac = utils.sha512hmac(body, secret);
|
|
|
|
request({
|
|
method: 'POST',
|
|
uri: this.options.webhook.endpoint,
|
|
headers: {
|
|
'Content-Type': 'application/json; charset=utf-8',
|
|
'Content-Length': body.length + '',
|
|
'X-Bcoin-Hmac': hmac.toString('hex')
|
|
},
|
|
body: body
|
|
}, function(err, res, body) {
|
|
if (err)
|
|
return callback(err);
|
|
return callback();
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Helpers
|
|
*/
|
|
|
|
function send(res, code, msg) {
|
|
if (!msg)
|
|
msg = { error: 'No message.' };
|
|
|
|
try {
|
|
res.statusCode = code;
|
|
msg = JSON.stringify(msg, null, 2) + '\n';
|
|
res.setHeader('Content-Type', 'application/json; charset=utf-8');
|
|
res.setHeader('Content-Length', Buffer.byteLength(msg) + '');
|
|
res.write(msg);
|
|
res.end();
|
|
} catch (e) {
|
|
utils.debug('Write failed: %s', e.message);
|
|
}
|
|
}
|
|
|
|
function compilePath(path) {
|
|
var map = [];
|
|
|
|
if (path instanceof RegExp)
|
|
return { regex: path, map: map };
|
|
|
|
var regex = path
|
|
.replace(/([^\/]+)\?/g, '(?:$1)?')
|
|
.replace(/\.(?!\+)/g, '\\.')
|
|
.replace(/\*/g, '.*?')
|
|
.replace(/%/g, '\\')
|
|
.replace(/:(\w+)/g, function(__, name) {
|
|
map.push(name);
|
|
return '([^/]+)';
|
|
}
|
|
);
|
|
|
|
regex = new RegExp('^' + regex + '$');
|
|
|
|
return {
|
|
map: map,
|
|
regex: regex
|
|
};
|
|
}
|
|
|
|
function parseBody(req, callback) {
|
|
var decode = new StringDecoder('utf8');
|
|
var total = 0;
|
|
var body = '';
|
|
|
|
req.body = {};
|
|
|
|
if (req.method === 'GET')
|
|
return callback();
|
|
|
|
req.on('data', function(data) {
|
|
total += data.length;
|
|
|
|
if (total > 20 * 1024 * 1024)
|
|
return callback(new Error('Overflow.'));
|
|
|
|
body += decode.write(data);
|
|
});
|
|
|
|
req.on('error', function(err) {
|
|
try {
|
|
req.destroy();
|
|
req.socket.destroy();
|
|
} catch (e) {
|
|
;
|
|
}
|
|
callback(err);
|
|
});
|
|
|
|
req.on('end', function() {
|
|
try {
|
|
if (body)
|
|
req.body = JSON.parse(body);
|
|
} catch (e) {
|
|
return callback(e);
|
|
}
|
|
callback();
|
|
});
|
|
}
|
|
|
|
function parsePairs(str, del, eq) {
|
|
var out, s, i, parts;
|
|
|
|
if (!str)
|
|
return {};
|
|
|
|
if (!del)
|
|
del = '&';
|
|
|
|
if (!eq)
|
|
eq = '=';
|
|
|
|
out = {};
|
|
s = str.split(del);
|
|
|
|
for (i = 0; i < s.length; i++) {
|
|
parts = s[i].split(eq);
|
|
if (parts[0]) {
|
|
parts[0] = unescape(parts[0]);
|
|
parts[1] = parts[1] ? unescape(parts[1]) : '';
|
|
out[parts[0]] = parts[1];
|
|
}
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
function parsePath(req) {
|
|
var uri = url.parse(req.url);
|
|
var pathname = uri.pathname || '/';
|
|
|
|
if (pathname[pathname.length - 1] === '/')
|
|
pathname = pathname.slice(0, -1);
|
|
|
|
pathname = unescape(pathname);
|
|
|
|
req.path = pathname;
|
|
|
|
if (req.path[0] === '/')
|
|
req.path = req.path.substring(1);
|
|
|
|
req.path = req.path.split('/');
|
|
|
|
if (!req.path[0])
|
|
req.path = [];
|
|
|
|
req.pathname = pathname || '/';
|
|
|
|
if (req.url.indexOf('//') !== -1) {
|
|
req.url = req.url.replace(/^([^:\/]+)?\/\/[^\/]+/, '');
|
|
if (!req.url)
|
|
req.url = '/';
|
|
}
|
|
|
|
if (!req.query) {
|
|
req.query = uri.query
|
|
? parsePairs(uri.query, '&')
|
|
: {};
|
|
}
|
|
}
|
|
|
|
function escape(str) {
|
|
return encodeURIComponent(str).replace(/%20/g, '+');
|
|
}
|
|
|
|
function unescape(str) {
|
|
try {
|
|
str = decodeURIComponent(str).replace(/\+/g, ' ');
|
|
} finally {
|
|
return str.replace(/\0/g, '');
|
|
}
|
|
}
|
|
|
|
function Socket(server, socket) {
|
|
this.server = server;
|
|
this.engine = server.engine;
|
|
this.node = server.node;
|
|
this.walletdb = server.node.walletdb;
|
|
this.socket = socket;
|
|
this.listeners = {};
|
|
this._init();
|
|
}
|
|
|
|
Socket.prototype._init = function _init() {
|
|
this.server.clients.push(this);
|
|
};
|
|
|
|
Socket.prototype.parse = function parse(msg) {
|
|
var size, off, header, payload;
|
|
|
|
size = utils.readIntv(msg, 0);
|
|
off = size.off;
|
|
size = size.r;
|
|
|
|
if (off + size > msg.length)
|
|
return this.send({ event: 'error', msg: 'Size larger than message.' });
|
|
|
|
try {
|
|
header = JSON.parse(msg.slice(off, off + size).toString('utf8'));
|
|
off += size;
|
|
} catch (e) {
|
|
return this.send({ event: 'error', msg: 'Header malformed.' });
|
|
}
|
|
|
|
payload = data.slice(off);
|
|
|
|
try {
|
|
return this._handle(header, payload);
|
|
} catch (e) {
|
|
return this.send({ event: 'error', msg: e.message + '' });
|
|
}
|
|
};
|
|
|
|
Socket.prototype._handle = function _handle(header, payload) {
|
|
if (header.cmd === 'handshake')
|
|
return this._handleHandshake(header, payload);
|
|
|
|
if (header.cmd === 'listen')
|
|
return this._handleListen(header, payload);
|
|
|
|
if (header.cmd === 'unlisten')
|
|
return this._handleUnlisten(header, payload);
|
|
|
|
if (header.event)
|
|
return this.emit(header.event, header, payload);
|
|
|
|
throw new Error('Not a valid command.');
|
|
};
|
|
|
|
Socket.prototype.destroy = function destroy() {
|
|
this.remove();
|
|
this.cleanup();
|
|
return this.clients.destroy();
|
|
};
|
|
|
|
Socket.prototype.remove = function remove() {
|
|
var i = this.server.clients.indexOf(this);
|
|
if (i !== -1)
|
|
this.server.clients.splice(i, 1);
|
|
};
|
|
|
|
Socket.prototype.cleanup = function cleanup() {
|
|
Object.keys(this.listeners).forEach(function(id) {
|
|
this.unlistenWallet(id);
|
|
}, this);
|
|
};
|
|
|
|
Socket.prototype.unlistenWallet = function unlistenWallet(id) {
|
|
this.listeners[id].forEach(function(listener) {
|
|
this.walletdb.removeListener(listener[0], listener[1]);
|
|
}, this);
|
|
|
|
delete this.listeners[id];
|
|
};
|
|
|
|
Socket.prototype._listenWallet = function _listenWallet(id, event, listener) {
|
|
if (!this.listeners[id])
|
|
this.listeners[id] = [];
|
|
|
|
this.listeners[id].push([event, listener]);
|
|
this.walletdb.on(event, listener);
|
|
};
|
|
|
|
Socket.prototype.listenWallet = function listenWallet(event, id, listener) {
|
|
if (id === '_all') {
|
|
this._listenWallet(id, 'tx', function(tx, map) {
|
|
self.send({ event: 'tx', map: map, id: id, _payload: tx.toExtended() });
|
|
});
|
|
|
|
this._listenWallet(id, 'updated', function(tx, map) {
|
|
self.send({ event: 'updated', map: map, id: id, _payload: tx.toExtended() });
|
|
});
|
|
|
|
this._listenWallet(id, 'confirmed', function(tx, map) {
|
|
self.send({ event: 'confirmed', map: map, id: id, _payload: tx.toExtended() });
|
|
});
|
|
|
|
this._listenWallet(id, 'unconfirmed', function(tx, map) {
|
|
self.send({ event: 'unconfirmed', map: map, id: id, _payload: tx.toExtended() });
|
|
});
|
|
|
|
this._listenWallet(id, 'balances', function(balances) {
|
|
Object.keys(balances).forEach(function(key) {
|
|
balances[key] = utils.btc(balances[key]);
|
|
});
|
|
self.send({ event: 'balances', id: id, balances: balances });
|
|
});
|
|
|
|
return;
|
|
}
|
|
|
|
this._listenWallet(id, id + ' tx', function(tx) {
|
|
self.send({ event: 'tx', id: id, _payload: tx.toExtended() });
|
|
});
|
|
|
|
this._listenWallet(id, id + ' updated', function(tx) {
|
|
self.send({ event: 'updated', id: id, _payload: tx.toExtended() });
|
|
});
|
|
|
|
this._listenWallet(id, id + ' confirmed', function(tx) {
|
|
self.send({ event: 'confirmed', id: id, _payload: tx.toExtended() });
|
|
});
|
|
|
|
this._listenWallet(id, id + ' unconfirmed', function(tx) {
|
|
self.send({ event: 'unconfirmed', id: id, _payload: tx.toExtended() });
|
|
});
|
|
|
|
this._listenWallet(id, id + ' balance', function(balance) {
|
|
self.send({ event: 'balance', id: id, balance: utils.btc(balance) });
|
|
});
|
|
};
|
|
|
|
Socket.prototype._onListen = function _onListen(header, payload) {
|
|
var self = this;
|
|
var id = header.id;
|
|
|
|
if (typeof id !== 'string')
|
|
throw new Error('Wallet ID is not a string.');
|
|
|
|
if (id.length > 1000)
|
|
throw new Error('Wallet ID too large.');
|
|
|
|
if (!/^[a-zA-Z0-9]+$/.test(id))
|
|
throw new Error('Wallet ID must be alphanumeric.');
|
|
|
|
if (this.listeners[id])
|
|
throw new Error('Already listening.');
|
|
|
|
this.listenWallet(id);
|
|
};
|
|
|
|
Socket.prototype._onUnlisten = function _onUnlisten(header, payload) {
|
|
var self = this;
|
|
var id = header.id;
|
|
|
|
if (typeof id !== 'string')
|
|
throw new Error('Wallet ID is not a string.');
|
|
|
|
if (id.length > 1000)
|
|
throw new Error('Wallet ID too large.');
|
|
|
|
if (!/^[a-zA-Z0-9]+$/.test(id))
|
|
throw new Error('Wallet ID must be alphanumeric.');
|
|
|
|
if (!this.listeners[id])
|
|
throw new Error('Not listening.');
|
|
|
|
this.unlistenWallet(id);
|
|
};
|
|
|
|
Socket.prototype._handleHandshake = function _handleHandshake(header, payload) {
|
|
if (this._activated)
|
|
throw new Error('Handshake already completed.');
|
|
|
|
if (payload.length > 0)
|
|
throw new Error('Unexpected payload.');
|
|
|
|
this._activated = true;
|
|
};
|
|
|
|
Socket.prototype.send = function send(data) {
|
|
var header, payload, size, msg;
|
|
|
|
if (data._payload) {
|
|
payload = data._payload;
|
|
delete data._payload;
|
|
} else {
|
|
payload = new Buffer([]);
|
|
}
|
|
|
|
assert(Buffer.isBuffer(payload));
|
|
|
|
header = new Buffer(JSON.stringify(data), 'utf8');
|
|
|
|
size = new Buffer(utils.sizeIntv(header.length));
|
|
utils.writeIntv(size, header.length, 0);
|
|
|
|
msg = Buffer.concat([size, header, payload]);
|
|
|
|
return this.socket.send(msg);
|
|
};
|
|
|
|
/**
|
|
* Expose
|
|
*/
|
|
|
|
module.exports = HTTPServer;
|