@sangaman/xud
Version:
Exchange Union Daemon
316 lines • 14 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result["default"] = mod;
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
/* tslint:disable no-floating-promises no-null-keyword */
const grpc_1 = require("grpc");
const xudrpc = __importStar(require("../proto/xudrpc_pb"));
const errors_1 = require("../orderbook/errors");
const errors_2 = require("../service/errors");
const errors_3 = require("../p2p/errors");
/**
* Convert a [[StampedOrder]] to an xudrpc Order message.
*/
const getOrder = (order) => {
const grpcOrder = new xudrpc.Order();
grpcOrder.setCanceled(false);
grpcOrder.setCreatedAt(order.createdAt);
grpcOrder.setId(order.id);
grpcOrder.setLocalId(order.localId);
grpcOrder.setPairId(order.pairId);
grpcOrder.setPeerPubKey(order.peerPubKey);
grpcOrder.setPrice(order.price);
grpcOrder.setQuantity(order.quantity);
return grpcOrder;
};
/** Class containing the available RPC methods for XUD */
class GrpcService {
/** Create an instance of available RPC methods and bind all exposed functions. */
constructor(logger, service) {
this.logger = logger;
this.service = service;
/**
* Convert an internal xud error type into a gRPC error.
* @param err an error object that should have code and message properties
* @return a gRPC error with a gRPC status code
*/
this.getGrpcError = (err) => {
// if we recognize this error, use a proper gRPC ServiceError with a descriptive and appropriate code
let code;
switch (err.code) {
case errors_2.errorCodes.INVALID_ARGUMENT:
case errors_3.errorCodes.ATTEMPTED_CONNECTION_TO_SELF:
code = grpc_1.status.INVALID_ARGUMENT;
break;
case errors_1.errorCodes.INVALID_PAIR_ID:
code = grpc_1.status.NOT_FOUND;
break;
case errors_1.errorCodes.DUPLICATE_ORDER:
case errors_3.errorCodes.NODE_ALREADY_CONNECTED:
code = grpc_1.status.ALREADY_EXISTS;
break;
case errors_3.errorCodes.NOT_CONNECTED:
code = grpc_1.status.FAILED_PRECONDITION;
break;
}
// return a grpc error with the code if we've assigned one, otherwise pass along the caught error as UNKNOWN
const grpcError = {
code: code || grpc_1.status.UNKNOWN,
message: err.message,
name: err.name,
};
this.logger.error(grpcError);
return grpcError;
};
/**
* See [[Service.cancelOrder]]
*/
this.cancelOrder = (call, callback) => __awaiter(this, void 0, void 0, function* () {
try {
const cancelOrderResponse = yield this.service.cancelOrder(call.request.toObject());
const response = new xudrpc.CancelOrderResponse();
response.setCanceled(cancelOrderResponse.canceled);
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
});
/**
* See [[Service.connect]]
*/
this.connect = (call, callback) => __awaiter(this, void 0, void 0, function* () {
try {
const connectResponse = yield this.service.connect(call.request.toObject());
const response = new xudrpc.ConnectResponse();
response.setResult(connectResponse);
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
});
/**
* See [[Service.disconnect]]
*/
this.disconnect = (call, callback) => __awaiter(this, void 0, void 0, function* () {
try {
const disconnectResponse = yield this.service.disconnect(call.request.toObject());
const response = new xudrpc.DisconnectResponse();
response.setResult(disconnectResponse);
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
});
/**
* See [[Service.executeSwap]]
*/
this.executeSwap = (call, callback) => {
try {
const executeSwapResponse = this.service.executeSwap(call.request.toObject());
const response = new xudrpc.ExecuteSwapResponse();
response.setResult(executeSwapResponse);
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
};
/**
* See [[Service.getInfo]]
*/
this.getInfo = (_, callback) => __awaiter(this, void 0, void 0, function* () {
try {
const getInfoResponse = yield this.service.getInfo();
const response = new xudrpc.GetInfoResponse();
response.setNumPairs(getInfoResponse.numPairs);
response.setNumPeers(getInfoResponse.numPeers);
response.setVersion(getInfoResponse.version);
const getLndInfo = ((lndInfo) => {
const lnd = new xudrpc.LndInfo();
if (lndInfo.blockheight)
lnd.setBlockheight(lndInfo.blockheight);
if (lndInfo.chains)
lnd.setChainsList(lndInfo.chains);
if (lndInfo.channels) {
const channels = new xudrpc.LndChannels();
channels.setActive(lndInfo.channels.active);
channels.setPending(lndInfo.channels.pending);
if (lndInfo.channels.inactive)
channels.setInactive(lndInfo.channels.inactive);
lnd.setChannels(channels);
}
if (lndInfo.error)
lnd.setError(lndInfo.error);
if (lndInfo.uris)
lnd.setUrisList(lndInfo.uris);
if (lndInfo.version)
lnd.setVersion(lndInfo.version);
return lnd;
});
if (getInfoResponse.lndbtc)
response.setLndbtc(getLndInfo(getInfoResponse.lndbtc));
if (getInfoResponse.lndltc)
response.setLndltc(getLndInfo(getInfoResponse.lndltc));
if (getInfoResponse.raiden) {
const raiden = new xudrpc.RaidenInfo();
if (getInfoResponse.raiden.address)
raiden.setAddress(getInfoResponse.raiden.address);
if (getInfoResponse.raiden.channels)
raiden.setChannels(getInfoResponse.raiden.channels);
if (getInfoResponse.raiden.error)
raiden.setError(getInfoResponse.raiden.error);
if (getInfoResponse.raiden.version)
raiden.setVersion(getInfoResponse.raiden.version);
response.setRaiden(raiden);
}
const orders = new xudrpc.OrdersCount;
orders.setOwn(getInfoResponse.orders.own);
orders.setPeer(getInfoResponse.orders.peer);
response.setOrders(orders);
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
});
/**
* See [[Service.getOrders]]
*/
this.getOrders = (call, callback) => {
try {
const getOrdersResponse = this.service.getOrders(call.request.toObject());
const response = new xudrpc.GetOrdersResponse();
const getOrdersList = (orders) => {
const ordersList = [];
orders.forEach(order => ordersList.push(getOrder(order)));
return ordersList;
};
const getOrders = (orderArrays) => {
const orders = new xudrpc.Orders();
orders.setBuyOrdersList(getOrdersList(orderArrays.buyOrders));
orders.setSellOrdersList(getOrdersList(orderArrays.sellOrders));
return orders;
};
response.setOwnOrders(getOrders(getOrdersResponse.ownOrders));
response.setPeerOrders(getOrders(getOrdersResponse.peerOrders));
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
};
/**
* See [[Service.getPairs]]
*/
this.getPairs = (_, callback) => {
try {
const getPairsResponse = this.service.getPairs();
const response = new xudrpc.GetPairsResponse();
const pairs = [];
getPairsResponse.forEach((pairInstance) => {
const pair = new xudrpc.Pair();
pair.setBaseCurrency(pairInstance.baseCurrency);
pair.setId(pairInstance.id);
pair.setQuoteCurrency(pairInstance.quoteCurrency);
pair.setSwapProtocol(pairInstance.swapProtocol);
pairs.push(pair);
});
response.setPairsList(pairs);
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
};
/**
* See [[Service.listPeers]]
*/
this.listPeers = (_, callback) => {
try {
const listPeersResponse = this.service.listPeers();
const response = new xudrpc.ListPeersResponse();
const peers = [];
listPeersResponse.forEach((peer) => {
const grpcPeer = new xudrpc.Peer();
grpcPeer.setAddress(peer.address);
grpcPeer.setInbound(peer.inbound);
grpcPeer.setNodePubKey(peer.nodePubKey || '');
grpcPeer.setPairsList(peer.pairs || []);
grpcPeer.setSecondsConnected(peer.secondsConnected);
grpcPeer.setXudVersion(peer.xudVersion || '');
peers.push(grpcPeer);
});
response.setPeersList(peers);
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
};
/**
* See [[Service.placeOrder]]
*/
this.placeOrder = (call, callback) => __awaiter(this, void 0, void 0, function* () {
try {
const placeOrderResponse = yield this.service.placeOrder(call.request.toObject());
const response = new xudrpc.PlaceOrderResponse();
const matchesList = [];
placeOrderResponse.matches.forEach((match) => {
const orderMatch = new xudrpc.OrderMatch();
orderMatch.setMaker(getOrder(match.maker));
orderMatch.setTaker(getOrder(match.taker));
matchesList.push(orderMatch);
});
response.setMatchesList(matchesList);
if (placeOrderResponse.remainingOrder) {
response.setRemainingOrder(getOrder(placeOrderResponse.remainingOrder));
}
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
});
this.shutdown = (_, callback) => {
try {
const shutdownResponse = this.service.shutdown();
const response = new xudrpc.ShutdownResponse();
response.setResult(shutdownResponse);
callback(null, response);
}
catch (err) {
callback(this.getGrpcError(err), null);
}
};
/*
* See [[Service.subscribePeerOrders]]
*/
this.subscribePeerOrders = (call) => {
this.service.subscribePeerOrders((order) => call.write({ order }));
};
/*
* See [[Service.subscribeSwaps]]
*/
this.subscribeSwaps = (call) => {
this.service.subscribeSwaps((order) => call.write({ order }));
};
}
}
exports.default = GrpcService;
//# sourceMappingURL=GrpcService.js.map