@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/services/BalanceService.d.ts

@@ -0,0 +1,39 @@
+import { DepositWalletBalance } from "../entities/DepositWalletBalance";
+import { BlockchainType, ChainId, SweepResult, TransferResult } from "../interfaces";
+import { IDatabasePool } from "../interfaces/database";
+import { IConfig } from "../interfaces/config";
+import { DepositEvent } from "./types";
+import BaseErrors from "../errors/errors";
+type OperationType = "add" | "remove";
+interface GetWalletBalanceResult {
+    token: string;
+    amount: bigint;
+    decimals: number;
+}
+declare class BalanceService extends BaseErrors {
+    private dbPool;
+    private config;
+    private logger;
+    constructor(dbPool: IDatabasePool, config: IConfig);
+    private getEntity;
+    getBalance(userId: number, blockchain: string, chainId: ChainId, paymentToken: string): Promise<GetWalletBalanceResult>;
+    getBalancesNeedSweepByToken(blockchain: BlockchainType, chainId: ChainId, paymentToken: string): Promise<DepositWalletBalance[]>;
+    removeWalletBalances(walletId: number, blockchain: string): Promise<boolean>;
+    initializeWalletBalances(walletId: number, blockchain: string): Promise<boolean>;
+    createBalanceBatch(walletId: number, blockchain: string): Promise<boolean>;
+    private createBalance;
+    batchUpdateBalances(events: DepositEvent[]): Promise<void>;
+    updateBalance(userId: number, blockchain: BlockchainType, address: string, chainId: ChainId, paymentToken: string, amountInWei: bigint, operationType: OperationType): Promise<{
+        updatedEntity: DepositWalletBalance;
+        wallet: import("..").DepositAddress;
+    }>;
+    getNeedsSweepBalances(wallet_id: number, blockchain: BlockchainType, wallet_address: string, is_full_sweep?: boolean): Promise<DepositWalletBalance[]>;
+    deleteBalances(userId: number, blockchain: BlockchainType): Promise<import("typeorm").DeleteResult | undefined>;
+    getAllBalancesNeedSweep(): Promise<any>;
+    get_available_jobs(limit?: number): Promise<import("../interfaces").Candidate[]>;
+    private getTokenDecimals;
+    updateSuccessfulTransfers(successfulTransfers: SweepResult[]): Promise<void>;
+    reflectUpdateInWalletBalances(successfulTransfers: TransferResult[]): Promise<void>;
+}
+export default BalanceService;
+//# sourceMappingURL=BalanceService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BalanceService.d.ts","sourceRoot":"","sources":["../../src/services/BalanceService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,cAAc,EAAgB,OAAO,EAAgB,WAAW,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAOjH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAI1C,KAAK,aAAa,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEtC,UAAU,sBAAsB;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CACpB;AAED,cAAM,cAAe,SAAQ,UAAU;IACnC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,MAAM,CAAS;gBACX,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO;YAOpC,SAAS;IA2BjB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAgCvH,2BAA2B,CAAC,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM;IAsB9F,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IA2BzD,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAI7D,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;YAmD/C,aAAa;IAwBd,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE;IA0EjD,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,aAAa;;;;IA2FpK,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,EAAE,aAAa,GAAE,OAAe;IAmE3H,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc;IAUlD,uBAAuB;IAuBvB,kBAAkB,CAAC,KAAK,GAAE,MAAY;YAOrC,gBAAgB;IAoBxB,yBAAyB,CAAC,mBAAmB,EAAE,WAAW,EAAE;IAY5D,6BAA6B,CAAC,mBAAmB,EAAE,cAAc,EAAE;CA8D5E;AAED,eAAe,cAAc,CAAC"}

package/build/services/BalanceService.js

@@ -0,0 +1,482 @@
+"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 DepositWalletBalance_1 = require("../entities/DepositWalletBalance");
+const Utility_1 = require("../utils/Utility");
+const DepositAddressService_1 = __importDefault(require("./DepositAddressService"));
+const custodial_1 = require("../utils/custodial");
+const Wallets_1 = require("../utils/Wallets");
+const SweepJobService_1 = __importDefault(require("./SweepJobService"));
+const ChainManager_1 = __importDefault(require("./ChainManager"));
+const errors_1 = __importDefault(require("../errors/errors"));
+const Logger_1 = require("../utils/Logger");
+class BalanceService extends errors_1.default {
+    constructor(dbPool, config) {
+        super();
+        this.dbPool = dbPool;
+        this.config = config;
+        this.logger = (0, Logger_1.createLogger)(`BalanceService`, this.config.pipelineConfig.azureAppName);
+    }
+    getEntity(userId, blockchain, chainId, paymentToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbDriver = this.dbPool;
+            if (!dbDriver.balancesRepo || !dbDriver.accountsRepo) {
+                throw new Error(`Db Driver appDataSource is not initialized.`);
+            }
+            const accountsService = new DepositAddressService_1.default(this.dbPool);
+            const entity = yield accountsService.findByUserId(userId, blockchain);
+            if (!entity) {
+                throw new Error(`Account not found for userId ${userId} on ${blockchain} chain`);
+            }
+            const balanceEntity = yield dbDriver.balancesRepo.findOne({
+                where: { blockchain, chain_id: chainId, wallet_id: entity.id, token: (0, Wallets_1.normalizeAddress)(paymentToken, blockchain) }
+            });
+            if (!balanceEntity) {
+                throw new Error(`Balance entity not found for user ${userId} on blockchain ${blockchain} chainId: ${chainId}`);
+            }
+            return balanceEntity;
+        });
+    }
+    // Gets the token balance of the wallet on the given chain
+    getBalance(userId, blockchain, chainId, paymentToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const dbDriver = this.dbPool;
+                if (!dbDriver.balancesRepo || !dbDriver.accountsRepo) {
+                    throw new Error(`Db Driver appDataSource is not initialized.`);
+                }
+                const depositAddressService = new DepositAddressService_1.default(this.dbPool);
+                const accountEntity = yield depositAddressService.findByUserId(userId, blockchain);
+                const entity = yield dbDriver.balancesRepo.findOne({
+                    where: { blockchain, chain_id: chainId, wallet_id: accountEntity.id, token: paymentToken }
+                });
+                if (!entity) {
+                    throw new Error('Balance not found for ' + userId);
+                }
+                return {
+                    token: paymentToken,
+                    amount: entity.balance,
+                    decimals: entity.decimals
+                };
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    // Gets wallets that require sweeping on a specific chain id
+    getBalancesNeedSweepByToken(blockchain, chainId, paymentToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbDriver = this.dbPool;
+            if (!dbDriver.balancesRepo || !dbDriver.accountsRepo) {
+                throw new Error(`Db Driver appDataSource is not initialized.`);
+            }
+            const balances = yield dbDriver.balancesRepo.find({
+                where: {
+                    blockchain,
+                    chain_id: chainId,
+                    token: paymentToken,
+                    // needs_sweep: true
+                },
+                order: {
+                    balance: 'DESC'
+                }
+            });
+            return balances;
+        });
+    }
+    removeWalletBalances(walletId, blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbDriver = this.dbPool;
+            if (!dbDriver.balancesRepo || !dbDriver.accountsRepo) {
+                throw new Error(`Db Driver appDataSource is not initialized.`);
+            }
+            // Create sweep jobs for any non-zero balances
+            const sweep_job_service = new SweepJobService_1.default(this.dbPool, this.config);
+            const depositAddressService = new DepositAddressService_1.default(this.dbPool);
+            // Get wallet details for parent/child indices
+            const walletDetails = yield depositAddressService.findById(walletId);
+            if (!walletDetails) {
+                throw new Error(`Wallet not found for id ${walletId}`);
+            }
+            // Delete all balance entries for this wallet
+            yield dbDriver.balancesRepo.delete({
+                wallet_id: walletId,
+                blockchain: blockchain
+            });
+            return true;
+        });
+    }
+    initializeWalletBalances(walletId, blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.createBalanceBatch(walletId, blockchain);
+        });
+    }
+    createBalanceBatch(walletId, blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbDriver = this.dbPool;
+            const dataSource = dbDriver.getDataSource();
+            if (!dataSource) {
+                throw new Error(`Database connection is not initialized.`);
+            }
+            const chainManager = ChainManager_1.default.getInstance(this.config);
+            if (!chainManager.paymentTokenMap) {
+                throw new Error(`Payment token map not defined in ChainManager.`);
+            }
+            // Build values for batch insert
+            const values = [];
+            const now = new Date().toISOString();
+            // Iterate through chains and tokens to build values array
+            for (const [chainName, config] of Object.entries(chainManager.paymentTokenMap)) {
+                if (config.blockchainType.toLowerCase() !== blockchain.toLowerCase()) {
+                    continue;
+                }
+                // Discard disabled networks
+                if (config.status === false)
+                    continue;
+                // Add each token for this chain to the values array
+                for (const token of config.paymentTokens) {
+                    values.push(`(${walletId}, '${blockchain}', '${config.chainId}', '${token.address}', ${token.decimals}, 0, 0, '${now}', '${now}')`);
+                }
+            }
+            if (values.length === 0) {
+                throw new Error(`No payment tokens found for blockchain ${blockchain}`);
+            }
+            // Execute batch insert
+            const query = `
+            INSERT INTO usersmanagement.deposit_wallet_balance 
+            (wallet_id, blockchain, chain_id, token, decimals, balance, transaction_count, created_at, updated_at)
+            VALUES ${values.join(', ')}
+        `;
+            yield dataSource.query(query);
+            this.logger.info(`Successfully created ${values.length} balance entities for wallet ${walletId}`);
+            return true;
+        });
+    }
+    // Create a balance entity for a given wallet on a given chain for a given payment token
+    // Used when creating new deposit wallets for users
+    createBalance(walletId, blockchain, config, paymentToken, decimals) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbDriver = this.dbPool;
+            if (!dbDriver.balancesRepo) {
+                throw new Error(`Db Driver appDataSource is not initialized.`);
+            }
+            if (!config.chainId)
+                throw new Error("Cannot find chain id.");
+            const entity = new DepositWalletBalance_1.DepositWalletBalance();
+            entity.balance = BigInt(0);
+            entity.blockchain = blockchain;
+            entity.chain_id = config.chainId.toString();
+            entity.decimals = decimals;
+            entity.wallet_id = walletId;
+            entity.transaction_count = 0;
+            entity.token = paymentToken;
+            entity.created_at = new Date();
+            entity.updated_at = new Date();
+            this.logger.info(`Creating balance for wallet id ${walletId}`);
+            const updatedEntity = yield dbDriver.balancesRepo.save(entity);
+            return updatedEntity;
+        });
+    }
+    batchUpdateBalances(events) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.dbPool.balancesRepo)
+                throw new Error(this.UnexpectedError(`Balances repo is not initialized.`));
+            this.logger.info(`Batch updating balances for ${events.length} events `);
+            const walletMap = new Map();
+            for (const e of events) {
+                if (!e.userId)
+                    continue;
+                const key = `${e.userId}:${e.blockchain}:${e.chainId}:${e.tokenAddress}:${e.depositWallet}`;
+                if (!walletMap.has(key)) {
+                    walletMap.set(key, { userId: parseInt(e.userId), blockchain: e.blockchain, chainId: e.chainId.toString(), tokenAddress: e.tokenAddress, depositWallet: e.depositWallet, events: [] });
+                }
+                walletMap.get(key).events.push(e);
+            }
+            const chainManager = ChainManager_1.default.getInstance(this.config);
+            const sweepJobService = new SweepJobService_1.default(this.dbPool, this.config);
+            const accountService = new DepositAddressService_1.default(this.dbPool);
+            const entities = [];
+            // Fetch all current balances once
+            for (const wallet of walletMap.values()) {
+                const { balance: currentBalance, decimals } = yield (0, custodial_1.getWalletBalance)(wallet.blockchain, wallet.chainId, wallet.depositWallet, wallet.tokenAddress, this.dbPool, this.config);
+                // Load entity from DB
+                const entity = yield this.getEntity(wallet.userId, wallet.blockchain, wallet.chainId, wallet.tokenAddress);
+                // Update balance
+                entity.balance = currentBalance;
+                // Optional: check sweep thresholds (reuse your current logic)
+                const paymentTokens = chainManager.getPaymentTokensForChain(parseInt(wallet.chainId));
+                if (!paymentTokens) {
+                    continue;
+                }
+                const relevantTokens = paymentTokens.filter((t) => (0, Wallets_1.normalizeAddress)(t.address, wallet.blockchain) === (0, Wallets_1.normalizeAddress)(wallet.tokenAddress, wallet.blockchain));
+                if (!relevantTokens.length) {
+                    continue;
+                }
+                if (relevantTokens.length > 0) {
+                    const sweepThresholdInWei = (0, Utility_1.fromDecimal)(wallet.blockchain, wallet.chainId, wallet.tokenAddress, relevantTokens[0].sweepThreshold, this.config);
+                    const sweepMinWalletBalanceInWei = (0, Utility_1.fromDecimal)(wallet.blockchain, wallet.chainId, wallet.tokenAddress, relevantTokens[0].sweepWalletMinBalance, this.config);
+                    if (currentBalance - sweepMinWalletBalanceInWei >= sweepThresholdInWei) {
+                        const account = yield accountService.findByUserId(wallet.userId, wallet.blockchain);
+                        yield sweepJobService.createSweepJob(wallet.userId, wallet.blockchain, wallet.chainId, wallet.depositWallet, account.parent_index, account.child_index, wallet.tokenAddress, relevantTokens[0].decimals, entity.balance);
+                    }
+                }
+                // await this.dbPool.balancesRepo.save(entity);
+                entities.push(entity);
+            }
+            // Save updated entity
+            yield this.dbPool.balancesRepo.save(entities);
+        });
+    }
+    // Add or subtract balance of specific user wallet
+    updateBalance(userId, blockchain, address, chainId, paymentToken, amountInWei, operationType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbDriver = this.dbPool;
+            if (!dbDriver.balancesRepo || !dbDriver.accountsRepo) {
+                throw new Error(`Db Driver appDataSource is not initialized.`);
+            }
+            const chainManager = ChainManager_1.default.getInstance(this.config);
+            const paymentTokens = chainManager.getPaymentTokensForChain(parseInt(chainId));
+            if (!paymentTokens) {
+                throw new Error(`No payment tokens found for chain ${chainId}`);
+            }
+            // Filter out relevant token
+            const relevantTokens = paymentTokens.filter((token) => (0, Wallets_1.normalizeAddress)(token.address, blockchain) === (0, Wallets_1.normalizeAddress)(paymentToken, blockchain));
+            if (!relevantTokens.length) {
+                throw new Error(`Payment token ${paymentToken} on chain ${chainId} not found.`);
+            }
+            // Use sweep threshold defined in config file
+            const sweepThresholdInTokenUnits = relevantTokens[0].sweepThreshold;
+            const sweepMinWalletBalance = relevantTokens[0].sweepWalletMinBalance;
+            // Get and validate account entity
+            const accountService = new DepositAddressService_1.default(this.dbPool);
+            const account = yield accountService.findByUserId(userId, blockchain);
+            if (!account) {
+                throw new Error(`Account not found for userId ${userId} on ${blockchain} chain`);
+            }
+            const entity = yield this.getEntity(userId, blockchain, chainId, paymentToken);
+            let needs_sweep = false;
+            switch (operationType) {
+                case "add":
+                    {
+                        const sweepThresholdInWei = (0, Utility_1.fromDecimal)(blockchain, chainId, paymentToken, sweepThresholdInTokenUnits, this.config);
+                        const sweepMinWalletBalanceInWei = (0, Utility_1.fromDecimal)(blockchain, chainId, paymentToken, sweepMinWalletBalance, this.config);
+                        if (sweepMinWalletBalance === undefined || sweepThresholdInWei === undefined || sweepMinWalletBalanceInWei === undefined)
+                            throw new Error("Failed to determine wallet token thresholds");
+                        const { balance: current_balance, decimals } = yield (0, custodial_1.getWalletBalance)(blockchain, chainId, address, paymentToken, this.dbPool, this.config);
+                        // Tag wallet as 'needs sweep' when balance exceeds sweep threshold
+                        if (current_balance - sweepMinWalletBalanceInWei >= sweepThresholdInWei) {
+                            needs_sweep = true;
+                            entity.updated_at = new Date();
+                        }
+                        entity.balance = current_balance;
+                        entity.needs_sweep = needs_sweep;
+                    }
+                    break;
+                case "remove":
+                    {
+                        const minBalanceInWei = (0, Utility_1.fromDecimal)(blockchain, chainId, paymentToken, sweepMinWalletBalance, this.config);
+                        const { balance: current_balance, decimals } = yield (0, custodial_1.getWalletBalance)(blockchain, chainId, address, paymentToken, this.dbPool, this.config);
+                        // Keep min amount in wallet in case sweep causes balance to be lower than minimum
+                        const deductable = BigInt(current_balance) - amountInWei;
+                        if (deductable < minBalanceInWei) {
+                            amountInWei -= BigInt(sweepMinWalletBalance);
+                        }
+                        entity.balance = BigInt(entity.balance) - BigInt(deductable);
+                    }
+                    break;
+                default:
+                    break;
+            }
+            // Insert sweep job
+            if (needs_sweep) {
+                const sweep_job_service = new SweepJobService_1.default(this.dbPool, this.config);
+                yield sweep_job_service.createSweepJob(userId, blockchain, chainId, address, account.parent_index, account.child_index, paymentToken, relevantTokens[0].decimals, entity.balance);
+            }
+            const updatedEntity = yield dbDriver.balancesRepo.save(entity);
+            return { updatedEntity, wallet: account };
+        });
+    }
+    getNeedsSweepBalances(wallet_id_1, blockchain_1, wallet_address_1) {
+        return __awaiter(this, arguments, void 0, function* (wallet_id, blockchain, wallet_address, is_full_sweep = false) {
+            const dbDriver = this.dbPool;
+            if (!dbDriver.balancesRepo) {
+                throw new Error('Database repository not initialized');
+            }
+            // Get all balances for this wallet
+            const depositBalances = yield dbDriver.balancesRepo.find({
+                where: { wallet_id: wallet_id, blockchain }
+            });
+            // No addresses to sweep
+            if (!depositBalances || depositBalances.length === 0) {
+                return [];
+            }
+            // Get chain manager to check payment tokens and sweep thresholds
+            const chainManager = ChainManager_1.default.getInstance(this.config);
+            // Filter balances that need sweeping
+            const balanceResults = yield Promise.all(depositBalances.map((balance) => __awaiter(this, void 0, void 0, function* () {
+                const { balance: onchain_balance, decimals } = yield (0, custodial_1.getWalletBalance)(blockchain, balance.chain_id, wallet_address, balance.token, this.dbPool, this.config);
+                // Must have positive balance
+                if (!onchain_balance || onchain_balance <= BigInt(0)) {
+                    return null;
+                }
+                if (onchain_balance !== balance.balance) {
+                    this.logger.info(`Balance mismatch between on-chain and off-chain records: onchain: ${onchain_balance.toString()} vs offchain: ${balance.balance}: Wallet:`, { wallet_id, wallet_address, token: balance.token });
+                    balance.balance = onchain_balance;
+                }
+                // Get payment tokens for this chain
+                const paymentTokens = chainManager.getPaymentTokensForChain(parseInt(balance.chain_id));
+                if (!paymentTokens) {
+                    return null;
+                }
+                // Find the specific token config
+                const tokenConfig = paymentTokens.find(token => token.address === balance.token);
+                if (!tokenConfig) {
+                    return null;
+                }
+                const minWalletBalanceInWei = (0, Utility_1.fromDecimal)(blockchain, balance.chain_id, balance.token, tokenConfig.sweepWalletMinBalance, this.config);
+                // Keep tx cost zero, it will be calculated upon sweeping
+                const txCost = BigInt(0);
+                this.logger.info(`Estimated cost for sweep all: ${txCost.toString()}`);
+                let sweepThresholdInWei = BigInt(0);
+                let shouldSweep = false;
+                if (!is_full_sweep) {
+                    sweepThresholdInWei = (0, Utility_1.fromDecimal)(blockchain, balance.chain_id, balance.token, tokenConfig.sweepThreshold, this.config);
+                    shouldSweep = BigInt(onchain_balance) - minWalletBalanceInWei - txCost >= sweepThresholdInWei;
+                }
+                else {
+                    shouldSweep = BigInt(onchain_balance) - txCost >= BigInt(0);
+                }
+                return shouldSweep ? balance : null;
+            })));
+            return balanceResults.filter(r => r !== null);
+        });
+    }
+    deleteBalances(userId, blockchain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const dbDriver = this.dbPool;
+            const accountsService = new DepositAddressService_1.default(this.dbPool);
+            const wallet = yield accountsService.findByUserId(userId, blockchain);
+            return yield ((_a = dbDriver.balancesRepo) === null || _a === void 0 ? void 0 : _a.delete({ wallet_id: wallet.id }));
+        });
+    }
+    getAllBalancesNeedSweep() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dbDriver = this.dbPool;
+            const dataSource = dbDriver.getDataSource();
+            if (!dataSource) {
+                throw new Error(`Database connection is not initialized.`);
+            }
+            return yield dataSource.query(`
+            SELECT 
+                b.wallet_id as "walletId",
+                b.token as "paymentToken",
+                b.blockchain,
+                b.chain_id as "chainId", 
+                w.parent_index as "parentIndex",
+                w.child_index as "childIndex",
+                b.balance,
+                w.address
+            FROM usersmanagement.deposit_wallet_balance b
+            JOIN usersmanagement.deposit_addresses w ON w.id = b.wallet_id  
+            WHERE b.needs_sweep = true
+        `);
+        });
+    }
+    get_available_jobs() {
+        return __awaiter(this, arguments, void 0, function* (limit = 100) {
+            const sweep_job_service = new SweepJobService_1.default(this.dbPool, this.config);
+            const pending_sweep_jobs = yield sweep_job_service.getPendingSweepJobs(limit);
+            return pending_sweep_jobs;
+        });
+    }
+    // Helper method to get token decimals from chain manager
+    getTokenDecimals(chainId, tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const chainManager = ChainManager_1.default.getInstance(this.config);
+            const paymentTokens = chainManager.getPaymentTokensForChain(parseInt(chainId));
+            if (!paymentTokens) {
+                throw new Error(`No payment tokens found for chain ${chainId}`);
+            }
+            const tokenInfo = paymentTokens.find(token => token.address.toLowerCase() === tokenAddress.toLowerCase());
+            if (!tokenInfo) {
+                throw new Error(`Token ${tokenAddress} not found in chain ${chainId} configuration`);
+            }
+            return tokenInfo.decimals;
+        });
+    }
+    // Bulk update balances and needs_sweep flag for successful transfers
+    updateSuccessfulTransfers(successfulTransfers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (successfulTransfers.length === 0) {
+                return;
+            }
+            const sweep_job_service = new SweepJobService_1.default(this.dbPool, this.config);
+            yield sweep_job_service.markMultipleAsSwept(successfulTransfers);
+            this.logger.info(`Successfully updated ${successfulTransfers.length} wallet balances`);
+        });
+    }
+    reflectUpdateInWalletBalances(successfulTransfers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (successfulTransfers.length === 0) {
+                return;
+            }
+            const dbDriver = this.dbPool;
+            const dataSource = dbDriver.getDataSource();
+            if (!dataSource) {
+                throw new Error(`Database connection is not initialized.`);
+            }
+            // First, get all the wallet IDs for the addresses that were swept
+            const addressConditions = successfulTransfers.map(transfer => `(address = '${transfer.address}' AND blockchain = '${transfer.blockchain}')`).join(' OR ');
+            const walletQuery = `
+            SELECT id as wallet_id, address, blockchain
+            FROM usersmanagement.deposit_addresses
+            WHERE ${addressConditions}
+        `;
+            const walletResults = yield dataSource.query(walletQuery);
+            if (!walletResults.length) {
+                this.logger.info('No active deposit addresses found for swept wallets');
+                return;
+            }
+            // Create a map of address to wallet_id for easy lookup
+            const addressToWalletId = new Map(walletResults.map((result) => [`${result.address}-${result.blockchain}`, result.wallet_id]));
+            // Build the VALUES clause for bulk update using the looked up wallet IDs
+            const updateValues = successfulTransfers.flatMap(transfer => {
+                const walletId = addressToWalletId.get(`${transfer.address}-${transfer.blockchain}`);
+                if (!walletId)
+                    return [];
+                return [`(${walletId}, '${transfer.blockchain}', ${transfer.chainId ? `'${transfer.chainId}'` : 'NULL'}, '${transfer.paymentToken}', ${transfer.amountRemaining.toString()}, NOW())`];
+            });
+            if (updateValues.length === 0) {
+                this.logger.info('No balances to update');
+                return;
+            }
+            const query = `
+            UPDATE usersmanagement.deposit_wallet_balance AS b
+            SET 
+                balance = v.new_balance::numeric,
+                updated_at = v.updated_at::timestamp
+            FROM (VALUES ${updateValues.join(', ')}) AS v(wallet_id, blockchain, chain_id, token, new_balance, updated_at)
+            WHERE b.wallet_id = v.wallet_id 
+                AND b.blockchain = v.blockchain 
+                AND (b.chain_id IS NULL AND v.chain_id IS NULL OR b.chain_id = v.chain_id)
+                AND b.token = v.token
+        `;
+            yield dataSource.query(query);
+            this.logger.info(`Successfully updated ${updateValues.length} wallet balances for ${walletResults.length} deposit addresses`);
+        });
+    }
+}
+exports.default = BalanceService;

package/build/services/ChainManager.d.ts

@@ -0,0 +1,86 @@
+import BaseErrors from '../errors/errors';
+import { ChainConfig, ChainId, Chains, ContractDetails, ContractName, NetworkConfig, PaymentToken } from '../interfaces';
+import { TokenTicker } from './types/accounting_service';
+import { BlockchainType } from '../interfaces';
+import { IConfig } from '../interfaces/config';
+import { ContractConfig, CustodialAlchemyWebhookConfig, EscrowAlchemyWebhookConfig } from './types';
+declare class ChainManager extends BaseErrors {
+    private static instance;
+    private networks_file_name;
+    private networks_storage_container_name;
+    private currency_tickers_file_name;
+    private config;
+    contractsMap: ChainConfig | null;
+    rpcs: Map<ChainId, string>;
+    paymentTokenMap: Chains | null;
+    paymentTokenLookup: Map<string, PaymentToken>;
+    isInitialized: boolean;
+    private monitorInstance;
+    private exceptionPrefix;
+    tickerMap: Map<ChainId, TokenTicker>;
+    chainIds: Set<ChainId>;
+    custodialAlchemyWebhooks: CustodialAlchemyWebhookConfig[];
+    escrowAlchemyWebhooks: EscrowAlchemyWebhookConfig[];
+    blockchain_chainid_map: Map<BlockchainType, ChainId[]>;
+    chain_id_blockchain_map: Map<ChainId, BlockchainType>;
+    escrow_contracts: Map<ChainId, ContractDetails>;
+    chainsRequireAlchemyAddressActivity: ChainId[];
+    private funding_wallets;
+    private treasury_receivers;
+    contractsLastUpdated: number;
+    private syncContractsTimeout;
+    private syncContractsInterval;
+    private updateContractsInterval;
+    private logger;
+    private constructor();
+    static getInstance(config: IConfig): ChainManager;
+    initialize(): Promise<void>;
+    startSyncingContracts(): Promise<void>;
+    private checkAndUpdateContracts;
+    getContractStartingBlock(chainId: number, contractType: ContractName): number;
+    getPaymentTokenMapForChain(chainId: number): NetworkConfig | null | undefined;
+    getPaymentTokensForChain(chainId: number): PaymentToken[] | null | undefined;
+    getContractsMapForChain(chainId: number): NetworkConfig | null;
+    getContractsForChain(chainId: number): Promise<ContractConfig[] | null>;
+    /**
+     * Gets the chain (network) configuration from local cache
+     * @param chainId
+     * @returns NetworkConfig | null. Null if config is not found or not loaded from storage service
+     */
+    getChainConfigForChainIdSync(chainId: number): NetworkConfig | null;
+    /**
+     * Synchronous call. Fetches the config from cache.
+     * @param chainId
+     * @returns ContractConfig. Throws error if config is not loaded yet from storage source or not found
+     */
+    getEscrowContractForChain(chainId: number): ContractConfig;
+    /**
+     * Asynchronous call. Refetches the config from storage source
+     * @param chainId
+     * @returns ContractConfig containing list of `addresses` for available escrow contracts
+     */
+    getEscrowContractForChainAsync(chainId: number): Promise<ContractConfig>;
+    get_payment_token_for_chain(blockchain: BlockchainType, chain_id: ChainId, token: string): PaymentToken;
+    get_ticker_for_chain(chain_id: ChainId): TokenTicker;
+    get_treasury_config_for_chain(chain_id: ChainId): import("./types").ChainAccountingDetails;
+    get_blockchain_for_chain_id(chain_id: ChainId): BlockchainType;
+    get_chain_ids_for_blockchain(blockchain: BlockchainType): string[];
+    get_active_chain_ids_for_blockchain(blockchain: BlockchainType): string[];
+    get_funding_wallet_by_chainid(chain_id: ChainId): string | undefined;
+    get_treasury_wallet_by_chainid(chain_id: ChainId): string | undefined;
+    is_exists_chain_id(chain_id: ChainId, blockchain: BlockchainType): boolean;
+    is_exists_blockchain(blockchain: BlockchainType): boolean;
+    readContractsMap(): Promise<ChainConfig>;
+    readChainIds(): Promise<void>;
+    readTickersMap(): Promise<Map<string, TokenTicker>>;
+    readAlchemyWebhookConfig(): Promise<void>;
+    readAccountingConfig(): Promise<void>;
+    get_lookup_token_key(chain_id: ChainId, token_address: string): string;
+    get_payment_token_if_exists(chain_id: ChainId, token_address: string): PaymentToken | null | undefined;
+    get_rpc_by_chainid(chain_id: ChainId): string;
+    readPaymentTokenMap(): Promise<Chains | undefined>;
+    readEscrowContracts(): Promise<void>;
+    readRpcUrls(): Promise<void>;
+}
+export default ChainManager;
+//# sourceMappingURL=ChainManager.d.ts.map

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

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