xud/dist/http/HttpService.js

Exchange Union Daemon

"use strict";
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 });
const errors_1 = __importDefault(require("../service/errors"));
const crypto_1 = require("crypto");
class HttpService {
    constructor(service) {
        this.service = service;
        this.providePreimage = (preimageRequest) => __awaiter(this, void 0, void 0, function* () {
            if (preimageRequest.data && preimageRequest.data.transferMeta) {
                const { preImage: preimage } = preimageRequest.data.transferMeta;
                if (!preimage) {
                    throw errors_1.default.INVALID_ARGUMENT('preImage is missing');
                }
                const slicedPreimage = preimage.slice(2);
                const rHash = crypto_1.createHash('sha256').update(Buffer.from(slicedPreimage, 'hex')).digest('hex');
                yield this.service.providePreimage({
                    rHash,
                    preimage: slicedPreimage,
                });
                return {};
            }
            else {
                throw errors_1.default.INVALID_REQUEST;
            }
        });
        this.incomingTransfer = (incomingTransferRequest) => __awaiter(this, void 0, void 0, function* () {
            if (incomingTransferRequest.data) {
                const { amount: amountHex, assetId, paymentId, } = incomingTransferRequest.data;
                const { lockHash, timelock: timelockString, } = incomingTransferRequest.data.transferMeta;
                const rHash = lockHash.slice(2);
                const timelock = parseInt(timelockString, 10);
                const units = parseInt(amountHex._hex, 16);
                yield this.service.transferReceived({
                    rHash,
                    timelock,
                    units,
                    paymentId,
                    tokenAddress: assetId,
                });
                return {};
            }
            else {
                throw errors_1.default.INVALID_REQUEST;
            }
        });
        this.depositConfirmed = (depositConfirmedRequest) => {
            if (depositConfirmedRequest.data && depositConfirmedRequest.data.hash) {
                this.service.depositConfirmed(depositConfirmedRequest.data.hash);
                return {};
            }
            else {
                throw errors_1.default.INVALID_REQUEST;
            }
        };
    }
}
exports.default = HttpService;
//# sourceMappingURL=HttpService.js.map