xud
Version:
Exchange Union Daemon
982 lines • 40.9 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
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)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
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) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
/* tslint:disable no-floating-promises no-null-keyword */
const grpc_1 = require("grpc");
const rxjs_1 = require("rxjs");
const operators_1 = require("rxjs/operators");
const enums_1 = require("../constants/enums");
const types_1 = require("../orderbook/types");
const xudrpc = __importStar(require("../proto/xudrpc_pb"));
const getGrpcError_1 = __importDefault(require("./getGrpcError"));
/**
* Creates an xudrpc Order message from an [[Order]].
*/
const createServiceOrder = (order) => {
const grpcOrder = new xudrpc.Order();
grpcOrder.setCreatedAt(order.createdAt);
grpcOrder.setId(order.id);
if (order.hold) {
grpcOrder.setHold(order.hold);
}
if (order.localId) {
grpcOrder.setLocalId(order.localId);
}
grpcOrder.setIsOwnOrder(order.isOwnOrder);
const nodeIdentifier = new xudrpc.NodeIdentifier();
nodeIdentifier.setNodePubKey(order.nodeIdentifier.nodePubKey);
if (order.nodeIdentifier.alias) {
nodeIdentifier.setAlias(order.nodeIdentifier.alias);
}
grpcOrder.setNodeIdentifier(nodeIdentifier);
grpcOrder.setPairId(order.pairId);
if (order.price) {
grpcOrder.setPrice(order.price);
}
if (order.quantity) {
grpcOrder.setQuantity(order.quantity);
}
grpcOrder.setSide(order.side);
return grpcOrder;
};
const createOrder = (order) => {
const grpcOrder = new xudrpc.Order();
grpcOrder.setCreatedAt(order.createdAt);
grpcOrder.setId(order.id);
if (types_1.isOwnOrder(order)) {
grpcOrder.setHold(order.hold);
grpcOrder.setLocalId((order).localId);
grpcOrder.setIsOwnOrder(true);
}
else {
const nodeIdentifier = new xudrpc.NodeIdentifier();
nodeIdentifier.setNodePubKey(order.peerPubKey);
grpcOrder.setNodeIdentifier(nodeIdentifier);
grpcOrder.setIsOwnOrder(false);
}
grpcOrder.setPairId(order.pairId);
grpcOrder.setPrice(order.price);
grpcOrder.setQuantity(order.quantity);
grpcOrder.setSide(order.isBuy ? xudrpc.OrderSide.BUY : xudrpc.OrderSide.SELL);
return grpcOrder;
};
/**
* Creates an xudrpc SwapSuccess message from a [[SwapSuccess]].
*/
const createSwapSuccess = (result) => {
const swapSuccess = new xudrpc.SwapSuccess();
swapSuccess.setOrderId(result.orderId);
swapSuccess.setLocalId(result.localId);
swapSuccess.setPairId(result.pairId);
swapSuccess.setQuantity(result.quantity);
swapSuccess.setRHash(result.rHash);
swapSuccess.setPrice(result.price);
swapSuccess.setRPreimage(result.rPreimage ? result.rPreimage : '');
swapSuccess.setAmountReceived(result.amountReceived);
swapSuccess.setAmountSent(result.amountSent);
swapSuccess.setCurrencyReceived(result.currencyReceived);
swapSuccess.setCurrencySent(result.currencySent);
swapSuccess.setPeerPubKey(result.peerPubKey);
swapSuccess.setRole(result.role);
return swapSuccess;
};
/**
* Creates an xudrpc SwapFailure message from a [[SwapFailure]].
*/
const createSwapFailure = (swapFailure) => {
const grpcSwapFailure = new xudrpc.SwapFailure();
grpcSwapFailure.setOrderId(swapFailure.orderId);
grpcSwapFailure.setPairId(swapFailure.pairId);
grpcSwapFailure.setPeerPubKey(swapFailure.peerPubKey);
grpcSwapFailure.setQuantity(swapFailure.quantity);
grpcSwapFailure.setFailureReason(enums_1.SwapFailureReason[swapFailure.failureReason]);
return grpcSwapFailure;
};
/**
* Creates an xudrpc SwapAccepted message from a [[SwapAccepted]].
*/
const createSwapAccepted = (swapAccepted) => {
const grpcSwapAccepted = new xudrpc.SwapAccepted();
grpcSwapAccepted.setOrderId(swapAccepted.orderId);
grpcSwapAccepted.setLocalId(swapAccepted.localId);
grpcSwapAccepted.setQuantity(swapAccepted.quantity);
grpcSwapAccepted.setRHash(swapAccepted.rHash);
grpcSwapAccepted.setPrice(swapAccepted.price);
grpcSwapAccepted.setAmountReceiving(swapAccepted.amountReceiving);
grpcSwapAccepted.setAmountSending(swapAccepted.amountSending);
grpcSwapAccepted.setCurrencyReceiving(swapAccepted.currencyReceiving);
grpcSwapAccepted.setCurrencySending(swapAccepted.currencySending);
grpcSwapAccepted.setPeerPubKey(swapAccepted.peerPubKey);
grpcSwapAccepted.setPairId(swapAccepted.pairId);
return grpcSwapAccepted;
};
/**
* Creates an xudrpc PlaceOrderResponse message from a [[PlaceOrderResult]].
*/
const createPlaceOrderResponse = (result) => {
const response = new xudrpc.PlaceOrderResponse();
const internalMatches = result.internalMatches.map(match => createOrder(match));
response.setInternalMatchesList(internalMatches);
const swapSuccesses = result.swapSuccesses.map(swapSuccess => createSwapSuccess(swapSuccess));
response.setSwapSuccessesList(swapSuccesses);
const swapFailures = result.swapFailures.map(swapFailure => createSwapFailure(swapFailure));
response.setSwapFailuresList(swapFailures);
if (result.remainingOrder) {
response.setRemainingOrder(createOrder(result.remainingOrder));
}
return response;
};
/**
* Creates an xudrpc PlaceOrderEvent message from a [[PlaceOrderEvent]].
*/
const createPlaceOrderEvent = (e) => {
const placeOrderEvent = new xudrpc.PlaceOrderEvent();
switch (e.type) {
case types_1.PlaceOrderEventType.Match:
placeOrderEvent.setMatch(createServiceOrder(e.order));
break;
case types_1.PlaceOrderEventType.SwapSuccess:
placeOrderEvent.setSwapSuccess(createSwapSuccess(e.swapSuccess));
break;
case types_1.PlaceOrderEventType.RemainingOrder:
placeOrderEvent.setRemainingOrder(createServiceOrder(e.order));
break;
case types_1.PlaceOrderEventType.SwapFailure:
placeOrderEvent.setSwapFailure(createSwapFailure(e.swapFailure));
break;
}
return placeOrderEvent;
};
const getCancelled$ = (call) => {
return rxjs_1.fromEvent(call, 'cancelled').pipe(operators_1.take(1));
};
/** Class containing the available RPC methods for XUD */
class GrpcService {
/** Create an instance of available RPC methods and bind all exposed functions. */
constructor() {
this.locked = false;
/** The set of active streaming calls. */
this.streams = new Set();
/** Closes and removes all active streaming calls. */
this.closeStreams = () => {
this.streams.forEach((stream) => {
stream.end();
});
this.streams.clear();
};
/** Adds an active streaming call and adds a listener to remove it if it is cancelled. */
this.addStream = (stream) => {
this.streams.add(stream);
stream.once('cancelled', () => {
this.streams.delete(stream);
});
};
/**
* Checks whether this service is ready to handle calls and sends an error to the client
* caller if not ready.
* @returns `true` if the service is ready, otherwise `false`
*/
this.isReady = (service, callbackOrCall) => {
if (!service) {
const err = this.locked ?
{ code: grpc_1.status.UNIMPLEMENTED, message: 'xud is locked', name: 'LockedError' } :
{ code: grpc_1.status.UNAVAILABLE, message: 'xud is starting', name: 'NotReadyError' };
if (typeof callbackOrCall === 'function') {
const callback = callbackOrCall;
callback(err, null);
}
else {
const call = callbackOrCall;
call.emit('error', err);
}
return false;
}
return true;
};
/**
* See [[Service.addCurrency]]
*/
this.addCurrency = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
yield this.service.addCurrency(call.request.toObject());
const response = new xudrpc.AddCurrencyResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.addPair]]
*/
this.addPair = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
yield this.service.addPair(call.request.toObject());
const response = new xudrpc.AddPairResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.closeChannel]]
*/
this.closeChannel = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const txIds = yield this.service.closeChannel(call.request.toObject());
const response = new xudrpc.CloseChannelResponse();
response.setTransactionIdsList(txIds);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.removeOrder]]
*/
this.removeOrder = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const { removedQuantity, remainingQuantity, onHoldQuantity, pairId } = this.service.removeOrder(call.request.toObject());
const response = new xudrpc.RemoveOrderResponse();
response.setQuantityOnHold(onHoldQuantity);
response.setRemainingQuantity(remainingQuantity);
response.setRemovedQuantity(removedQuantity);
response.setPairId(pairId);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.removeAllOrders]]
*/
this.removeAllOrders = (_, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const { removedOrderLocalIds, onHoldOrderLocalIds } = yield this.service.removeAllOrders();
const response = new xudrpc.RemoveAllOrdersResponse();
response.setRemovedOrderIdsList(removedOrderLocalIds);
response.setOnHoldOrderIdsList(onHoldOrderLocalIds);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.getBalance]]
*/
this.getBalance = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const balanceResponse = yield this.service.getBalance(call.request.toObject());
const response = new xudrpc.GetBalanceResponse();
const balancesMap = response.getBalancesMap();
balanceResponse.forEach((balanceObj, currency) => {
const balance = new xudrpc.Balance();
balance.setTotalBalance(balanceObj.totalBalance);
balance.setChannelBalance(balanceObj.channelBalance);
balance.setPendingChannelBalance(balanceObj.pendingChannelBalance);
balance.setInactiveChannelBalance(balanceObj.inactiveChannelBalance);
balance.setWalletBalance(balanceObj.walletBalance);
balance.setUnconfirmedWalletBalance(balanceObj.unconfirmedWalletBalance);
balancesMap.set(currency, balance);
});
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.tradingLimits]]
*/
this.tradingLimits = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const tradingLimitsResponse = yield this.service.tradingLimits(call.request.toObject());
const response = new xudrpc.TradingLimitsResponse();
const limitsMap = response.getLimitsMap();
tradingLimitsResponse.forEach((tradingLimitsObj, currency) => {
const tradingLimits = new xudrpc.TradingLimits();
tradingLimits.setMaxSell(tradingLimitsObj.maxSell);
tradingLimits.setMaxBuy(tradingLimitsObj.maxBuy);
tradingLimits.setReservedSell(tradingLimitsObj.reservedSell);
tradingLimits.setReservedBuy(tradingLimitsObj.reservedBuy);
limitsMap.set(currency, tradingLimits);
});
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.openChannel]]
*/
this.openChannel = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const txId = yield this.service.openChannel(call.request.toObject());
const response = new xudrpc.OpenChannelResponse();
response.setTransactionId(txId);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.connect]]
*/
this.connect = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const { nodeUri } = call.request.toObject();
yield this.service.connect({ nodeUri, retryConnecting: false });
const response = new xudrpc.ConnectResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.walletDeposit]]
*/
this.walletDeposit = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const address = yield this.service.walletDeposit(call.request.toObject());
const response = new xudrpc.DepositResponse();
response.setAddress(address);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.walletWithdraw]]
*/
this.walletWithdraw = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const txId = yield this.service.walletWithdraw(call.request.toObject());
const response = new xudrpc.WithdrawResponse();
response.setTransactionId(txId);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.ban]]
*/
this.ban = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
yield this.service.ban(call.request.toObject());
const response = new xudrpc.BanResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.unban]]
*/
this.unban = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
yield this.service.unban(call.request.toObject());
const response = new xudrpc.UnbanResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.executeSwap]]
*/
this.executeSwap = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const swapSuccess = yield this.service.executeSwap(call.request.toObject());
callback(null, createSwapSuccess(swapSuccess));
}
catch (err) {
if (typeof err === 'number') {
// treat the error as a SwapFailureReason enum
let code;
switch (err) {
case enums_1.SwapFailureReason.DealTimedOut:
case enums_1.SwapFailureReason.SwapTimedOut:
code = grpc_1.status.DEADLINE_EXCEEDED;
break;
case enums_1.SwapFailureReason.InvalidSwapRequest:
case enums_1.SwapFailureReason.PaymentHashReuse:
// these cases suggest something went very wrong with our swap request
code = grpc_1.status.INTERNAL;
break;
case enums_1.SwapFailureReason.InsufficientBalance:
case enums_1.SwapFailureReason.NoRouteFound:
case enums_1.SwapFailureReason.SendPaymentFailure:
case enums_1.SwapFailureReason.SwapClientNotSetup:
case enums_1.SwapFailureReason.OrderOnHold:
code = grpc_1.status.FAILED_PRECONDITION;
break;
case enums_1.SwapFailureReason.UnexpectedClientError:
case enums_1.SwapFailureReason.UnknownError:
default:
code = grpc_1.status.UNKNOWN;
break;
}
const grpcError = {
code,
name: enums_1.SwapFailureReason[err],
message: enums_1.SwapFailureReason[err],
};
callback(grpcError, null);
}
else {
callback(getGrpcError_1.default(err), null);
}
}
});
/**
* See [[Service.getInfo]]
*/
this.getInfo = (_, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const getInfoResponse = yield this.service.getInfo();
const response = new xudrpc.GetInfoResponse();
response.setNodePubKey(getInfoResponse.nodePubKey);
response.setUrisList(getInfoResponse.uris);
response.setNumPairs(getInfoResponse.numPairs);
response.setNumPeers(getInfoResponse.numPeers);
response.setVersion(getInfoResponse.version);
response.setAlias(getInfoResponse.alias);
response.setNetwork(getInfoResponse.network);
const getLndInfo = ((lndInfo) => {
const lnd = new xudrpc.LndInfo();
if (lndInfo.blockheight)
lnd.setBlockheight(lndInfo.blockheight);
if (lndInfo.chains) {
const chains = lndInfo.chains.map((chain) => {
const xudChain = new xudrpc.Chain();
xudChain.setChain(chain.chain);
xudChain.setNetwork(chain.network);
return xudChain;
});
lnd.setChainsList(chains);
}
if (lndInfo.channels) {
const channels = new xudrpc.Channels();
channels.setActive(lndInfo.channels.active);
channels.setPending(lndInfo.channels.pending);
channels.setClosed(lndInfo.channels.closed);
if (lndInfo.channels.inactive)
channels.setInactive(lndInfo.channels.inactive);
lnd.setChannels(channels);
}
lnd.setStatus(lndInfo.status);
if (lndInfo.uris)
lnd.setUrisList(lndInfo.uris);
if (lndInfo.version)
lnd.setVersion(lndInfo.version);
if (lndInfo.alias)
lnd.setAlias(lndInfo.alias);
return lnd;
});
const lndMap = response.getLndMap();
getInfoResponse.lnd.forEach((lndInfo, currency) => {
lndMap.set(currency, getLndInfo(lndInfo));
});
if (getInfoResponse.connext) {
const connext = new xudrpc.ConnextInfo();
connext.setStatus(getInfoResponse.connext.status);
if (getInfoResponse.connext.address)
connext.setAddress(getInfoResponse.connext.address);
if (getInfoResponse.connext.version)
connext.setVersion(getInfoResponse.connext.version);
if (getInfoResponse.connext.chain)
connext.setChain(getInfoResponse.connext.chain);
response.setConnext(connext);
}
const orders = new xudrpc.OrdersCount;
orders.setOwn(getInfoResponse.orders.own);
orders.setPeer(getInfoResponse.orders.peer);
response.setOrders(orders);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.getMnemonic]]
*/
this.getMnemonic = (_, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const mnemonic = yield this.service.getMnemonic();
const response = new xudrpc.GetMnemonicResponse();
response.setSeedMnemonicList(mnemonic);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.getETHMnemonic]]
*/
this.getETHMnemonic = (_, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const mnemonic = yield this.service.getETHMnemonic();
const response = new xudrpc.GetEthMnemonicResponse();
response.setSeedMnemonic(mnemonic);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.getNodeInfo]]
*/
this.getNodeInfo = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const { banned, reputationScore } = yield this.service.getNodeInfo(call.request.toObject());
const response = new xudrpc.GetNodeInfoResponse();
if (banned) {
response.setBanned(banned);
}
response.setReputationscore(reputationScore);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.listOrders]]
*/
this.listOrders = (call, callback) => {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const listOrdersResponse = this.service.listOrders(call.request.toObject());
const response = new xudrpc.ListOrdersResponse();
const listOrdersList = (orders) => {
const ordersList = [];
orders.forEach(order => ordersList.push(createServiceOrder(order)));
return ordersList;
};
const ordersMap = response.getOrdersMap();
listOrdersResponse.forEach((orderArrays, pairId) => {
const orders = new xudrpc.Orders();
orders.setBuyOrdersList(listOrdersList(orderArrays.buyArray));
orders.setSellOrdersList(listOrdersList(orderArrays.sellArray));
ordersMap.set(pairId, orders);
});
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
};
/**
* See [[Service.listCurrencies]]
*/
this.listCurrencies = (_, callback) => {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const currencies = this.service.listCurrencies();
const response = new xudrpc.ListCurrenciesResponse();
currencies.forEach((currency) => {
const resultCurrency = new xudrpc.Currency();
resultCurrency.setDecimalPlaces(currency.decimalPlaces);
resultCurrency.setCurrency(currency.id);
if (currency.tokenAddress) {
resultCurrency.setTokenAddress(currency.tokenAddress);
}
resultCurrency.setSwapClient(currency.swapClient);
response.getCurrenciesList().push(resultCurrency);
});
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
};
/**
* See [[Service.listPairs]]
*/
this.listPairs = (_, callback) => {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const listPairsResponse = this.service.listPairs();
const response = new xudrpc.ListPairsResponse();
response.setPairsList(listPairsResponse);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
};
/**
* See [[Service.tradeHistory]]
*/
this.tradeHistory = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const trades = yield this.service.tradeHistory(call.request.toObject());
const response = new xudrpc.TradeHistoryResponse();
const tradesList = trades.map((trade) => {
const grpcTrade = new xudrpc.Trade();
grpcTrade.setMakerOrder(createServiceOrder(trade.makerOrder));
if (trade.takerOrder) {
grpcTrade.setTakerOrder(createServiceOrder(trade.takerOrder));
}
grpcTrade.setPairId(trade.pairId);
grpcTrade.setQuantity(trade.quantity);
if (trade.rHash) {
grpcTrade.setRHash(trade.rHash);
}
grpcTrade.setPrice(trade.price);
grpcTrade.setSide(trade.side);
grpcTrade.setRole(trade.role);
grpcTrade.setExecutedAt(trade.executedAt);
if (trade.counterparty) {
const counterparty = new xudrpc.NodeIdentifier();
counterparty.setNodePubKey(trade.counterparty.nodePubKey);
if (trade.counterparty.alias) {
counterparty.setAlias(trade.counterparty.alias);
}
grpcTrade.setCounterparty(counterparty);
}
return grpcTrade;
});
response.setTradesList(tradesList);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.listPeers]]
*/
this.listPeers = (_, callback) => {
if (!this.isReady(this.service, callback)) {
return;
}
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.setAlias(peer.alias || '');
if (peer.lndPubKeys) {
const map = grpcPeer.getLndPubKeysMap();
for (const key in peer.lndPubKeys) {
map.set(key, peer.lndPubKeys[key]);
}
}
grpcPeer.setPairsList(peer.pairs || []);
grpcPeer.setSecondsConnected(peer.secondsConnected);
grpcPeer.setXudVersion(peer.xudVersion || '');
peers.push(grpcPeer);
});
response.setPeersList(peers);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
};
/**
* See [[Service.placeOrder]]
*/
this.placeOrder = (call) => __awaiter(this, void 0, void 0, function* () {
if (!this.service) {
call.emit('error', { code: grpc_1.status.UNAVAILABLE, message: 'xud is starting', name: 'NotReadyError' });
return;
}
try {
yield this.service.placeOrder(call.request.toObject(), (result) => {
call.write(createPlaceOrderEvent(result));
});
call.end();
}
catch (err) {
call.emit('error', getGrpcError_1.default(err));
}
});
/**
* See [[Service.placeOrder]]
*/
this.placeOrderSync = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const result = yield this.service.placeOrder(call.request.toObject());
callback(null, createPlaceOrderResponse(result));
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.addCurrency]]
*/
this.removeCurrency = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
yield this.service.removeCurrency(call.request.toObject());
const response = new xudrpc.RemoveCurrencyResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.addPair]]
*/
this.removePair = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
yield this.service.removePair(call.request.toObject());
const response = new xudrpc.RemovePairResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
/**
* See [[Service.discoverNodes]]
*/
this.discoverNodes = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
const numNodes = yield this.service.discoverNodes(call.request.toObject());
const response = new xudrpc.DiscoverNodesResponse();
response.setNumNodes(numNodes);
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
this.setLogLevel = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
yield this.service.setLogLevel(call.request.toObject());
const response = new xudrpc.SetLogLevelResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
this.changePassword = (call, callback) => __awaiter(this, void 0, void 0, function* () {
if (!this.isReady(this.service, callback)) {
return;
}
try {
yield this.service.changePassword(call.request.toObject());
const response = new xudrpc.ChangePasswordResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
});
this.shutdown = (_, callback) => {
if (!this.isReady(this.service, callback)) {
return;
}
try {
this.service.shutdown();
const response = new xudrpc.ShutdownResponse();
callback(null, response);
}
catch (err) {
callback(getGrpcError_1.default(err), null);
}
};
/*
* See [[Service.subscribeOrders]]
*/
this.subscribeOrders = (call) => {
if (!this.isReady(this.service, call)) {
return;
}
const cancelled$ = getCancelled$(call);
this.service.subscribeOrders(call.request.toObject(), (order, orderRemoval) => {
const orderUpdate = new xudrpc.OrderUpdate();
if (order) {
orderUpdate.setOrder(createServiceOrder(order));
}
else if (orderRemoval) {
const grpcOrderRemoval = new xudrpc.OrderRemoval();
grpcOrderRemoval.setPairId(orderRemoval.pairId);
grpcOrderRemoval.setOrderId(orderRemoval.id);
grpcOrderRemoval.setQuantity(orderRemoval.quantity);
grpcOrderRemoval.setLocalId(orderRemoval.localId || '');
grpcOrderRemoval.setIsOwnOrder(orderRemoval.localId !== undefined);
orderUpdate.setOrderRemoval(grpcOrderRemoval);
}
call.write(orderUpdate);
}, cancelled$);
};
/*
* See [[Service.subscribeSwapFailures]]
*/
this.subscribeSwapFailures = (call) => {
if (!this.isReady(this.service, call)) {
return;
}
const cancelled$ = getCancelled$(call);
this.service.subscribeSwapFailures(call.request.toObject(), (result) => {
call.write(createSwapFailure(result));
}, cancelled$);
this.addStream(call);
};
/*
* See [[Service.subscribeSwaps]]
*/
this.subscribeSwaps = (call) => {
if (!this.isReady(this.service, call)) {
return;
}
const cancelled$ = getCancelled$(call);
this.service.subscribeSwaps(call.request.toObject(), (result) => {
call.write(createSwapSuccess(result));
}, cancelled$);
this.addStream(call);
};
/*
* See [[Service.subscribeSwapFailures]]
*/
this.subscribeSwapsAccepted = (call) => {
if (!this.isReady(this.service, call)) {
return;
}
const cancelled$ = getCancelled$(call);
this.service.subscribeSwapsAccepted(call.request.toObject(), (result) => {
call.write(createSwapAccepted(result));
}, cancelled$);
this.addStream(call);
};
}
setService(service) {
this.service = service;
this.locked = false;
}
}
exports.default = GrpcService;
//# sourceMappingURL=GrpcService.js.map