xud
Version:
Exchange Union Daemon
116 lines • 5.71 kB
JavaScript
;
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());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.handler = exports.builder = exports.describe = exports.command = void 0;
const grpc_1 = require("grpc");
const xudrpc = __importStar(require("../../proto/xudrpc_pb"));
const utils_1 = require("../../utils/utils");
const command_1 = require("../command");
exports.command = 'streamorders [existing]';
exports.describe = 'stream order added, removed, and swapped events (DEMO)';
exports.builder = (argv) => argv
.option('existing', {
description: 'whether to return existing orders',
type: 'boolean',
default: true,
});
exports.handler = (argv) => __awaiter(void 0, void 0, void 0, function* () {
yield ensureConnection(argv, true);
});
let client;
const ensureConnection = (argv, printError) => __awaiter(void 0, void 0, void 0, function* () {
if (!client) {
client = yield command_1.loadXudClient(argv);
}
client.waitForReady(Date.now() + 3000, (error) => {
if (error) {
if (error.message === 'Failed to connect before the deadline') {
console.error(`could not connect to xud at ${argv.rpchost}:${argv.rpcport}, is xud running?`);
process.exit(1);
}
if (printError)
console.error(`${error.name}: ${error.message}`);
setTimeout(ensureConnection.bind(undefined, argv, printError), 3000);
}
else {
console.log('Successfully connected, subscribing for orders');
streamOrders(argv);
}
});
});
const streamOrders = (argv) => {
const ordersReqeust = new xudrpc.SubscribeOrdersRequest();
ordersReqeust.setExisting(argv.existing);
const ordersSubscription = client.subscribeOrders(ordersReqeust);
ordersSubscription.on('data', (orderUpdate) => {
if (orderUpdate.getOrder() !== undefined) {
console.log(`Order added: ${JSON.stringify(orderUpdate.getOrder().toObject())}`);
}
else if (orderUpdate.getOrderRemoval() !== undefined) {
console.log(`Order removed: ${JSON.stringify(orderUpdate.getOrderRemoval().toObject())}`);
}
});
// adding end, close, error events only once,
// since they'll be thrown for three of subscriptions in the corresponding cases, catching once is enough.
ordersSubscription.on('end', reconnect.bind(undefined, argv));
ordersSubscription.on('error', (err) => __awaiter(void 0, void 0, void 0, function* () {
if (err.code === grpc_1.status.UNIMPLEMENTED) {
console.error("xud is locked, run 'xucli unlock', 'xucli create', or 'xucli restore' then try again");
process.exit(1);
}
console.warn(`Unexpected error occured: ${err.message}, reconnecting in 1 second`);
yield utils_1.setTimeoutPromise(1000);
yield ensureConnection(argv);
}));
const swapsRequest = new xudrpc.SubscribeSwapsRequest();
swapsRequest.setIncludeTaker(true);
const swapsSubscription = client.subscribeSwaps(swapsRequest);
swapsSubscription.on('data', (swapSuccess) => {
console.log(`Order swapped: ${JSON.stringify(swapSuccess.toObject())}`);
});
const swapsAcceptedRequest = new xudrpc.SubscribeSwapsAcceptedRequest();
const swapsAcceptedSubscription = client.subscribeSwapsAccepted(swapsAcceptedRequest);
swapsAcceptedSubscription.on('data', (swapAccepted) => {
console.log(`Swap deal accepted: ${JSON.stringify(swapAccepted.toObject())}`);
});
const swapFailuresSubscription = client.subscribeSwapFailures(swapsRequest);
swapFailuresSubscription.on('data', (swapFailure) => {
console.log(`Swap failed: ${JSON.stringify(swapFailure.toObject())}`);
});
// prevent exiting and do nothing, it's already caught above.
swapsSubscription.on('error', () => { });
swapsAcceptedSubscription.on('error', () => { });
swapFailuresSubscription.on('error', () => { });
};
const reconnect = (argv) => __awaiter(void 0, void 0, void 0, function* () {
console.log('Stream has closed, trying to reconnect');
yield ensureConnection(argv, false);
});
//# sourceMappingURL=streamorders.js.map