@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/services/SweepJobService.js

@@ -0,0 +1,725 @@
+"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 SweepJob_1 = require("../entities/SweepJob");
+const SweepHistory_1 = require("../entities/SweepHistory");
+const BalanceService_1 = __importDefault(require("./BalanceService"));
+const Wallets_1 = require("../utils/Wallets");
+const Logger_1 = require("../utils/Logger");
+class SweepJobService {
+    constructor(dbPool, config) {
+        this.batch_update_queued_with_sweep_before = (jobs, expected_status) => __awaiter(this, void 0, void 0, function* () {
+            if (jobs.length === 0)
+                return;
+            const repo = this.getRepo();
+            // Use unnest to update multiple rows with different values
+            yield repo.query(`
+        UPDATE usersmanagement.sweep_jobs AS s
+        SET job_status = 'queued', 
+            updated_at = now(), 
+            sweep_before = v.sweep_before,
+            locked_at = NULL,
+            lock_owner = NULL,
+            lock_expires_at = NULL
+        FROM (SELECT unnest($1::int[]) AS id, unnest($2::timestamptz[]) AS sweep_before) AS v
+        WHERE s.id = v.id
+        AND s.job_status = $3
+    `, [
+                jobs.map(j => j.id),
+                jobs.map(j => j.sweep_before),
+                expected_status
+            ]);
+        });
+        this.batch_update_status = (job_ids, expected_status, new_status) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.getRepo();
+            const status = new_status;
+            yield repo.query(`
+            UPDATE usersmanagement.sweep_jobs
+            SET job_status = $1, updated_at = now() 
+            WHERE id = ANY($2)
+            AND job_status = $3
+        `, [status, job_ids, expected_status]);
+            return;
+        });
+        this.requeue_failed_retryable_jobs = (blockchain, limit) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.getRepo();
+            const rows = yield repo.query(`
+            WITH all_failed AS (
+                SELECT
+                    s.id,
+                    s.blockchain, s.chain_id, s.token, s.address,
+                    ROW_NUMBER() OVER (
+                        PARTITION BY s.blockchain, s.chain_id, s.token, s.address
+                        ORDER BY s.updated_at DESC
+                    ) AS rn
+                FROM usersmanagement.sweep_jobs s
+                WHERE s.job_status = 'failed_retryable'
+                  AND s.blockchain = $1
+                  AND NOT EXISTS (
+                      SELECT 1 FROM usersmanagement.sweep_jobs dup
+                      WHERE dup.blockchain = s.blockchain
+                        AND dup.chain_id = s.chain_id
+                        AND dup.token = s.token
+                        AND dup.address = s.address
+                        AND dup.job_status IN ('pending', 'queued')
+                  )
+            ),
+            duplicates_deleted AS (
+                DELETE FROM usersmanagement.sweep_jobs
+                WHERE id IN (SELECT id FROM all_failed WHERE rn > 1)
+            ),
+            locked AS (
+                SELECT f.id
+                FROM all_failed f
+                JOIN usersmanagement.sweep_jobs j ON j.id = f.id
+                WHERE f.rn = 1
+                ORDER BY j.updated_at ASC
+                LIMIT $2
+                FOR UPDATE SKIP LOCKED
+            )
+            UPDATE usersmanagement.sweep_jobs j
+            SET
+                job_status = 'pending',
+                tx_hash = NULL,
+                lock_owner = NULL,
+                locked_at = NULL,
+                lock_expires_at = NULL,
+                sweep_before = NULL,
+                error_message = NULL,
+                sent_at = NULL,
+                updated_at = now()
+            FROM locked
+            WHERE j.id = locked.id
+            RETURNING j.*;
+        `, [blockchain, limit]);
+            return rows[0];
+        });
+        this.requeue_expired_jobs = (status, blockchain, limit, freeze_min) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.getRepo();
+            if (freeze_min === 0)
+                freeze_min = 1;
+            const rows = yield repo.query(`
+            WITH all_matching AS (
+                SELECT
+                    s.id,
+                    s.blockchain, s.chain_id, s.token, s.address,
+                    ROW_NUMBER() OVER (
+                        PARTITION BY s.blockchain, s.chain_id, s.token, s.address
+                        ORDER BY s.updated_at DESC
+                    ) AS rn
+                FROM usersmanagement.sweep_jobs s
+                WHERE s.job_status = $1
+                  AND s.blockchain = $2
+                  AND s.lock_expires_at + ($4 * interval '1 minute') < now()
+                  AND NOT EXISTS (
+                      SELECT 1 FROM usersmanagement.sweep_jobs dup
+                      WHERE dup.blockchain = s.blockchain
+                        AND dup.chain_id = s.chain_id
+                        AND dup.token = s.token
+                        AND dup.address = s.address
+                        AND dup.job_status IN ('pending', 'queued')
+                  )
+            ),
+            duplicates_deleted AS (
+                DELETE FROM usersmanagement.sweep_jobs
+                WHERE id IN (SELECT id FROM all_matching WHERE rn > 1)
+            ),
+            locked AS (
+                SELECT f.id
+                FROM all_matching f
+                JOIN usersmanagement.sweep_jobs j ON j.id = f.id
+                WHERE f.rn = 1
+                ORDER BY j.updated_at ASC
+                LIMIT $3
+                FOR UPDATE SKIP LOCKED
+            )
+            UPDATE usersmanagement.sweep_jobs j
+            SET
+                job_status = 'pending',
+                tx_hash = NULL,
+                lock_owner = NULL,
+                locked_at = NULL,
+                lock_expires_at = NULL,
+                sweep_before = NULL,
+                error_message = NULL,
+                sent_at = NULL,
+                updated_at = now()
+            FROM locked
+            WHERE j.id = locked.id
+            RETURNING j.*;
+        `, [status, blockchain, limit, freeze_min]);
+            return rows[0];
+        });
+        // public requeue_expired_jobs = async (
+        //     current_status: SweepJobStatus,
+        //     limit: number,
+        //     max_retries: number,
+        // ): Promise<SweepJob[]> => {
+        //     const rows = await this.getRepo().query(
+        //         `
+        //     WITH expired AS (
+        //       SELECT id
+        //       FROM usersmanagement.sweep_jobs
+        //       WHERE job_status = $2
+        //         AND lock_expires_at  < now()
+        //         AND retry_count < $3
+        //       ORDER BY lock_expires_at ASC
+        //       LIMIT $1
+        //       FOR UPDATE SKIP LOCKED
+        //     )
+        //     UPDATE usersmanagement.sweep_jobs sj
+        //     SET
+        //       job_status = 'queued',
+        //       locked_at = NULL,
+        //       lock_owner = NULL,
+        //       lock_expires_at = NULL,
+        //       error_message = NULL,
+        //       sweep_before = NULL,
+        //       tx_hash = NULL,
+        //       sent_at = NULL,
+        //       updated_at = now()
+        //     FROM expired e
+        //     WHERE sj.id = e.id
+        //     RETURNING sj.*;
+        //     `,
+        //         [limit, current_status, max_retries]
+        //     );
+        //     return rows[0];
+        // };
+        this.batch_requeue_jobs_to_pending = (job_ids, expected_status) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.getRepo();
+            yield repo.query(`
+            UPDATE usersmanagement.sweep_jobs
+            SET job_status = 'pending', 
+                tx_hash = NULL,
+                lock_owner = NULL,
+                locked_at = NULL,
+                lock_expires_at = NULL,
+                sweep_before = NULL,
+                error_message = NULL,
+                sent_at = NULL,
+                updated_at = now()
+            WHERE id = ANY($1)
+            AND job_status = $2
+            `, [job_ids, expected_status]);
+        });
+        this.batch_update_failed_jobs = (request_ids, new_status, error_message, retryable) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.getRepo();
+            yield repo.query(`
+            UPDATE usersmanagement.sweep_jobs
+            SET 
+                job_status = $1,
+                updated_at = now()
+            WHERE id = ANY($2::bigint[])
+        `, [
+                new_status,
+                request_ids
+            ]);
+        });
+        this.batch_update_failed_jobs_with_error = (jobs, retryable) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.getRepo();
+            const failed_status = retryable ? "failed_retryable" : "failed_permanent";
+            const ids = jobs.map(j => j.id);
+            const errors = jobs.map(j => { var _a; return (_a = j.error_message) !== null && _a !== void 0 ? _a : null; });
+            yield repo.query(`
+            UPDATE usersmanagement.sweep_jobs j
+            SET
+                job_status = $1,
+                error_message = data.error_message,
+                updated_at = now()
+            FROM (
+                SELECT
+                    unnest($2::bigint[]) AS id,
+                    unnest($3::text[]) AS error_message
+            ) AS data
+            WHERE j.id = data.id;
+            `, [failed_status, ids, errors]);
+        });
+        this.batch_update_confirming = (jobs, expected_status) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.getRepo();
+            const ids = jobs.map(j => j.jobId);
+            const tx_hashes = jobs.map(j => j.txHash);
+            yield repo.query(`
+            UPDATE usersmanagement.sweep_jobs sj
+            SET
+                job_status = 'confirming',
+                tx_hash = data.tx_hash,
+                sent_at = now(),
+                locked_at = NULL,
+                lock_owner = NULL,
+                lock_expires_at = NULL,
+                updated_at = now()
+            FROM (
+                SELECT *
+                FROM unnest($1::bigint[], $2::text[])
+            ) AS data(id, tx_hash)
+            WHERE sj.id = data.id
+            AND sj.job_status = $3
+            AND sj.tx_hash IS NULL;
+            `, [ids, tx_hashes, expected_status]);
+        });
+        this.reset_retry_count = (job_ids) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.getRepo();
+            const parsed_ids = job_ids.map(id => Number(id));
+            yield repo.query(`
+            UPDATE usersmanagement.sweep_jobs
+            SET retry_count = 0, updated_at = now()
+            WHERE id = ANY($1)
+        `, [parsed_ids]);
+        });
+        this.dbPool = dbPool;
+        this.config = config;
+        this.logger = (0, Logger_1.createLogger)(`SweepJobService`, config.pipelineConfig.azureAppName);
+    }
+    getRepo() {
+        const repository = this.dbPool.sweepJobRepo;
+        if (!repository) {
+            throw new Error(`SweepJob Repo not initialized.`);
+        }
+        return repository;
+    }
+    get_sweep_jobs_paginated(page_1) {
+        return __awaiter(this, arguments, void 0, function* (page, page_size = 10, filters) {
+            const repo = this.getRepo();
+            if (page === 0)
+                page = 1;
+            // Build where clause
+            const whereClause = {};
+            if (filters.blockchain)
+                whereClause.blockchain = filters.blockchain;
+            if (filters.chain_id)
+                whereClause.chain_id = filters.chain_id;
+            if (filters.token)
+                whereClause.token = filters.token;
+            if (filters.address)
+                whereClause.address = filters.address;
+            if (filters.job_status)
+                whereClause.job_status = filters.job_status;
+            // 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: whereClause,
+                    order: { created_at: "DESC" }
+                }),
+                repo.count({ where: whereClause })
+            ]);
+            return {
+                total_count: totalCount,
+                pages_count: Math.ceil(totalCount / page_size),
+                has_next: totalCount > page * page_size,
+                current_page: page,
+                items: items || []
+            };
+        });
+    }
+    /**
+CREATE UNIQUE INDEX uniq_active_sweep
+ON sweep_jobs(blockchain, chain_id, token, address)
+WHERE job_status IN ('pending', 'queued');
+
+     */
+    // Inserts or updates a sweep job with pending status
+    createSweepJob(userId, blockchain, chainId, address, parentIndex, childIndex, token, decimals, balance) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const repository = this.getRepo();
+            const rows = yield repository.query(`
+            INSERT INTO usersmanagement.sweep_jobs (
+                user_id,
+                blockchain,
+                chain_id,
+                address,
+                parent_index,
+                child_index,
+                token,
+                decimals,
+                balance,
+                job_status,
+                created_at,
+                updated_at
+            )
+            VALUES (
+                $1,
+                $2,
+                $3,
+                $4,
+                $5,
+                $6,
+                $7,
+                $8,
+                $9,
+                'pending',
+                now(),
+                now()
+            )
+            ON CONFLICT (blockchain, chain_id, token, address)
+            WHERE job_status IN ('pending', 'queued')
+            DO UPDATE SET
+                balance = EXCLUDED.balance,
+                job_status = CASE
+                        WHEN sweep_jobs.job_status IN ('failed_retryable', 'failed_permanent')
+                        THEN 'pending'
+                        ELSE sweep_jobs.job_status
+                    END,
+                updated_at = now()
+            RETURNING *;
+            `, [
+                userId,
+                blockchain,
+                chainId,
+                (0, Wallets_1.normalizeAddress)(address, blockchain),
+                parentIndex,
+                childIndex,
+                (0, Wallets_1.normalizeAddress)(token, blockchain),
+                decimals,
+                balance.toString()
+            ]);
+            return rows[0];
+        });
+    }
+    // Called after successful sweep by Sweep worker
+    markBatchComplete(sweepResults) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (sweepResults.length === 0)
+                return;
+            const jobIds = sweepResults.map(r => r.jobId);
+            const txHashes = sweepResults.map(r => r.txHash);
+            yield this.getRepo().manager.transaction((em) => __awaiter(this, void 0, void 0, function* () {
+                yield em.query(`
+            WITH swept_jobs AS (
+                SELECT
+                    j.id,
+                    j.blockchain,
+                    j.chain_id,
+                    j.user_id,
+                    j.address,
+                    j.parent_index,
+                    j.child_index,
+                    j.token,
+                    j.decimals,
+                    j.balance,
+                    r.sweep_tx_hash,
+                    now() AS swept_at
+                FROM usersmanagement.sweep_jobs j
+                JOIN (
+                    SELECT
+                        unnest($1::bigint[]) AS job_id,
+                        unnest($2::text[])   AS sweep_tx_hash
+                ) r ON r.job_id = j.id
+            ),
+            inserted AS (
+                INSERT INTO usersmanagement.sweep_history (
+                    blockchain,
+                    chain_id,
+                    user_id,
+                    address,
+                    parent_index,
+                    child_index,
+                    token,
+                    decimals,
+                    amount,
+                    sweep_tx_hash,
+                    swept_at
+                )
+                SELECT
+                    blockchain,
+                    chain_id,
+                    user_id,
+                    address,
+                    parent_index,
+                    child_index,
+                    token,
+                    decimals,
+                    balance,
+                    sweep_tx_hash,
+                    swept_at
+                FROM swept_jobs
+            )
+            DELETE FROM usersmanagement.sweep_jobs
+            WHERE id IN (SELECT id FROM swept_jobs);
+            `, [jobIds, txHashes]);
+            }));
+        });
+    }
+    // Get batch of jobs for low priority sweeps (midnight worker)
+    findAndLockQueuedBatchJobs(blockchain_1) {
+        return __awaiter(this, arguments, void 0, function* (blockchain, limit = 100, lock_owner, lock_expiry_duration_min = 30) {
+            const repo = this.getRepo();
+            const rows = yield repo.query(`
+        WITH locked AS (
+            SELECT id
+            FROM usersmanagement.sweep_jobs
+            WHERE job_status = 'queued'
+              AND blockchain = $1
+              AND sweep_before IS NULL
+              AND (locked_at IS NULL OR lock_expires_at < now())
+            ORDER BY created_at ASC
+            LIMIT $2
+            FOR UPDATE SKIP LOCKED
+        )
+        UPDATE usersmanagement.sweep_jobs j
+        SET
+            locked_at = now(),
+            lock_owner = $3,
+            lock_expires_at = now() + ($4 * interval '1 minute'),
+            updated_at = now()
+        FROM locked
+        WHERE j.id = locked.id
+        RETURNING j.*;
+        `, [blockchain, limit, lock_owner, lock_expiry_duration_min]);
+            return rows[0];
+        });
+    }
+    // Pull jobs ready for transfer by sweep worker
+    findAndLockQueuedJobs(blockchain_1) {
+        return __awaiter(this, arguments, void 0, function* (blockchain, limit = 100, lock_owner, lock_expiry_duration_min = 5) {
+            const repo = this.getRepo();
+            const rows = yield repo.query(`
+            WITH locked AS (
+                SELECT id
+                FROM usersmanagement.sweep_jobs
+                WHERE job_status = 'queued'
+                    AND blockchain = $1
+                    AND sweep_before <= now()
+                    AND (locked_at IS NULL OR lock_expires_at < now())
+                ORDER BY sweep_before ASC
+                LIMIT $2
+                FOR UPDATE SKIP LOCKED
+            )
+            UPDATE usersmanagement.sweep_jobs j
+            SET
+                locked_at = now(),
+                lock_owner = $3,
+                lock_expires_at = now() + ($4 * interval '1 minute')
+            FROM locked
+            WHERE j.id = locked.id
+            RETURNING j.*;
+            `, [blockchain, limit, lock_owner, lock_expiry_duration_min]);
+            return rows[0];
+        });
+    }
+    // Pull jobs to ensure enough gas cost by funding worker
+    findAndLockPendingJobs(blockchain_1, lock_owner_1) {
+        return __awaiter(this, arguments, void 0, function* (blockchain, lock_owner, lock_interval_mins = 5, limit = 100) {
+            const repo = this.getRepo();
+            const rows = yield repo.query(`
+            WITH locked AS (
+                SELECT id
+                FROM usersmanagement.sweep_jobs
+                WHERE job_status = 'pending'
+                    AND blockchain = $1
+                    AND (locked_at IS NULL OR lock_expires_at < now())
+                ORDER BY created_at
+                LIMIT $2
+            )
+            UPDATE usersmanagement.sweep_jobs j
+            SET
+                locked_at = now(),
+                lock_owner = $3,
+                lock_expires_at = now() + ($4 * interval '1 minute')
+            FROM locked
+            WHERE j.id = locked.id
+            RETURNING j.*;
+            `, [blockchain, limit, lock_owner, lock_interval_mins]);
+            return rows[0];
+        });
+    }
+    createSweepJobDeprec(userId, blockchain, chainId, address, parentIndex, childIndex, token, decimals, balance) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const repository = this.getRepo();
+            // Check if a job already exists
+            const existingJob = yield repository.findOne({
+                where: {
+                    blockchain,
+                    chain_id: chainId,
+                    token: (0, Wallets_1.normalizeAddress)(token, blockchain),
+                    address: (0, Wallets_1.normalizeAddress)(address, blockchain)
+                }
+            });
+            if (existingJob) {
+                // Update the existing job's balance if needed
+                if (existingJob.balance !== balance) {
+                    existingJob.balance = balance;
+                    existingJob.updated_at = new Date();
+                    return repository.save(existingJob);
+                }
+                return existingJob;
+            }
+            // Create new job if none exists
+            const job = new SweepJob_1.SweepJob();
+            job.user_id = userId;
+            job.blockchain = blockchain;
+            job.chain_id = chainId;
+            job.address = (0, Wallets_1.normalizeAddress)(address, blockchain);
+            job.parent_index = parentIndex;
+            job.child_index = childIndex;
+            job.token = (0, Wallets_1.normalizeAddress)(token, blockchain);
+            job.decimals = decimals;
+            job.balance = balance;
+            return repository.save(job);
+        });
+    }
+    // Creates a sweep job for wallets with token balance > min wallet balance
+    dispatchAddSweepJobWithBalanceCheck(wallet_id, blockchain, user_id, address, parentIndex, childIndex, is_full_sweep) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const balanceService = new BalanceService_1.default(this.dbPool, this.config);
+            const need_sweep = yield balanceService.getNeedsSweepBalances(wallet_id, blockchain, address, is_full_sweep);
+            yield this.batchCreateSweepJob(user_id, address, parentIndex, childIndex, need_sweep);
+        });
+    }
+    batchCreateSweepJob(user_id, address, parent_index, child_index, need_sweep) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = new Date().toISOString();
+            const inputs = need_sweep.map((w) => {
+                return `('${w.blockchain}', '${w.chain_id}', ${user_id}, '${address}', ${parent_index}, ${child_index}, '${(0, Wallets_1.normalizeAddress)(w.token, w.blockchain)}', ${w.decimals}, ${w.balance}, '${w.created_at.toISOString()}', '${now}')`;
+            });
+            if (inputs.length === 0) {
+                return true;
+            }
+            const dbDriver = this.dbPool;
+            const dataSource = dbDriver.getDataSource();
+            if (!dataSource) {
+                throw new Error(`Database connection is not initialized.`);
+            }
+            const query = `
+        INSERT INTO usersmanagement.sweep_jobs
+        (blockchain, chain_id, user_id, address, parent_index, child_index, token, decimals, balance, created_at, updated_at)
+        VALUES ${inputs.join(", ")}
+        ON CONFLICT (blockchain, chain_id, token, address)
+        WHERE job_status IN ('pending', 'queued')
+        DO UPDATE SET
+            balance = EXCLUDED.balance,
+            updated_at = EXCLUDED.updated_at
+        WHERE sweep_jobs.balance != EXCLUDED.balance
+       `;
+            try {
+                yield dataSource.query(query);
+                this.logger.info(`Sweep job created for ${need_sweep.length} wallets`);
+                return true;
+            }
+            catch (error) {
+                this.logger.error(`Failed to create sweep job for wallets:`, { data: { error, user_id, address, parent_index, child_index, need_sweep } });
+                throw error;
+            }
+        });
+    }
+    getPendingSweepJobs() {
+        return __awaiter(this, arguments, void 0, function* (limit = 100) {
+            const repository = this.getRepo();
+            const sweep_jobs = yield repository.find({ take: limit, order: { id: "ASC" } });
+            return sweep_jobs.map((job) => {
+                return {
+                    sweep_id: job.id,
+                    paymentToken: (0, Wallets_1.normalizeAddress)(job.token, job.blockchain),
+                    blockchain: job.blockchain,
+                    chainId: job.chain_id,
+                    parentIndex: job.parent_index,
+                    childIndex: job.child_index,
+                    address: (0, Wallets_1.normalizeAddress)(job.address, job.blockchain),
+                    balance: job.balance,
+                    decimals: job.decimals
+                };
+            });
+        });
+    }
+    dropSweepJobs(to_remove) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (to_remove.length === 0) {
+                return [];
+            }
+            const jobRepo = this.getRepo();
+            const dbDriver = this.dbPool;
+            const dataSource = dbDriver.getDataSource();
+            if (!dataSource) {
+                throw new Error(`Database connection is not initialized.`);
+            }
+            try {
+                const conditions = to_remove.map(val => ({
+                    blockchain: val.blockchain,
+                    chain_id: val.chain_id,
+                    token: (0, Wallets_1.normalizeAddress)(val.token, val.blockchain),
+                    address: (0, Wallets_1.normalizeAddress)(val.address, val.blockchain)
+                }));
+                const result = yield jobRepo.delete(conditions);
+                this.logger.info(`Deleted ${result.affected} sweep jobs`);
+                return result;
+            }
+            catch (error) {
+                this.logger.error(`Failed to delete sweep jobs:`, { data: { error } });
+                throw error;
+            }
+        });
+    }
+    markMultipleAsSwept(sweepResults) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (sweepResults.length === 0)
+                return;
+            const jobRepo = this.getRepo();
+            // Get all jobs that were swept
+            const jobs = yield jobRepo.findByIds(sweepResults.map(r => r.jobId));
+            // Create history records
+            const historyRecords = jobs.map(job => {
+                const result = sweepResults.find(r => r.jobId === job.id);
+                if (!result)
+                    throw new Error(`No sweep result found for job ${job.id}`);
+                const history = new SweepHistory_1.SweepHistory();
+                history.blockchain = job.blockchain;
+                history.chain_id = job.chain_id;
+                history.user_id = job.user_id;
+                history.address = (0, Wallets_1.normalizeAddress)(job.address, job.blockchain);
+                history.parent_index = job.parent_index;
+                history.child_index = job.child_index;
+                history.token = (0, Wallets_1.normalizeAddress)(job.token, job.blockchain);
+                history.decimals = job.decimals;
+                history.amount = job.balance;
+                history.sweep_tx_hash = result.txHash;
+                history.swept_at = new Date();
+                return history;
+            });
+            // Save history records and delete completed jobs in a transaction
+            yield jobRepo.manager.transaction((transactionalEntityManager) => __awaiter(this, void 0, void 0, function* () {
+                yield transactionalEntityManager.save(SweepHistory_1.SweepHistory, historyRecords);
+                yield transactionalEntityManager.remove(jobs);
+            }));
+        });
+    }
+    find_confirming_jobs_with_tx_hash(blockchain_1, limit_1, lock_owner_1) {
+        return __awaiter(this, arguments, void 0, function* (blockchain, limit, lock_owner, lock_minutes = 5) {
+            const repo = this.getRepo();
+            const rows = yield repo.query(`
+        WITH locked AS (
+            SELECT id
+            FROM usersmanagement.sweep_jobs
+            WHERE job_status = 'confirming'
+              AND tx_hash IS NOT NULL
+              AND blockchain = $1
+              AND (locked_at IS NULL OR lock_expires_at < now())
+            ORDER BY sent_at ASC
+            LIMIT $2
+        )
+        UPDATE usersmanagement.sweep_jobs j
+        SET
+            locked_at = now(),
+            lock_owner = $3,
+            lock_expires_at = now() + ($4 * interval '1 minute')
+        FROM locked
+        WHERE j.id = locked.id
+        RETURNING j.*;
+    `, [blockchain, limit, lock_owner, lock_minutes]);
+            return rows[0];
+        });
+    }
+}
+exports.default = SweepJobService;