@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/services/RedisPubSub.js

@@ -0,0 +1,254 @@
+"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 redis_1 = require("redis");
+const Parsing_1 = require("../utils/Parsing");
+const ElasticSearch_1 = __importDefault(require("./ElasticSearch"));
+const Logger_1 = require("../utils/Logger");
+class RedisPubSub {
+    constructor(config, prefix) {
+        this.create_redis_client = () => {
+            if (this.config.serverConfig.environment === 'local') {
+                this.client = (0, redis_1.createClient)();
+            }
+            else {
+                const parsed_string = (0, Parsing_1.parseRedisUrl)(this.config.config.redisConnectionstring);
+                let url = `rediss://${parsed_string.host}:${parsed_string.port}`;
+                this.client = (0, redis_1.createClient)({
+                    pingInterval: 10000,
+                    url,
+                    password: parsed_string.password,
+                    socket: {
+                        host: parsed_string.host,
+                        port: parsed_string.port,
+                        tls: true,
+                        reconnectStrategy: (retries) => {
+                            if (retries < 10) {
+                                return 200;
+                            }
+                            return false;
+                        }
+                    }
+                });
+            }
+            return this.client;
+        };
+        this.config = config;
+        this.initialized = false;
+        // this.prefix = `${config.serverConfig.projectName}-${config.serverConfig.environment}`; // Same prefix as TimerManager for custodial wallets
+        this.prefix = prefix;
+        this.client = this.create_redis_client();
+        this.logger = (0, Logger_1.createLogger)(`RedisPubSub`, this.config.pipelineConfig.azureAppName);
+    }
+    reinitialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logger.info("RedisPubSub: Reinitializing Redis...");
+                this.client = this.create_redis_client();
+                this.initialized = false;
+                yield this.initialize();
+            }
+            catch (err) {
+                this.logger.error("RedisPubSub: Reinit failed:", { data: { error: err } });
+            }
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.client.isOpen)
+                return;
+            this.logger.info(`RedisPubSub: Initializing redis....`);
+            try {
+                this.client.on('error', (err) => __awaiter(this, void 0, void 0, function* () { return yield this.handle_redis_error(err); }));
+                this.client.on('reconnecting', () => this.handle_redis_action("reconnecting"));
+                this.client.on('connect', () => this.handle_redis_action("connect"));
+                this.client.on('end', () => __awaiter(this, void 0, void 0, function* () { return yield this.handle_redis_action("end"); }));
+                // Enable keyspace notifications for expired events
+                try {
+                    yield this.client.connect();
+                    // Subscribe to events on local redis
+                    if (this.config.serverConfig.environment === "local") {
+                        yield this.client.configSet('notify-keyspace-events', 'Exg');
+                    }
+                    this.initialized = true;
+                    // // Create a dedicated subscriber connection for notifications
+                    this.subscriber = this.client.duplicate();
+                    // this.subscriber.on('error', async (err) => await this.handle_redis_error(err));
+                    yield this.subscriber.connect();
+                    this.initialized = true;
+                }
+                catch (e) {
+                    this.logger.warn('RedisPubSub: Redis init Error:', { data: { error: e } });
+                }
+                this.logger.info(`RedisPubSub: Initialized redis`);
+            }
+            catch (error) {
+                this.logger.error(`RedisPubSub: Error initializoing redis client`, { data: { error } });
+            }
+        });
+    }
+    // Subscribe to key expiry notifications
+    psubscribe(events) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!this.subscriber)
+                throw new Error('RedisPubSub:Redis subscriber not initialized');
+            const db = (_b = (_a = this.client.options) === null || _a === void 0 ? void 0 : _a.database) !== null && _b !== void 0 ? _b : 0;
+            for (let event of events) {
+                const pattern = `__keyevent@${db}__:${event.eventName}`;
+                this.logger.info(`RedisPubSub: pSubscribe: Subscribed to pattern: ${pattern}`);
+                yield this.subscriber.pSubscribe(pattern, (eventKey) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        this.logger.info(`RedisPubSub: pSubscribe: Received subscriber event: ${event.eventName}. eventkey: ${eventKey}`);
+                        // Get the value before it expires (if possible) or use the key
+                        const pref = `${this.prefix}-`;
+                        if (eventKey.startsWith(pref))
+                            return event.onEvent(eventKey, event.eventName);
+                    }
+                    catch (e) {
+                        yield this.handle_redis_error(e);
+                    }
+                }));
+            }
+        });
+    }
+    subscribe(events) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.subscriber)
+                throw new Error('RedisPubSub:Redis subscriber not initialized');
+            for (let event of events) {
+                yield this.subscriber.subscribe(event.eventName, (stringified_obj) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const obj = JSON.parse(stringified_obj);
+                        this.logger.info("PubSub: Subscribe: New custodial key:", obj);
+                        if (!obj)
+                            return;
+                        this.logger.info(`PubSub: Subscribe: Parsed data: `, obj);
+                        return event.onEvent(obj);
+                    }
+                    catch (error) {
+                        return;
+                    }
+                }));
+            }
+        });
+    }
+    get_key(key, _prefix) {
+        return `${_prefix ? _prefix : this.prefix}-${key}`;
+    }
+    _get(final_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initialized)
+                yield this.initialize();
+            const value = yield this.client.get(final_key);
+            if (!value)
+                return null;
+            return value;
+        });
+    }
+    _set(final_key, _value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initialized)
+                yield this.initialize();
+            if (options) {
+                const expiry_timestamp = options.expires_at;
+                const ttl = options.ttl;
+                if (!expiry_timestamp)
+                    throw new Error("Expiry timestamp is required");
+                if (!ttl)
+                    throw new Error("TTL for key required");
+                let opt = {
+                    expiration: {
+                        type: "EXAT",
+                        value: expiry_timestamp
+                    },
+                };
+                let now_s = Math.floor(new Date().getTime() / 1000);
+                return yield this.client.set(final_key, _value, {
+                    EX: ttl
+                });
+            }
+            else {
+                return yield this.client.set(final_key, _value);
+            }
+        });
+    }
+    _delete(final_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initialized)
+                yield this.initialize();
+            return yield this.client.del(final_key);
+        });
+    }
+    get(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            const value = yield this._get(key);
+            if (!value)
+                return null;
+            return value;
+        });
+    }
+    set(_key, _value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            return yield this._set(key, _value, options);
+        });
+    }
+    delete(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            return yield this._delete(key);
+        });
+    }
+    set_object(_key, _value, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            return this._set(key, JSON.stringify(_value), options);
+        });
+    }
+    get_object(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            const value = yield this._get(key);
+            return value ? JSON.parse(value) : null;
+        });
+    }
+    delete_object(_key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let key = this.get_key(_key);
+            return yield this._delete(key);
+        });
+    }
+    handle_redis_error(error) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.warn(`RedisPubSub: Redis Client Error: `, { data: { error } });
+            const error_data = { message: (error === null || error === void 0 ? void 0 : error.message) ? error.message : "Unexpected error occured" };
+            ElasticSearch_1.default.getInstance(this.config).index_log("RedisPubSub", this.handle_redis_error.name, "Error", "Redis Client Error", error_data);
+        });
+    }
+    handle_redis_action(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let message = "Redis Client Connected";
+            if (type === "reconnecting")
+                message = "Redis Client Reconnecting";
+            else if (type === "end") {
+                message = "Redis Client Connection Ended";
+                yield this.reinitialize();
+            }
+            this.logger.info(`RedisPubSub: Redis client action: ${message} type: ${type}`);
+        });
+    }
+}
+exports.default = RedisPubSub;

package/build/services/RedisQueue.d.ts

@@ -0,0 +1,18 @@
+import { IConfig } from "../interfaces/config";
+import { InvoiceSubscription } from "./types/lightning";
+declare class RedisQueue {
+    private redis;
+    readonly queue_key: string;
+    constructor(config: IConfig, name?: string);
+    initialize(): Promise<void>;
+    private get_queue;
+    length(): Promise<number>;
+    find(task: (item: InvoiceSubscription) => boolean): Promise<InvoiceSubscription | undefined>;
+    push(item: InvoiceSubscription): Promise<void>;
+    push_many(items: InvoiceSubscription[]): Promise<void>;
+    filter(task: (invoice: InvoiceSubscription) => boolean): Promise<InvoiceSubscription[]>;
+    set(queue: InvoiceSubscription[]): Promise<void>;
+    shift(): Promise<InvoiceSubscription | undefined>;
+}
+export default RedisQueue;
+//# sourceMappingURL=RedisQueue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RedisQueue.d.ts","sourceRoot":"","sources":["../../src/services/RedisQueue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGxD,cAAM,UAAU;IACZ,OAAO,CAAC,KAAK,CAAQ;IACrB,SAAgB,SAAS,EAAE,MAAM,CAAC;gBACtB,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7B,UAAU;YAIT,SAAS;IAOV,MAAM;IAKN,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,mBAAmB,KAAK,OAAO;IAMjD,IAAI,CAAC,IAAI,EAAE,mBAAmB;IAO9B,SAAS,CAAC,KAAK,EAAE,mBAAmB,EAAE;IAQtC,MAAM,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAKvF,GAAG,CAAC,KAAK,EAAE,mBAAmB,EAAE;IAIhC,KAAK;CASrB;AAED,eAAe,UAAU,CAAC"}

package/build/services/RedisQueue.js

@@ -0,0 +1,82 @@
+"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 Redis_1 = __importDefault(require("./Redis"));
+class RedisQueue {
+    constructor(config, name) {
+        this.redis = Redis_1.default.getInstance(config);
+        this.queue_key = name ? `redis-queue-${name}` : `redis-queue-${crypto.randomUUID()}`;
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis.set_object(this.queue_key, []);
+        });
+    }
+    get_queue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queue = yield this.redis.get_object(this.queue_key);
+            if (!queue)
+                return [];
+            return queue;
+        });
+    }
+    length() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queue = yield this.get_queue();
+            return queue ? queue.length : 0;
+        });
+    }
+    find(task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queue = yield this.get_queue();
+            return queue.find(task);
+        });
+    }
+    push(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queue = yield this.get_queue();
+            queue.push(item);
+            yield this.redis.set_object(this.queue_key, queue);
+        });
+    }
+    push_many(items) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queue = yield this.get_queue();
+            queue.push(...items);
+            yield this.redis.set_object(this.queue_key, queue);
+        });
+    }
+    filter(task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queue = yield this.get_queue();
+            return queue.filter(task);
+        });
+    }
+    set(queue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.redis.set_object(this.queue_key, queue);
+        });
+    }
+    shift() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let queue = yield this.get_queue();
+            let removed_item = queue.shift();
+            if (!removed_item)
+                return undefined;
+            yield this.set(queue);
+            return removed_item;
+        });
+    }
+}
+exports.default = RedisQueue;

package/build/services/StorageService.d.ts

@@ -0,0 +1,12 @@
+import { BlobClient } from '@azure/storage-blob';
+import { IConfig } from '../interfaces/config';
+declare class StorageService {
+    private config;
+    constructor(config: IConfig);
+    fetchContainerContent: (containerClientName: string, fileName: string) => Promise<any | null>;
+    updateContainerContent: (containerName: string, fileName: string, content: string) => Promise<boolean>;
+    fetchJsonFromBlob: (client: BlobClient) => Promise<any>;
+    streamToBuffer: (readableStream: any) => Promise<Buffer>;
+}
+export default StorageService;
+//# sourceMappingURL=StorageService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StorageService.d.ts","sourceRoot":"","sources":["../../src/services/StorageService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAqB,MAAM,qBAAqB,CAAC;AAEpE,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,cAAM,cAAc;IAChB,OAAO,CAAC,MAAM,CAAU;gBACZ,MAAM,EAAE,OAAO;IAK3B,qBAAqB,GAAU,qBAAqB,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC,CA6BjG;IAGD,sBAAsB,GAAU,eAAe,MAAM,EAAE,UAAU,MAAM,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,OAAO,CAAC,CA2BzG;IAEF,iBAAiB,GAAU,QAAQ,UAAU,kBAQ5C;IAED,cAAc,GAAU,gBAAgB,GAAG,KAAG,OAAO,CAAC,MAAM,CAAC,CAW5D;CAEJ;AAED,eAAe,cAAc,CAAC"}

package/build/services/StorageService.js

@@ -0,0 +1,92 @@
+"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 storage_blob_1 = require("@azure/storage-blob");
+const KeyVaultService_1 = __importDefault(require("./KeyVaultService"));
+class StorageService {
+    constructor(config) {
+        this.fetchContainerContent = (containerClientName, fileName) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const vaultHandler = new KeyVaultService_1.default(this.config.config.keyVaultName);
+                if (!vaultHandler.client) {
+                    vaultHandler.initializeKeyVaultService();
+                }
+                const connectionStringFromVault = yield vaultHandler.getSecretValue(this.config.requiredVaultSecrets.azureStorageAccount);
+                if (!connectionStringFromVault) {
+                    throw new Error("Cannot get storage account connection string");
+                }
+                const blobServiceClient = storage_blob_1.BlobServiceClient.fromConnectionString(connectionStringFromVault);
+                const containerClient = blobServiceClient.getContainerClient(containerClientName);
+                const blobClient = containerClient.getBlobClient(fileName);
+                const downloadBlockBlobResponse = yield this.fetchJsonFromBlob(blobClient);
+                if (!downloadBlockBlobResponse) {
+                    throw new Error("Failed to download file");
+                }
+                return downloadBlockBlobResponse;
+            }
+            catch (error) {
+                console.error(`Error:`, error);
+                throw error;
+            }
+        });
+        // Function to update or create the content of a file in a given container
+        this.updateContainerContent = (containerName, fileName, content) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const vaultHandler = new KeyVaultService_1.default(this.config.config.keyVaultName);
+                if (!vaultHandler.client) {
+                    vaultHandler.initializeKeyVaultService();
+                }
+                // Fetch the connection string from Azure Key Vault
+                const connectionString = yield vaultHandler.getSecretValue(this.config.requiredVaultSecrets.azureStorageAccount);
+                if (!connectionString) {
+                    throw new Error("Failed to retrieve Azure Storage connection string from Key Vault.");
+                }
+                // Create a blob service client and container client
+                const blobServiceClient = storage_blob_1.BlobServiceClient.fromConnectionString(connectionString);
+                const containerClient = blobServiceClient.getContainerClient(containerName);
+                // Get a reference to the blob (file) you want to create/update in the container
+                const blobClient = containerClient.getBlockBlobClient(fileName);
+                // Upload the content to the blob, overwriting any existing content
+                yield blobClient.uploadData(Buffer.from(content));
+                return true;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.fetchJsonFromBlob = (client) => __awaiter(this, void 0, void 0, function* () {
+            const downloadBlockBlobResponse = yield client.download();
+            if (!downloadBlockBlobResponse.readableStreamBody) {
+                return;
+            }
+            const jsonData = (yield this.streamToBuffer(downloadBlockBlobResponse.readableStreamBody)).toString();
+            const jsonObj = JSON.parse(jsonData);
+            return jsonObj;
+        });
+        this.streamToBuffer = (readableStream) => __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const chunks = [];
+                readableStream.on("data", (data) => {
+                    chunks.push(data instanceof Buffer ? data : Buffer.from(data));
+                });
+                readableStream.on("end", () => {
+                    resolve(Buffer.concat(chunks));
+                });
+                readableStream.on("error", reject);
+            });
+        });
+        this.config = config;
+    }
+}
+exports.default = StorageService;

package/build/services/SweepHistoryService.d.ts

@@ -0,0 +1,15 @@
+import { SweepHistory } from "../entities/SweepHistory";
+import { IDatabasePool } from "../interfaces/database";
+import { IConfig } from "../interfaces/config";
+import { Paginated } from "./types/claim_job_service";
+import { SweepSearchFilters } from "./types/sweep_job_service";
+declare class SweepHistoryService {
+    private dbPool;
+    private config;
+    constructor(dbPool: IDatabasePool, config: IConfig);
+    private get_repo;
+    private paginate;
+    get_sweep_jobs_paginated(page: number, page_size: number | undefined, filters: SweepSearchFilters): Promise<Paginated<SweepHistory[]>>;
+}
+export default SweepHistoryService;
+//# sourceMappingURL=SweepHistoryService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SweepHistoryService.d.ts","sourceRoot":"","sources":["../../src/services/SweepHistoryService.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAMxD,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAG/D,cAAM,mBAAmB;IACrB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAU;gBACZ,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO;IAKlD,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,QAAQ,CAsBf;IAEK,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,YAAK,EAAE,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC;CAIxI;AAED,eAAe,mBAAmB,CAAC"}

package/build/services/SweepHistoryService.js

@@ -0,0 +1,52 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+class SweepHistoryService {
+    constructor(dbPool, config) {
+        this.paginate = (page, page_size, filters) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            if (page === 0)
+                page = 1;
+            // Use separate queries to avoid TypeORM findAndCount issues
+            const [items, totalCount] = yield Promise.all([
+                repo.find({
+                    take: page_size,
+                    skip: (page - 1) * page_size,
+                    where: Object.assign({}, filters),
+                    order: { swept_at: "DESC" }
+                }),
+                repo.count({ where: Object.assign({}, filters) })
+            ]);
+            return {
+                total_count: totalCount,
+                pages_count: Math.ceil(totalCount / page_size),
+                has_next: totalCount > page * page_size,
+                current_page: page,
+                items: items || []
+            };
+        });
+        this.dbPool = dbPool;
+        this.config = config;
+    }
+    get_repo() {
+        const repository = this.dbPool.sweepHistoryRepo;
+        if (!repository) {
+            throw new Error(`SweepJob History Repo not initialized.`);
+        }
+        return repository;
+    }
+    get_sweep_jobs_paginated(page_1) {
+        return __awaiter(this, arguments, void 0, function* (page, page_size = 10, filters) {
+            return this.paginate(page, page_size, filters);
+        });
+    }
+}
+exports.default = SweepHistoryService;

package/build/services/SweepJobService.d.ts

@@ -0,0 +1,53 @@
+import { SweepJob } from "../entities/SweepJob";
+import { BlockchainType } from "../interfaces";
+import { Candidate, ChainId, SweepResult } from "../interfaces";
+import { DepositWalletBalance } from "../entities/DepositWalletBalance";
+import { IDatabasePool } from "../interfaces/database";
+import { IConfig } from "../interfaces/config";
+import { Paginated } from "./types/claim_job_service";
+import { SweepJobStatus, SweepSearchFilters } from "./types/sweep_job_service";
+declare class SweepJobService {
+    private dbPool;
+    private config;
+    private logger;
+    constructor(dbPool: IDatabasePool, config: IConfig);
+    private getRepo;
+    get_sweep_jobs_paginated(page: number, page_size: number | undefined, filters: SweepSearchFilters): Promise<Paginated<SweepJob[]>>;
+    /**
+CREATE UNIQUE INDEX uniq_active_sweep
+ON sweep_jobs(blockchain, chain_id, token, address)
+WHERE job_status IN ('pending', 'queued');
+
+     */
+    createSweepJob(userId: number, blockchain: string, chainId: string, address: string, parentIndex: number, childIndex: number, token: string, decimals: number, balance: bigint): Promise<SweepJob>;
+    markBatchComplete(sweepResults: SweepResult[]): Promise<void>;
+    findAndLockQueuedBatchJobs(blockchain: BlockchainType, limit: number | undefined, lock_owner: string, lock_expiry_duration_min?: number): Promise<SweepJob[]>;
+    findAndLockQueuedJobs(blockchain: BlockchainType, limit: number | undefined, lock_owner: string, lock_expiry_duration_min?: number): Promise<SweepJob[]>;
+    findAndLockPendingJobs(blockchain: BlockchainType, lock_owner: string, lock_interval_mins?: number, limit?: number): Promise<SweepJob[]>;
+    createSweepJobDeprec(userId: number, blockchain: string, chainId: string, address: string, parentIndex: number, childIndex: number, token: string, decimals: number, balance: bigint): Promise<SweepJob>;
+    dispatchAddSweepJobWithBalanceCheck(wallet_id: number, blockchain: BlockchainType, user_id: number, address: string, parentIndex: number, childIndex: number, is_full_sweep: boolean): Promise<void>;
+    batchCreateSweepJob(user_id: number, address: string, parent_index: number, child_index: number, need_sweep: DepositWalletBalance[]): Promise<boolean>;
+    getPendingSweepJobs(limit?: number): Promise<Candidate[]>;
+    dropSweepJobs(to_remove: {
+        blockchain: BlockchainType;
+        chain_id: ChainId;
+        token: string;
+        address: string;
+    }[]): Promise<never[] | import("typeorm").DeleteResult>;
+    markMultipleAsSwept(sweepResults: SweepResult[]): Promise<void>;
+    batch_update_queued_with_sweep_before: (jobs: {
+        id: number;
+        sweep_before: Date | null;
+    }[], expected_status: SweepJobStatus) => Promise<void>;
+    batch_update_status: (job_ids: number[], expected_status: SweepJobStatus, new_status: SweepJobStatus) => Promise<void>;
+    requeue_failed_retryable_jobs: (blockchain: BlockchainType, limit: number) => Promise<SweepJob[]>;
+    requeue_expired_jobs: (status: SweepJobStatus, blockchain: BlockchainType, limit: number, freeze_min: number) => Promise<SweepJob[]>;
+    batch_requeue_jobs_to_pending: (job_ids: number[], expected_status: SweepJobStatus) => Promise<void>;
+    batch_update_failed_jobs: (request_ids: number[], new_status: SweepJobStatus, error_message?: string, retryable?: boolean) => Promise<void>;
+    batch_update_failed_jobs_with_error: (jobs: SweepJob[], retryable: boolean) => Promise<void>;
+    batch_update_confirming: (jobs: SweepResult[], expected_status: SweepJobStatus) => Promise<void>;
+    reset_retry_count: (job_ids: number[]) => Promise<void>;
+    find_confirming_jobs_with_tx_hash(blockchain: BlockchainType, limit: number, lock_owner: string, lock_minutes?: number): Promise<SweepJob[]>;
+}
+export default SweepJobService;
+//# sourceMappingURL=SweepJobService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SweepJobService.d.ts","sourceRoot":"","sources":["../../src/services/SweepJobService.ts"],"names":[],"mappings":"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"}