@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/services/EventsService.js

@@ -0,0 +1,234 @@
+"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 ethers_1 = require("ethers");
+const Utility_1 = require("../utils/Utility");
+const AzureEventHubHandler_1 = __importDefault(require("./AzureEventHubHandler"));
+const EventsHandler_1 = __importDefault(require("./EventsHandler"));
+const Wallets_1 = require("../utils/Wallets");
+const event_hubs_1 = require("@azure/event-hubs");
+const Logger_1 = require("../utils/Logger");
+class EventsService {
+    constructor(config) {
+        /**
+     * Sends a single event to the event hub
+     * @param event
+     * @param eventHubNameOverride
+     * @param contractNameOverride
+     * @returns Promise resolving to a `boolean` status
+     */
+        this.serviceSendEventSingle = (event, eventHubNameOverride) => __awaiter(this, void 0, void 0, function* () {
+            let finalEventObject = Object.assign({}, event);
+            try {
+                if (!EventsHandler_1.default.azureHandler) {
+                    this.logger.info(`Azure handler does not exist. Recreating...`);
+                    //Initialize Azure Event Hub handler for producing events to Azure service
+                    EventsHandler_1.default.azureHandler = new AzureEventHubHandler_1.default(this.config);
+                }
+                const isSent = yield EventsHandler_1.default.azureHandler.sendEvent(finalEventObject);
+                if (!isSent) {
+                    this.logger.info(`EventsHandler: Event not produced to Azure hub.`);
+                    return false;
+                }
+                else {
+                    this.logger.info(`Successfully produced event to Azure Hub. ${finalEventObject.txHash ? `${finalEventObject.txHash}` : ""}`);
+                    yield (0, Utility_1.sleep)(100);
+                    return true;
+                }
+            }
+            catch (error) {
+                this.logger.error(`EventsHandler: Error sending event to azure hub for event ${event.eventName} `, { data: { error, event } });
+                return false;
+            }
+        });
+        /**
+         * Sends a batch of events to the event hub sequentially
+         * @param logs
+         * @param eventHubNameOverride
+         * @param contractNameOverride
+         * @returns Promise resolving to a `boolean` status
+         */
+        this.serviceSendAllEventsSequentially = (logs, eventHubNameOverride) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                let failed = [];
+                for (let log of logs) {
+                    let event = Object.assign({ eventName: log.eventName }, log);
+                    yield this.serviceSendEventSingle(event, eventHubNameOverride);
+                    yield new Promise(res => setImmediate(res));
+                    // if (!isSent) failed.push(log);
+                }
+                return failed.length === 0;
+            }
+            catch (error) {
+                this.logger.error(`EventsService: Error sending all events.`, { data: { error, logs } });
+                throw error;
+            }
+        });
+        this.produce_events_pre_transaction = (candidates, status) => __awaiter(this, void 0, void 0, function* () {
+            const events = candidates.map(c => {
+                const amount_decimals = ethers_1.ethers.formatUnits(c.amount, c.decimals);
+                return {
+                    eventName: "Withdrawal",
+                    blockchain: c.blockchain,
+                    chainId: parseInt(c.chain_id),
+                    confirmed: false,
+                    status: status,
+                    requestId: Number(c.request_id),
+                    paymentType: c.payment_type,
+                    caller: c.user_id.toString(),
+                    payer: null,
+                    // userId: c.user_id.toString(),
+                    userId: Number(c.user_id),
+                    receiver: c.receiver,
+                    tokenAddress: (0, Wallets_1.normalizeAddress)(c.token, c.blockchain),
+                    amount: parseFloat(amount_decimals),
+                    txFeeNative: 0, // TODO: add estimate here
+                    txFeeUsd: 0, // TODO: add estimate here
+                    // Additional properties
+                    parentContract: c.token,
+                    batchSize: null,
+                    timestamp: Math.floor(new Date().getTime() / 1000),
+                    blockNumber: 0,
+                    txHash: null,
+                    gasUsed: 0,
+                };
+            });
+            yield this.serviceSendAllEventsSequentially(events);
+        });
+        this.produce_events_post_transaction = (candidates, status, confirmed) => __awaiter(this, void 0, void 0, function* () {
+            const events = candidates.map(c => {
+                const amount_decimals = ethers_1.ethers.formatUnits(c.amount, c.decimals);
+                return {
+                    eventName: "Withdrawal",
+                    blockchain: c.blockchain,
+                    chainId: parseInt(c.chain_id),
+                    // confirmed: c.blockchain === "solana" ? true : false, // Force confirm event for solana since there is no contract producing events yet
+                    confirmed,
+                    status: status,
+                    requestId: Number(c.request_id),
+                    paymentType: c.payment_type,
+                    caller: c.user_id.toString(),
+                    payer: (0, Wallets_1.normalizeAddress)(c.from, c.blockchain),
+                    userId: Number(c.user_id),
+                    receiver: (0, Wallets_1.normalizeAddress)(c.receiver, c.blockchain),
+                    tokenAddress: (0, Wallets_1.normalizeAddress)(c.token, c.blockchain),
+                    amount: parseFloat(amount_decimals),
+                    txFeeNative: c.actual_tx_fee_native_decimals,
+                    txFeeUsd: c.actual_tx_fee_usd_decimals,
+                    // Additional properties
+                    parentContract: c.token,
+                    batchSize: c.batch_size,
+                    timestamp: Math.floor(new Date().getTime() / 1000),
+                    blockNumber: c.block_number,
+                    txHash: c.tx_hash,
+                    gasUsed: c.gas_used,
+                };
+            });
+            // setImmediate(() => serviceSendAllEventsSequentially(events))
+            yield this.serviceSendAllEventsSequentially(events);
+        });
+        //refactored
+        this.serviceHandleIncompleteEvents = (logs) => __awaiter(this, void 0, void 0, function* () {
+            for (let log of logs) {
+                this.logger.info(`EventsService: Cacheing failed event to elastic search...`);
+                let event = Object.assign({ eventName: log.eventName }, log);
+            }
+        });
+        this.consumeEventHub = (eventHubName, chainId, eventName, startDate, endDate) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const connectionString = this.config.config.azureConnectionStringNotifications;
+                const consumerGroup = "$Default";
+                const outputFileName = "eventHubData.json";
+                const consumerClient = new event_hubs_1.EventHubConsumerClient(consumerGroup, connectionString, eventHubName);
+                const allEvents = [];
+                let lastEventTime = Date.now();
+                const noEventTimeout = 5000; // max wait 5 seconds without new events
+                const subscription = consumerClient.subscribe({
+                    processEvents: (events, context) => __awaiter(this, void 0, void 0, function* () {
+                        if (events.length === 0) {
+                            return;
+                        }
+                        lastEventTime = Date.now();
+                        const data = events.map(event => {
+                            return JSON.stringify(event.body);
+                        }).join("\n");
+                        const parsedData = JSON.parse(data);
+                        if (data && parsedData.confirmed && parsedData.chainId === parseInt(chainId) && parsedData.eventName === eventName) {
+                            // Append received events to a file
+                            // await fsPromises.appendFile(outputFileName, data + "\n");
+                            allEvents.push(parsedData);
+                        }
+                        // Update the checkpoint.
+                        yield context.updateCheckpoint(events[events.length - 1]);
+                    }),
+                    processError: (error, context) => __awaiter(this, void 0, void 0, function* () {
+                        this.logger.error(`Error on partition "${context.partitionId}": ${error}`);
+                    })
+                }, {
+                    // Set the startPosition to a past timestamp to read past events
+                    startPosition: {
+                        enqueuedOn: startDate
+                    },
+                });
+                // Keep checking for new events until the timeout is reached
+                while (Date.now() - lastEventTime < noEventTimeout) {
+                    yield new Promise(resolve => setTimeout(resolve, 100));
+                }
+                yield subscription.close();
+                yield consumerClient.close();
+                // Return deduplicated array of event objects
+                return this.filterEventsByUniqueTxHash(allEvents);
+            }
+            catch (error) {
+                this.logger.error(`ConsumeEvents: Error consuming events`, { data: { error, eventHubName, chainId } });
+                throw error;
+            }
+        });
+        this.consumePastEvents = (eventHubName, chainId, eventName, startTimeOffsetInDays, endTimeOffsetInDays) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // const { eventHubName, chainId, eventName, startTimeOffsetInDays, endTimeOffsetInDays } = req.query;
+                if (!eventHubName)
+                    throw new Error("Missing `eventHubName` property.");
+                if (!startTimeOffsetInDays)
+                    throw new Error("Missing `startTimeOffsetInDays` property.");
+                const startTimeDate = (0, Utility_1.convertOffsetInDaysToDate)(parseInt(startTimeOffsetInDays));
+                let endTimeDate;
+                if (endTimeOffsetInDays) {
+                    endTimeDate = (0, Utility_1.convertOffsetInDaysToDate)(parseInt(endTimeOffsetInDays));
+                }
+                const events = yield this.consumeEventHub(eventHubName, chainId, eventName, startTimeDate, endTimeDate ? endTimeDate : undefined);
+                return { status: true, message: "Consumed events.", events };
+            }
+            catch (error) {
+                this.logger.error(`EventhubController: Error consuming events.`, { data: { error, eventHubName, chainId, eventName } });
+                return { status: false, message: "Error consuming events.", error: error.message };
+            }
+        });
+        this.config = config;
+        this.logger = (0, Logger_1.createLogger)(`EventsService`, this.config.pipelineConfig.azureAppName);
+    }
+    filterEventsByUniqueTxHash(events) {
+        const set = new Set();
+        let uniqueHashes = [];
+        for (const event of events) {
+            if (set.has(event.txHash)) {
+                continue;
+            }
+            set.add(event.txHash);
+            uniqueHashes.push(event);
+        }
+        return uniqueHashes;
+    }
+}
+exports.default = EventsService;

package/build/services/InvoiceQueue.d.ts

@@ -0,0 +1,56 @@
+import { IConfig } from "../interfaces/config";
+import RedisQueue from "./RedisQueue";
+import { PaymentIdRequest, PaymentRequest, UserId } from "./types/lightning";
+declare class InvoiceQueue {
+    static instance: InvoiceQueue;
+    queue: RedisQueue;
+    pendingQueue: RedisQueue;
+    staleQueue: RedisQueue;
+    readonly PAYMENT_ID_TTL_S: number;
+    readonly PAYMENT_ID_REFRESH_MIN_TTL_S: number;
+    readonly PAYMENT_ID_TO_USER_KEY = "paymentIdToUser";
+    readonly USER_TO_PAYMENT_ID_KEY = "userToPaymentId";
+    readonly USER_TO_PAYMENT_REQUEST_KEY = "userToPaymentRequest";
+    readonly USER_TO_HASH_KEY = "userToHash";
+    readonly HASH_TO_USER_KEY = "hashToUser";
+    readonly USER_TO_INITIAL_INVOICE = "userToInvoice";
+    private readonly MAX_QUEUE_SIZE;
+    private redis;
+    default_invoice_expiry: number;
+    private errors;
+    private logger;
+    constructor(config: IConfig, MAX_QUEUE_SIZE?: number, TICK_INTERVAL_MS?: number, STALE_INVOICE_TIME_S?: number, PAYMENT_ID_TTL_S?: number, PAYMENT_ID_REFRESH_MIN_TTL_S?: number);
+    static getInstance(config: IConfig, MAX_QUEUE_SIZE?: number, TICK_INTERVAL?: number, STALE_INVOICE_TIME?: number): InvoiceQueue;
+    shutdownGracefully: () => Promise<void>;
+    getInitialInvoice: (userId: UserId) => Promise<string | null>;
+    setInitialInvoice: (userId: UserId, invoice: string, expires_at_timestamp: number) => Promise<unknown>;
+    private _removeInitialInvoice;
+    getPaymentRequest: (userId: UserId) => Promise<PaymentRequest>;
+    clearInvoiceRecords: (userId: UserId) => Promise<void>;
+    addPaymentIdToMap: (paymentId: string, userId: number, amount_in_btc_decimal: number) => Promise<PaymentIdRequest>;
+    addPaymentRequest: (userId: UserId, paymentRequest: PaymentRequest) => Promise<void>;
+    addHashToMap: (r_hash: string, userId: number) => Promise<void>;
+    _removePaymentRequest: (userId: UserId) => Promise<void>;
+    _removeHash: (userId: number) => Promise<void>;
+    private _removeHashFromMap;
+    private _removePaymentIdFromMap;
+    findUserByPaymentHash: (r_hash: string) => Promise<number | null>;
+    findUserByPaymentId: (payment_id: string) => Promise<number | null>;
+    findPaymentIdByUser: (userId: number) => Promise<PaymentIdRequest | null>;
+    getAllPaymentIdsByPrefix(prefix: string): Promise<{
+        key: string;
+        value: any;
+    }[]>;
+    getInvoicesInMap: () => Promise<{
+        key: string;
+        value: any;
+    }[]>;
+    createPaymentIdRequest: (userId: number, amount_in_btc_decimal: number) => Promise<PaymentIdRequest>;
+    pushInvoiceToQueue: (r_hash: string, payment_id: string) => Promise<boolean>;
+    private addInvoiceToQueue;
+    removeInvoiceFromQueue: (r_hash: string) => Promise<boolean>;
+    removeInvoiceFromPendingQueue: (r_hash: string) => Promise<boolean>;
+    private tickPendingQueue;
+}
+export default InvoiceQueue;
+//# sourceMappingURL=InvoiceQueue.d.ts.map

package/build/services/InvoiceQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InvoiceQueue.d.ts","sourceRoot":"","sources":["../../src/services/InvoiceQueue.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAI/C,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG7E,cAAM,YAAY;IACd,MAAM,CAAC,QAAQ,EAAE,YAAY,CAAC;IACvB,KAAK,EAAE,UAAU,CAAC;IAClB,YAAY,EAAE,UAAU,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IAC9B,SAAgB,gBAAgB,EAAE,MAAM,CAAC;IACzC,SAAgB,4BAA4B,EAAE,MAAM,CAAC;IACrD,SAAgB,sBAAsB,qBAAqB;IAC3D,SAAgB,sBAAsB,qBAAqB;IAC3D,SAAgB,2BAA2B,0BAA0B;IACrE,SAAgB,gBAAgB,gBAAgB;IAChD,SAAgB,gBAAgB,gBAAgB;IAChD,SAAgB,uBAAuB,mBAAmB;IAE1D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,KAAK,CAAQ;IACd,sBAAsB,EAAE,MAAM,CAAC;IAEtC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,OAAO,EAAE,cAAc,SAAK,EAAE,gBAAgB,SAAO,EAAE,oBAAoB,SAAU,EAAE,gBAAgB,SAAU,EAAE,4BAA4B,SAAS;IAc5K,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,cAAc,SAAK,EAAE,aAAa,SAAO,EAAE,kBAAkB,SAAU;IAUpG,kBAAkB,sBAQxB;IAGM,iBAAiB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAGxE;IAEM,iBAAiB,GAAU,QAAQ,MAAM,EAAE,SAAS,MAAM,EAAE,sBAAsB,MAAM,sBAG9F;IAED,OAAO,CAAC,qBAAqB,CAG5B;IAGM,iBAAiB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,cAAc,CAAC,CAGzE;IAGM,mBAAmB,GAAU,QAAQ,MAAM,mBAKjD;IAGM,iBAAiB,GAAU,WAAW,MAAM,EAAE,QAAQ,MAAM,EAAE,uBAAuB,MAAM,+BAejG;IAIM,iBAAiB,GAAU,QAAQ,MAAM,EAAE,gBAAgB,cAAc,mBAU/E;IAGM,YAAY,GAAU,QAAQ,MAAM,EAAE,QAAQ,MAAM,mBAY1D;IAEM,qBAAqB,GAAU,QAAQ,MAAM,mBAGnD;IAGM,WAAW,GAAU,QAAQ,MAAM,mBAEzC;IAGD,OAAO,CAAC,kBAAkB,CAazB;IAGD,OAAO,CAAC,uBAAuB,CAc9B;IACM,qBAAqB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAM5E;IAEM,mBAAmB,GAAU,YAAY,MAAM,4BAWrD;IAEM,mBAAmB,GAAU,QAAQ,MAAM,sCAGjD;IAEY,wBAAwB,CAAC,MAAM,EAAE,MAAM;aAEpB,MAAM;eAAS,GAAG;;IAuB3C,gBAAgB;aAvBS,MAAM;eAAS,GAAG;SA0BjD;IAEM,sBAAsB,GAAU,QAAQ,MAAM,EAAE,uBAAuB,MAAM,+BAOnF;IAIM,kBAAkB,GAAU,QAAQ,MAAM,EAAE,YAAY,MAAM,sBA6BpE;IAKD,OAAO,CAAC,iBAAiB,CA8BxB;IAGM,sBAAsB,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,CAKvE;IAGM,6BAA6B,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,CAgB9E;IAID,OAAO,CAAC,gBAAgB,CAqBvB;CAEJ;AAED,eAAe,YAAY,CAAC"}

package/build/services/InvoiceQueue.js

@@ -0,0 +1,297 @@
+"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 VoltageErrors_1 = __importDefault(require("../errors/VoltageErrors"));
+const Logger_1 = require("../utils/Logger");
+const Utility_1 = require("../utils/Utility");
+const Redis_1 = __importDefault(require("./Redis"));
+const RedisQueue_1 = __importDefault(require("./RedisQueue"));
+class InvoiceQueue {
+    constructor(config, MAX_QUEUE_SIZE = 10, TICK_INTERVAL_MS = 1000, STALE_INVOICE_TIME_S = 16 * 60, PAYMENT_ID_TTL_S = 15 * 60, PAYMENT_ID_REFRESH_MIN_TTL_S = 3 * 60) {
+        this.PAYMENT_ID_TO_USER_KEY = "paymentIdToUser";
+        this.USER_TO_PAYMENT_ID_KEY = "userToPaymentId";
+        this.USER_TO_PAYMENT_REQUEST_KEY = "userToPaymentRequest";
+        this.USER_TO_HASH_KEY = "userToHash";
+        this.HASH_TO_USER_KEY = "hashToUser";
+        this.USER_TO_INITIAL_INVOICE = "userToInvoice";
+        // Called in case of SIGTERM or SIGINT
+        // Backs up the invoices in the queue to db
+        this.shutdownGracefully = () => __awaiter(this, void 0, void 0, function* () {
+            this.logger.warn(`App shutting down gracefully. ${yield this.queue.length()} items in queue`);
+            // TODO: Backup queue to db
+            // Potentially back up the response form the websocket
+            // Stop listener
+            // await this.invoiceStream.stop_listener();
+        });
+        this.getInitialInvoice = (userId) => __awaiter(this, void 0, void 0, function* () {
+            const userToInitialInvoice = `${this.USER_TO_INITIAL_INVOICE}-${userId.toString()}`;
+            return this.redis.get(userToInitialInvoice);
+        });
+        this.setInitialInvoice = (userId, invoice, expires_at_timestamp) => __awaiter(this, void 0, void 0, function* () {
+            const userToInitialInvoice = `${this.USER_TO_INITIAL_INVOICE}-${userId.toString()}`;
+            return this.redis.set(userToInitialInvoice, invoice, { expires_at: expires_at_timestamp, ttl: this.PAYMENT_ID_TTL_S });
+        });
+        this._removeInitialInvoice = (userId) => __awaiter(this, void 0, void 0, function* () {
+            const userToInitialInvoice = `${this.USER_TO_INITIAL_INVOICE}-${userId.toString()}`;
+            return this.redis.delete(userToInitialInvoice);
+        });
+        this.getPaymentRequest = (userId) => __awaiter(this, void 0, void 0, function* () {
+            const userToPaymentKey = `${this.USER_TO_PAYMENT_REQUEST_KEY}-${userId.toString()}`;
+            return yield this.redis.get_object(userToPaymentKey);
+        });
+        // Clear all records related to a user's lnurl request (payment id, payment request, timers..)
+        this.clearInvoiceRecords = (userId) => __awaiter(this, void 0, void 0, function* () {
+            yield this._removePaymentIdFromMap(userId);
+            yield this._removeHashFromMap(userId);
+            yield this._removePaymentRequest(userId);
+            yield this._removeInitialInvoice(userId);
+        });
+        // Add association for payment id <=> user id
+        this.addPaymentIdToMap = (paymentId, userId, amount_in_btc_decimal) => __awaiter(this, void 0, void 0, function* () {
+            // Calculate expiry time
+            const { created_at, expires_at, expires_at_timestamp_s: expires_at_s, duration_s: duration } = (0, Utility_1.get_expiry_time)(this.PAYMENT_ID_TTL_S);
+            const newEntry = { paymentId, amount_in_btc_decimal, createdAt: created_at, expiresAt: expires_at, duration_s: duration };
+            yield this.redis.set(`${this.PAYMENT_ID_TO_USER_KEY}-${paymentId}`, userId.toString(), { expires_at: expires_at_s, ttl: duration });
+            yield this.redis.set_object(`${this.USER_TO_PAYMENT_ID_KEY}-${userId.toString()}`, newEntry, { expires_at: expires_at_s, ttl: duration });
+            return newEntry;
+        });
+        // maps payment request to a user id
+        // Deletes mapping of payment id and payment request after expiry
+        this.addPaymentRequest = (userId, paymentRequest) => __awaiter(this, void 0, void 0, function* () {
+            const userToPaymentRequestKey = `${this.USER_TO_PAYMENT_REQUEST_KEY}-${userId.toString()}`;
+            // Calculate expiry time
+            const { expires_at_timestamp_s: expires_at_s, duration_s: duration } = (0, Utility_1.get_expiry_time)(this.PAYMENT_ID_TTL_S);
+            yield this.redis.set_object(userToPaymentRequestKey, paymentRequest, { expires_at: expires_at_s, ttl: duration });
+        });
+        // Associate invoice hash to user id
+        this.addHashToMap = (r_hash, userId) => __awaiter(this, void 0, void 0, function* () {
+            const hashToUserKey = `${this.HASH_TO_USER_KEY}-${r_hash}`;
+            const userToHashKey = `${this.USER_TO_HASH_KEY}-${userId.toString()}`;
+            const { expires_at_timestamp_s: expires_at_s, duration_s: duration } = (0, Utility_1.get_expiry_time)(this.default_invoice_expiry);
+            yield this.redis.set(hashToUserKey, userId.toString(), { expires_at: expires_at_s, ttl: duration });
+            yield this.redis.set(userToHashKey, r_hash, { expires_at: expires_at_s, ttl: duration });
+            this.logger.info(`Scheduling timer. Clear user ${userId} payment id in ${this.default_invoice_expiry * 1000}s`);
+        });
+        this._removePaymentRequest = (userId) => __awaiter(this, void 0, void 0, function* () {
+            const userToPaymentKey = `${this.USER_TO_PAYMENT_REQUEST_KEY}-${userId.toString()}`;
+            yield this.redis.delete(userToPaymentKey);
+        });
+        // Remove all associations for a user
+        this._removeHash = (userId) => __awaiter(this, void 0, void 0, function* () {
+            yield this._removeHashFromMap(userId);
+        });
+        // Removes associations for invoice hash <=> user id
+        this._removeHashFromMap = (userId) => __awaiter(this, void 0, void 0, function* () {
+            const key = `${this.USER_TO_HASH_KEY}-${userId.toString()}`;
+            const r_hash = yield this.redis.get(key);
+            if (r_hash) {
+                const userKey = `${this.USER_TO_HASH_KEY}-${userId.toString()}`;
+                const hashKey = `${this.HASH_TO_USER_KEY}-${r_hash}`;
+                const user = yield this.redis.get(userKey);
+                yield this.redis.delete(userKey);
+                yield this.redis.delete(hashKey);
+                this.logger.info(`Invoice ${r_hash} is settled for user id ${userId} `);
+                return true;
+            }
+            return false;
+        });
+        // Delete associations for payment id <=> user id
+        this._removePaymentIdFromMap = (userId) => __awaiter(this, void 0, void 0, function* () {
+            const payment = yield this.findPaymentIdByUser(userId);
+            if (payment) {
+                const user_id = yield this.findUserByPaymentId(payment === null || payment === void 0 ? void 0 : payment.paymentId);
+                if (user_id !== null) {
+                    const paymentIdKey = `${this.PAYMENT_ID_TO_USER_KEY}-${payment.paymentId}`;
+                    const userIdKey = `${this.USER_TO_PAYMENT_ID_KEY}-${user_id.toString()}`;
+                    yield this.redis.delete(paymentIdKey);
+                    yield this.redis.delete_object(userIdKey);
+                    return true;
+                }
+            }
+            return false;
+        });
+        this.findUserByPaymentHash = (r_hash) => __awaiter(this, void 0, void 0, function* () {
+            const key = `${this.HASH_TO_USER_KEY}-${r_hash}`;
+            const userId = yield this.redis.get(key);
+            if (!userId)
+                return null;
+            return parseInt(userId);
+        });
+        // Get user id for a given payment Id
+        this.findUserByPaymentId = (payment_id) => __awaiter(this, void 0, void 0, function* () {
+            const key = `${this.PAYMENT_ID_TO_USER_KEY}-${payment_id}`;
+            this.logger.info(`getting paymnet id for user. with key ${key} payment id: ${payment_id} `);
+            const user_id = yield this.redis.get(key);
+            if (!user_id) {
+                this.logger.info(`User id not found for payment id ${payment_id}`);
+                return null;
+            }
+            this.logger.info(`Found user id ${user_id} associated with payment id ${payment_id}`);
+            return parseInt(user_id);
+        });
+        this.findPaymentIdByUser = (userId) => __awaiter(this, void 0, void 0, function* () {
+            const key = `${this.USER_TO_PAYMENT_ID_KEY}-${userId.toString()}`;
+            return yield this.redis.get_object(key);
+        });
+        // Get all invoices - admin
+        this.getInvoicesInMap = () => __awaiter(this, void 0, void 0, function* () {
+            return yield this.getAllPaymentIdsByPrefix(this.USER_TO_HASH_KEY);
+        });
+        this.createPaymentIdRequest = (userId, amount_in_btc_decimal) => __awaiter(this, void 0, void 0, function* () {
+            // Generate a unique payment ID
+            const _paymentId = crypto.randomUUID();
+            // Bidirectional map for payment id to user id relationship
+            let new_payment = yield this.addPaymentIdToMap(_paymentId, userId, amount_in_btc_decimal);
+            return new_payment;
+        });
+        // Entrypoint for subscribing to invoices
+        this.pushInvoiceToQueue = (r_hash, payment_id) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!r_hash) {
+                    throw new Error(this.errors.RequireParameter("r_hash"));
+                }
+                const userId = yield this.findUserByPaymentId(payment_id);
+                if (userId === undefined || userId === null) {
+                    throw new Error(this.errors.PaymentIdNotFound(payment_id));
+                }
+                this.logger.info(`InvoiceQueue: Subscribing to invoice ${r_hash}`);
+                // Add invoice to queue
+                // TODO: Remove this because its not needed
+                const isAdded = yield this.addInvoiceToQueue(r_hash, userId);
+                this.logger.info(`InvoiceQueue: isAdded: ${isAdded}`);
+                if (!isAdded) {
+                    this.logger.info(`invoice not added to queue`);
+                }
+                // Bidirectional map for r_hash to user id relationship
+                yield this.addHashToMap(r_hash, userId);
+                // Ensure the stream is open
+                // this.initialize_stream();
+                return isAdded;
+            }
+            catch (error) {
+                this.logger.error(`InvoiceQueue: Error listening for invoice ${r_hash}`, { data: { error, r_hash, payment_id } });
+                // TODO handle invoice error, reject payment request
+                throw error;
+            }
+        });
+        // Add invoice to main queue or pending queue
+        // TODO: Add mapping or set to enhance search performance
+        this.addInvoiceToQueue = (r_hash, userId) => __awaiter(this, void 0, void 0, function* () {
+            this.logger.info(`Adding invoice to queue. r_hash ${r_hash}`);
+            // Check if invoice is already in main queue
+            const existingInvoice = yield this.queue.find((invoice) => invoice.r_hash === r_hash);
+            if (existingInvoice) {
+                return true;
+            }
+            // Check if invoice is already in pending queue
+            const existingPendingInvoice = yield this.pendingQueue.find((invoice) => invoice.r_hash === r_hash);
+            if (existingPendingInvoice) {
+                return true;
+            }
+            // this.invoices.set(userId, r_hash);
+            // Queue is full, add to pending queue
+            if ((yield this.queue.length()) >= this.MAX_QUEUE_SIZE) {
+                yield this.pendingQueue.push({ userId, r_hash, isFulfilled: false, timestamp: Math.floor(Date.now() / 1000) });
+                this.logger.info(`InvoiceQueue: Queue is full, adding invoice ${r_hash} to pending queue.  Queue size: ${yield this.queue.length()} : Pending queue: ${yield this.pendingQueue.length()}`);
+                // TODO: We can track the index in a map
+                return true;
+            }
+            // Add invoice to main queue for immediate processing
+            yield this.queue.push({ userId, r_hash, isFulfilled: false, timestamp: Math.floor(Date.now() / 1000) });
+            this.logger.info(`InvoiceQueue: Added invoice ${r_hash} to main queue. Queue size: ${yield this.queue.length()} : Pending queue: ${yield this.pendingQueue.length()}`);
+            return true;
+        });
+        // Remove invoice from main queue
+        this.removeInvoiceFromQueue = (r_hash) => __awaiter(this, void 0, void 0, function* () {
+            let new_queue = yield this.queue.filter((invoice) => invoice.r_hash !== r_hash);
+            yield this.queue.set(new_queue);
+            this.logger.info(`InvoiceQueue: Removed invoice ${r_hash} from main queue. Queue size: ${yield this.queue.length()} : Pending queue: ${yield this.pendingQueue.length()}`);
+            return true;
+        });
+        // Remove invoice from pending queue
+        this.removeInvoiceFromPendingQueue = (r_hash) => __awaiter(this, void 0, void 0, function* () {
+            // No pending invoices
+            if ((yield this.pendingQueue.length()) === 0) {
+                return false;
+            }
+            // Doesnt exist in pending queue
+            if ((yield this.pendingQueue.filter((invoice) => invoice.r_hash === r_hash)).length === 0) {
+                return false;
+            }
+            // Remove invoice from pending queue
+            const new_queue = yield this.pendingQueue.filter((invoice) => invoice.r_hash !== r_hash);
+            yield this.pendingQueue.set(new_queue);
+            this.logger.info(`InvoiceQueue: Removed invoice ${r_hash} from pending queue. Queue size: ${yield this.pendingQueue.length()}`);
+            return true;
+        });
+        // Moves invoice from pending queue to main queue if there is space
+        this.tickPendingQueue = () => __awaiter(this, void 0, void 0, function* () {
+            const main_queue_length = yield this.queue.length();
+            // No pending invoices
+            if ((yield this.pendingQueue.length()) === 0 && main_queue_length == 0) {
+                return;
+            }
+            // If main queue has space, move invoice from pending queue to main queue
+            if (main_queue_length < this.MAX_QUEUE_SIZE) {
+                // Get first invoice in pending queue
+                const invoice = yield this.pendingQueue.shift();
+                if (!invoice) {
+                    return;
+                }
+                // Move invoice to main queue
+                this.addInvoiceToQueue(invoice.r_hash, invoice.userId);
+                return;
+            }
+        });
+        this.queue = new RedisQueue_1.default(config, "invoice-main-queue");
+        this.pendingQueue = new RedisQueue_1.default(config, "invoice-pending-queue");
+        this.staleQueue = new RedisQueue_1.default(config, "invoice-stale-queue");
+        // this.voltage = Voltage.getInstance();
+        this.MAX_QUEUE_SIZE = MAX_QUEUE_SIZE;
+        this.PAYMENT_ID_TTL_S = config.serverConfig.lnUrlDefaultExpiryInSeconds;
+        this.PAYMENT_ID_REFRESH_MIN_TTL_S = config.serverConfig.lnUrlDefaultMinDurationRefreshInSeconds;
+        this.errors = new VoltageErrors_1.default();
+        this.redis = Redis_1.default.getInstance(config);
+        this.default_invoice_expiry = config.serverConfig.lnUrlDefaultExpiryInSeconds;
+        this.logger = (0, Logger_1.createLogger)(`InvoiceQueue`, config.pipelineConfig.azureAppName);
+    }
+    static getInstance(config, MAX_QUEUE_SIZE = 10, TICK_INTERVAL = 3000, STALE_INVOICE_TIME = 16 * 60) {
+        if (!InvoiceQueue.instance) {
+            InvoiceQueue.instance = new InvoiceQueue(config, MAX_QUEUE_SIZE, TICK_INTERVAL, STALE_INVOICE_TIME);
+        }
+        return InvoiceQueue.instance;
+    }
+    getAllPaymentIdsByPrefix(prefix) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pattern = `${prefix}-*`;
+            const results = [];
+            let cursor = "";
+            do {
+                // Scan for keys matching pattern
+                const scanResult = yield this.redis.client.scan(cursor, {
+                    MATCH: pattern,
+                    COUNT: 100
+                });
+                cursor = scanResult.cursor;
+                // Get values for found keys
+                for (const key of scanResult.keys) {
+                    const value = yield this.redis.get_object(key);
+                    results.push({ key, value });
+                }
+            } while (cursor !== "");
+            return results;
+        });
+    }
+}
+exports.default = InvoiceQueue;

package/build/services/KeyVaultService.d.ts

@@ -0,0 +1,14 @@
+import { SecretClient } from '@azure/keyvault-secrets';
+declare class KeyVaultHandler {
+    vaultName: string;
+    url: string;
+    client: SecretClient | null;
+    defaultVaultName: string;
+    constructor(keyVaultName: string);
+    initializeKeyVaultService: () => SecretClient;
+    store: (keyName: string, pkey: string) => Promise<boolean>;
+    delete: (keyName: string) => Promise<boolean>;
+    getSecretValue(secretName: string): Promise<string | null>;
+}
+export default KeyVaultHandler;
+//# sourceMappingURL=KeyVaultService.d.ts.map

package/build/services/KeyVaultService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KeyVaultService.d.ts","sourceRoot":"","sources":["../../src/services/KeyVaultService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAGvD,cAAM,eAAe;IACV,SAAS,EAAE,MAAM,CAAM;IACvB,GAAG,EAAE,MAAM,CAAM;IACjB,MAAM,EAAE,YAAY,GAAG,IAAI,CAAQ;IACnC,gBAAgB,EAAE,MAAM,CAAC;gBAIpB,YAAY,EAAE,MAAM;IAMhC,yBAAyB,qBAWxB;IAED,KAAK,GAAU,SAAS,MAAM,EAAE,MAAM,MAAM,sBAO3C;IAED,MAAM,GAAU,SAAS,MAAM,sBAI9B;IAEK,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;CAkBnE;AAED,eAAe,eAAe,CAAC"}