@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/services/WithdrawalManager.js

@@ -0,0 +1,372 @@
+"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 web3_js_1 = require("@solana/web3.js");
+// import { ServerConfig } from "../config/server-config";
+const TransactionsErrors_1 = __importDefault(require("../errors/TransactionsErrors"));
+const WalletManager_1 = __importDefault(require("./WalletManager"));
+const custodial_1 = require("../utils/custodial");
+const AccountingService_1 = __importDefault(require("./AccountingService"));
+const ClaimJobService_1 = __importDefault(require("./ClaimJobService"));
+const ChainManager_1 = __importDefault(require("./ChainManager"));
+const ethers_1 = require("ethers");
+const ProviderManager_1 = __importDefault(require("./ProviderManager"));
+const Escrow_1 = __importDefault(require("../contracts/Escrow"));
+const Wallets_1 = require("../utils/Wallets");
+const Utility_1 = require("../utils/Utility");
+const constants_1 = require("../constants");
+class WithdrawalManager extends TransactionsErrors_1.default {
+    constructor(dbPool, config) {
+        super();
+        this.handle_get_withdraw_request = (id) => __awaiter(this, void 0, void 0, function* () {
+            const accounting = new AccountingService_1.default(this.dbPool, this.config);
+            return accounting.get_crypto_withdrawal_request(id);
+        });
+        // TODO : Implement check for withdraw request
+        this.get_withdraw_request = (id) => __awaiter(this, void 0, void 0, function* () {
+            const withdraw_request = yield this.handle_get_withdraw_request(id);
+            if (!withdraw_request)
+                throw new Error(this.NotExistWithdrawRequest());
+            return withdraw_request;
+        });
+        // Check if receiver address is the same one used for the deposit
+        this.is_source_address = (user_id, address, blockchain) => __awaiter(this, void 0, void 0, function* () {
+            const accounting_service = new AccountingService_1.default(this.dbPool, this.config);
+            const is_valid_address = yield accounting_service.deposit_address_exists_by_user(user_id, address, blockchain);
+            return is_valid_address;
+        });
+        // Calls the escrow contract to check if the request id is fulfilled
+        this.is_available_request_id = (request_id, chain_id) => __awaiter(this, void 0, void 0, function* () {
+            const escrow_config = yield ChainManager_1.default.getInstance(this.config).getEscrowContractForChain(parseInt(chain_id));
+            const provider = ProviderManager_1.default.getInstance(this.config).getNewProvider(chain_id);
+            const funds_manager = WalletManager_1.default.getInstance(this.config, this.dbPool).getEscrowFundsManagerWallet("evm");
+            // TODO remove signer from here
+            const escrow_manager = new Escrow_1.default(escrow_config.addresses[0], provider.provider, funds_manager.connect(provider.provider));
+            const used_ids = yield escrow_manager.get_used_request_ids([request_id]);
+            if (used_ids.length > 0)
+                return false;
+            return true;
+        });
+        this.estimate_batch_withdraw_cost = (blockchain, chain_id, queue) => __awaiter(this, void 0, void 0, function* () {
+            if (blockchain !== "solana" && blockchain !== "evm")
+                throw new Error();
+            if (queue.length === 0)
+                return { estimation_map: new Map(), updated_queue: [] };
+            const accounting = new AccountingService_1.default(this.dbPool, this.config);
+            // Get native token price in usdt
+            const token_price = yield (0, Utility_1.retryWithExponentialBackoff)(() => accounting.get_crypto_rate(chain_id));
+            // Estimate total transaction cost with batch withdrawal
+            const { estimate, tx_count } = yield this.get_estimate_for_batch(blockchain, chain_id, queue);
+            const { estimation_map, updated_queue } = this.calculate_estimate_for_user(blockchain, token_price, estimate, tx_count, queue);
+            return { estimation_map, updated_queue };
+        });
+        // Estimates the cost to be paid by the user when their transaction is included in a batch withdrawal
+        this.estimate_cost_for_user = (blockchain, chain_id, receiver, token, display_currency, user_id) => __awaiter(this, void 0, void 0, function* () {
+            if (blockchain !== constants_1.BLOCKCHAINS.SOLANA && blockchain !== constants_1.BLOCKCHAINS.EVM && blockchain !== constants_1.BLOCKCHAINS.TRON)
+                throw new Error();
+            // // TODO remove this dummy return
+            // if (blockchain === BLOCKCHAINS.TRON) {
+            //     return {
+            //         estimate_units: Number(0),
+            //         estimate_in_decimals: 0,
+            //         estimate_in_usdt: 0,
+            //         estimate_in_usdt_decimals: 0,
+            //         token_price: 0,
+            //         estimate_in_usdt_precision: 0
+            //     }
+            // }
+            const accounting = new AccountingService_1.default(this.dbPool, this.config);
+            // Get max batch size based on blockchain type
+            const max_batch_size = blockchain === "evm" ? this.config.serverConfig.maxTransactionsPerTxEvm : this.config.serverConfig.maxInstructionsPerTxSolana;
+            // Get withdrawal requests in queue
+            const recent_queue = yield this.claim_jobs_service.get_next_queued_jobs(blockchain, chain_id, max_batch_size);
+            // Validate token
+            const target_token = ChainManager_1.default.getInstance(this.config).get_payment_token_for_chain(blockchain, chain_id, token);
+            if ((0, Wallets_1.normalizeAddress)(target_token.address, blockchain) !== (0, Wallets_1.normalizeAddress)(token, blockchain))
+                throw new Error(this.UnexpectedPaymentToken());
+            // Estimate total transaction cost with batch withdrawal
+            const { estimate, estimate_decimals, tx_count } = yield this.get_estimate_for_batch(blockchain, chain_id, recent_queue, { token, receiver, user_id });
+            // Handle no user
+            if (estimate === BigInt(0))
+                return {
+                    estimate_units: Number(0),
+                    estimate_in_decimals: 0,
+                    estimate_in_usdt: 0,
+                    estimate_in_usdt_decimals: 0,
+                    token_price: 0,
+                    estimate_in_usdt_precision: 0
+                };
+            // Get native token price in usdt
+            const token_price = yield accounting.get_crypto_rate(chain_id);
+            if (blockchain === constants_1.BLOCKCHAINS.TRON) {
+                const estimate_usdt_decimals = Number((estimate_decimals * token_price).toPrecision(5));
+                const display_exchange_rate = yield accounting.convert_amount_to_currency(estimate_usdt_decimals, "USD", display_currency);
+                // Return user estimation
+                return {
+                    estimate_units: Number(estimate),
+                    estimate_in_decimals: estimate_decimals,
+                    estimate_in_usdt: (0, ethers_1.parseUnits)(estimate_usdt_decimals.toString(), 6),
+                    estimate_in_usdt_decimals: display_exchange_rate,
+                    token_price,
+                    estimate_in_usdt_precision: estimate_usdt_decimals
+                };
+            }
+            else {
+                // Calculate payable cost for user
+                const { estimation_map, user_cost } = this.calculate_estimate_for_user(blockchain, token_price, estimate, tx_count, recent_queue);
+                const display_exchange_rate = yield accounting.convert_amount_to_currency(user_cost.estimate_in_usdt_decimals, "USD", display_currency);
+                // Return user estimation
+                return {
+                    estimate_units: Number(user_cost.estimate_units),
+                    estimate_in_decimals: user_cost.estimate_in_decimals,
+                    estimate_in_usdt: user_cost.estimate_in_usdt,
+                    // estimate_in_usdt_decimals: user_estimate.estimate_in_usdt_decimals,
+                    estimate_in_usdt_decimals: display_exchange_rate,
+                    token_price,
+                    estimate_in_usdt_precision: user_cost.estimate_in_usdt_decimals
+                };
+            }
+        });
+        // TODO: CHECK THIS LOGIC
+        this.get_estimate_for_batch = (blockchain, chain_id, queue, extra_config) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Get funds manager wallet
+            // TODO remove signer from here
+            const funds_manager = WalletManager_1.default.getInstance(this.config, this.dbPool).getEscrowFundsManagerWallet(blockchain);
+            if (blockchain === 'solana') {
+                const user_count = queue.length === 0 ? 1 : queue.length;
+                return { estimate: BigInt(5000), estimate_decimals: Number(ethers_1.ethers.formatUnits(5000, 9)), tx_count: user_count };
+            }
+            else if (blockchain === "evm") {
+                // Build evm batch withdraw payload
+                const payloads = queue.map(j => ({
+                    amount_in_tokens: j.amount,
+                    requestId: j.request_id,
+                    token: j.token,
+                    receiver: j.receiver
+                }));
+                // In case queue is empty, push a mock tx for gas estimation only
+                // amount_in_tokens = 1 (minimum unit) to avoid triggering balance checks in the contract
+                if (payloads.length === 0 && (extra_config === null || extra_config === void 0 ? void 0 : extra_config.token)) {
+                    payloads.push({
+                        amount_in_tokens: BigInt(1),
+                        requestId: 0,
+                        token: extra_config.token,
+                        receiver: funds_manager.address
+                    });
+                }
+                // Estimate cost to call `batch_withdraw`
+                const transaction_cost = yield (0, custodial_1.estimate_escrow_method_call_cost)(chain_id, payloads, this.dbPool, this.config);
+                return { estimate: transaction_cost, estimate_decimals: Number(ethers_1.ethers.formatEther(transaction_cost)), tx_count: payloads.length };
+            }
+            // Implement tron estimation
+            else if (blockchain === constants_1.BLOCKCHAINS.TRON) {
+                const tronFeeConfig = (_a = ChainManager_1.default.getInstance(this.config).getChainConfigForChainIdSync(parseInt(chain_id))) === null || _a === void 0 ? void 0 : _a.tronConfig;
+                if (!tronFeeConfig) {
+                    return { estimate: BigInt(0), estimate_decimals: 0, tx_count: queue.length };
+                }
+                if ((extra_config === null || extra_config === void 0 ? void 0 : extra_config.token) && (extra_config.token === ethers_1.ethers.ZeroAddress.slice(2) || extra_config.token === ethers_1.ethers.ZeroAddress) || (extra_config === null || extra_config === void 0 ? void 0 : extra_config.token) === 'TRX') {
+                    return { estimate: BigInt(tronFeeConfig.trxTransferCost), estimate_decimals: Number(ethers_1.ethers.formatUnits(tronFeeConfig.trxTransferCost, 6)), tx_count: 1 };
+                }
+                else {
+                    return { estimate: BigInt(tronFeeConfig.trc20TransferCost), estimate_decimals: Number(ethers_1.ethers.formatUnits(tronFeeConfig.trc20TransferCost, 6)), tx_count: 1 };
+                }
+            }
+            else
+                throw new Error(this.UnsupportedResource("Blockchain type"));
+        });
+        // Calculates the average cost per transaction in a batch
+        // Returns parsed estimation (decimals, units,..)
+        // TODO: CHECK THIS LOGIC
+        this.calculate_cost_per_job = (blockchain, token_price, total_fee, job_count) => {
+            const user_estimate = BigInt(total_fee) / BigInt(job_count);
+            let estimate_in_decimals = 0;
+            if (blockchain === "evm") {
+                estimate_in_decimals = parseFloat((0, ethers_1.formatEther)(user_estimate.toString()));
+            }
+            else if (blockchain === "solana") {
+                estimate_in_decimals = parseFloat((0, ethers_1.formatUnits)(user_estimate, 9));
+            }
+            else
+                throw new Error(this.UnsupportedResource(`Blockchain ${blockchain}`));
+            let estimate_in_usdt_decimals = token_price * estimate_in_decimals;
+            let estimate_in_usdt_wei = (0, ethers_1.parseUnits)(estimate_in_usdt_decimals.toFixed(5), 6);
+            // Discard fee if less than threshold
+            if (Number(estimate_in_usdt_decimals) < Number(this.config.serverConfig.minPayableWithdrawalFee)) {
+                let estimation = {
+                    user_job_count: 1,
+                    estimate_units: BigInt(0),
+                    estimate_in_decimals: 0,
+                    estimate_in_usdt: BigInt(0),
+                    estimate_in_usdt_decimals: 0,
+                    token_price
+                };
+                return estimation;
+            }
+            let estimation = {
+                user_job_count: 1,
+                estimate_units: user_estimate,
+                estimate_in_decimals,
+                estimate_in_usdt: estimate_in_usdt_wei,
+                estimate_in_usdt_decimals: estimate_in_usdt_decimals,
+                token_price
+            };
+            return estimation;
+        };
+        // Given a queue of jobs, calculates each user's share of the batch cost
+        // Returns mapping of userid to total cost and a queue with adjusted amounts
+        this.calculate_estimate_for_user = (blockchain, token_price, total_fee, tx_count, queue) => {
+            // Userid to estimation map
+            const user_map = new Map();
+            const user_cost = this.calculate_cost_per_job(blockchain, token_price, total_fee, tx_count);
+            // Calculate cost per unit = total_fee / tx_count (user_job_count is always 1 in calculate_cost_per_job)
+            const unit_cost = BigInt(user_cost.estimate_units) / BigInt(user_cost.user_job_count);
+            // Calculate new amounts including the payable fee
+            const updated_queue = queue.map(j => {
+                if (blockchain === constants_1.BLOCKCHAINS.SOLANA) {
+                    // Solana native token
+                    if (new web3_js_1.PublicKey(j.token).toBase58() === web3_js_1.SystemProgram.programId.toBase58()) {
+                        // Intentional in-place mutation: mutates the original ClaimJobs object so spread picks up the updated amount
+                        if (unit_cost < BigInt(j.amount))
+                            j.amount = BigInt(j.amount) - unit_cost;
+                        // TODO: Drop this job since the cost is higher than amount
+                        return Object.assign(Object.assign({}, j), { fee_data: user_cost });
+                    }
+                    else {
+                        // SPL token
+                        return this.parse_cost_stable_coin(blockchain, user_cost, j, unit_cost, token_price);
+                    }
+                }
+                else if (blockchain === constants_1.BLOCKCHAINS.EVM) {
+                    // Directly deduct from native amount
+                    if (j.token === ethers_1.ethers.ZeroAddress) {
+                        // Intentional in-place mutation: mutates the original ClaimJobs object so spread picks up the updated amount
+                        if (unit_cost < BigInt(j.amount))
+                            j.amount = BigInt(j.amount) - unit_cost;
+                        return Object.assign(Object.assign({}, j), { fee_data: user_cost });
+                    }
+                    else {
+                        // ERC20
+                        return this.parse_cost_stable_coin(blockchain, user_cost, j, unit_cost, token_price);
+                    }
+                }
+                else
+                    throw new Error(this.UnsupportedResource(`blockchain ${blockchain}`));
+            });
+            // Populate estimation_map: aggregate per-user total cost (user may have multiple jobs)
+            const user_job_counts = new Map();
+            queue.forEach(j => { var _a; return user_job_counts.set(j.user_id, ((_a = user_job_counts.get(j.user_id)) !== null && _a !== void 0 ? _a : 0) + 1); });
+            for (const [uid, count] of user_job_counts.entries()) {
+                user_map.set(uid, {
+                    user_job_count: count,
+                    estimate_units: user_cost.estimate_units * BigInt(count),
+                    estimate_in_decimals: user_cost.estimate_in_decimals * count,
+                    estimate_in_usdt: user_cost.estimate_in_usdt * BigInt(count),
+                    estimate_in_usdt_decimals: user_cost.estimate_in_usdt_decimals * count,
+                    token_price
+                });
+            }
+            return { estimation_map: user_map, updated_queue, user_cost };
+        };
+        this.parse_cost_stable_coin = (blockchain, user_cost, job, unit_cost, token_price) => {
+            // Calculate value in usdt to deduct
+            const native_decimals = blockchain === 'evm' ? 18 : 9;
+            const unit_cost_decimals = (0, ethers_1.formatUnits)(unit_cost, native_decimals);
+            const cost_in_usdt = parseFloat((0, ethers_1.formatUnits)(unit_cost, native_decimals)) * token_price;
+            const cost_in_usdt_truncated = cost_in_usdt.toFixed(5);
+            const cost_in_usdt_wei = (0, ethers_1.parseUnits)(cost_in_usdt_truncated.toString(), job.decimals);
+            if (BigInt(cost_in_usdt_wei) < BigInt(job.amount)) {
+                const new_amount = BigInt(job.amount) - BigInt(cost_in_usdt_wei);
+                job.amount = new_amount;
+            }
+            return Object.assign(Object.assign({}, job), { fee_data: Object.assign(Object.assign({}, user_cost), { estimate_in_usdt: cost_in_usdt_wei, estimate_in_usdt_decimals: parseFloat(cost_in_usdt_truncated), estimate_units: unit_cost, estimate_in_decimals: parseFloat(unit_cost_decimals) }) });
+        };
+        this.calculate_estimate_for_user_deprecated = (blockchain, token_price, user_ids, total_fee, tx_count, queue) => {
+            let estimate_in_decimals = 0;
+            // Userid to estimation map
+            const user_map = new Map();
+            for (let user_id of user_ids) {
+                // Filter out jobs belonging to this user id
+                const user_job_count = queue.filter(j => j.user_id === user_id).length || 1;
+                const user_estimate = BigInt(total_fee) * BigInt(user_job_count) / BigInt(tx_count);
+                if (blockchain === "evm") {
+                    estimate_in_decimals = parseFloat((0, ethers_1.formatEther)(user_estimate.toString()));
+                }
+                else if (blockchain === "solana") {
+                    estimate_in_decimals = parseFloat((0, ethers_1.formatUnits)(user_estimate, 9));
+                }
+                else
+                    throw new Error(this.UnsupportedResource(`Blockchain ${blockchain}`));
+                let estimate_in_usdt_decimals = token_price * estimate_in_decimals;
+                let estimate_in_usdt_wei = (0, ethers_1.parseUnits)(estimate_in_usdt_decimals.toFixed(5), 6);
+                // Discard fee if less than threshold
+                if (Number(estimate_in_usdt_decimals) < Number(this.config.serverConfig.minPayableWithdrawalFee)) {
+                    let estimation = {
+                        user_job_count,
+                        estimate_units: BigInt(0),
+                        estimate_in_decimals: 0,
+                        estimate_in_usdt: BigInt(0),
+                        estimate_in_usdt_decimals: 0,
+                        token_price
+                    };
+                    user_map.set(user_id, estimation);
+                    continue;
+                }
+                let estimation = {
+                    user_job_count,
+                    estimate_units: user_estimate,
+                    estimate_in_decimals,
+                    estimate_in_usdt: estimate_in_usdt_wei,
+                    estimate_in_usdt_decimals: estimate_in_usdt_decimals,
+                    token_price
+                };
+                user_map.set(user_id, estimation);
+            }
+            // Calculate new amounts including the payable fee
+            const updated_queue = queue.map(j => {
+                const user_cost = user_map.get(j.user_id);
+                const native_decimals = blockchain === 'evm' ? 18 : 9;
+                // TODO: Handle error
+                if (!user_cost)
+                    throw new Error();
+                // Calculate cost on avg in native tokens
+                const unit_cost = BigInt(user_cost.estimate_units) / BigInt(user_cost.user_job_count);
+                const unit_cost_decimals = (0, ethers_1.formatUnits)(unit_cost, native_decimals);
+                // Directly deduct form native amount
+                if (j.token === ethers_1.ethers.ZeroAddress) {
+                    if (unit_cost < BigInt(j.amount)) {
+                        j.amount = BigInt(j.amount) - unit_cost;
+                    }
+                    return Object.assign(Object.assign({}, j), { fee_data: user_cost });
+                }
+                else {
+                    // Calculate value in usdt to deduct
+                    const cost_in_usdt = parseFloat((0, ethers_1.formatUnits)(unit_cost, native_decimals)) * token_price;
+                    const cost_in_usdt_truncated = cost_in_usdt.toFixed(5);
+                    const cost_in_usdt_wei = (0, ethers_1.parseUnits)(cost_in_usdt_truncated.toString(), j.decimals);
+                    if (BigInt(cost_in_usdt_wei) < BigInt(j.amount)) {
+                        const new_amount = BigInt(j.amount) - BigInt(cost_in_usdt_wei);
+                        j.amount = new_amount;
+                    }
+                    return Object.assign(Object.assign({}, j), { fee_data: Object.assign(Object.assign({}, user_cost), { estimate_in_usdt: cost_in_usdt_wei, estimate_in_usdt_decimals: parseFloat(cost_in_usdt_truncated), estimate_units: unit_cost, estimate_in_decimals: parseFloat(unit_cost_decimals) }) });
+                }
+            });
+            return { estimation_map: user_map, updated_queue };
+        };
+        this.dbPool = dbPool;
+        this.claim_jobs_service = new ClaimJobService_1.default(this.dbPool);
+        this.config = config;
+    }
+}
+exports.default = WithdrawalManager;

package/build/services/Worker.d.ts

@@ -0,0 +1,25 @@
+import BaseErrors from '../errors/errors';
+interface RunningProcess {
+    pid: number;
+    start_timestamp: number;
+    start_date: Date;
+}
+declare class Worker extends BaseErrors {
+    private cronJob;
+    private task;
+    private schedule;
+    private is_executing;
+    private allow_parallel_execution;
+    private current_task;
+    worker_name: string;
+    private logger;
+    constructor(schedule: string, allow_parallel_execution: boolean | undefined, task: () => Promise<void>, name?: string);
+    start: () => void;
+    stop: () => void;
+    private handle_process;
+    private add_process;
+    private remove_process;
+    get_processes: () => RunningProcess | null;
+}
+export default Worker;
+//# sourceMappingURL=Worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Worker.d.ts","sourceRoot":"","sources":["../../src/services/Worker.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAG1C,UAAU,cAAc;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,IAAI,CAAC;CACpB;AAED,cAAM,MAAO,SAAQ,UAAU;IAC3B,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,IAAI,CAAC;IACb,OAAO,CAAC,QAAQ,CAAC;IACjB,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,wBAAwB,CAAkB;IAClD,OAAO,CAAC,YAAY,CAAwB;IAErC,WAAW,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,MAAM,CAAS;gBACX,QAAQ,EAAE,MAAM,EAAE,wBAAwB,EAAE,OAAO,YAAQ,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,GAAE,MAAiB;IAWpH,KAAK,aAWX;IAGM,IAAI,aAOV;IAGD,OAAO,CAAC,cAAc,CAoBrB;IAED,OAAO,CAAC,WAAW,CAGlB;IAED,OAAO,CAAC,cAAc,CAErB;IAEM,aAAa,8BAEnB;CAGJ;AAED,eAAe,MAAM,CAAC"}

package/build/services/Worker.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 cron = __importStar(require("node-cron"));
+const errors_1 = __importDefault(require("../errors/errors"));
+const Logger_1 = require("../utils/Logger");
+class Worker extends errors_1.default {
+    constructor(schedule, allow_parallel_execution = false, task, name = "worker") {
+        super();
+        this.cronJob = null;
+        this.is_executing = false;
+        this.allow_parallel_execution = false;
+        // Default scheduled every 10 seconds
+        this.start = () => {
+            if (!this.schedule)
+                throw new Error(`${this.worker_name}: Worker is not initialized`);
+            if (this.cronJob) {
+                this.logger.info(`${this.worker_name}: Worker already running.`);
+                throw new Error(`${this.worker_name}: Worker already running`);
+            }
+            this.cronJob = cron.schedule(this.schedule, () => __awaiter(this, void 0, void 0, function* () { return yield this.handle_process(); }), { timezone: 'UTC' });
+            this.cronJob.start();
+            this.logger.info(`${this.worker_name}: Worker schedueler started.`);
+            return;
+        };
+        // Deschedule cron
+        this.stop = () => {
+            if (this.cronJob) {
+                this.cronJob.stop();
+                this.cronJob.destroy();
+                this.cronJob = null;
+                this.logger.info(`${this.worker_name}: Worker cron job stopped`);
+            }
+        };
+        this.handle_process = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (this.is_executing && !this.allow_parallel_execution) {
+                    this.logger.info(`${this.worker_name}: Previous worker process still running. Skipping...`);
+                    return;
+                }
+                this.is_executing = true;
+                this.add_process(process.pid);
+                yield this.task();
+            }
+            catch (error) {
+                this.logger.error(`${this.worker_name}: Error during scheduled task:`, { data: { error } });
+            }
+            finally {
+                this.remove_process();
+                this.is_executing = false;
+            }
+        });
+        this.add_process = (pid) => {
+            const now = new Date();
+            this.current_task = { pid, start_timestamp: now.getTime(), start_date: now };
+        };
+        this.remove_process = () => {
+            this.current_task = null;
+        };
+        this.get_processes = () => {
+            return this.current_task;
+        };
+        this.worker_name = name;
+        this.schedule = schedule;
+        this.task = task;
+        this.allow_parallel_execution = allow_parallel_execution;
+        this.current_task = null;
+        this.logger = (0, Logger_1.createLogger)(`Worker`, `Worker`);
+    }
+}
+exports.default = Worker;

package/build/services/solana/escrow/SolanaEscrowAdmin.d.ts

@@ -0,0 +1,102 @@
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+import * as anchor from "@coral-xyz/anchor";
+import { Escrow } from "./types/escrow";
+import { BatchReceiver, SignAllTransactionsInterface, SignTransactionInterface } from "./types/types";
+interface AdditionalConstructorParams {
+    signer_keypair?: Keypair;
+    localnet: boolean;
+}
+declare class SolanaEscrowAdmin {
+    provider: anchor.AnchorProvider;
+    program: anchor.Program<Escrow>;
+    private adminUtility;
+    private signer?;
+    connection: Connection;
+    constructor(escrowAddress: string, walletPublicKey: PublicKey, signTransaction: SignTransactionInterface, signAllTransactions: SignAllTransactionsInterface, chainId: string, additionalParams?: AdditionalConstructorParams);
+    /**
+     *
+     * @returns anchor.Idl - the escrowprogram's Idl file
+     */
+    private get_idl;
+    /**
+     *
+     * @returns User's withdrawal nonce count
+     */
+    get_withdraw_nonce: () => Promise<number>;
+    /**
+     * Checks the state of the program (paused/unpaused)
+     * @returns true/false - True for paused, false for unpaused
+     */
+    is_paused: () => Promise<boolean>;
+    /**
+     * Checks if the wallet is an admin
+     * @param wallet_address Target wallet to check
+     * @returns
+     */
+    is_admin: (wallet_address: string) => Promise<boolean>;
+    /**
+     * Checks if the token is an accepted payment token
+     * @param token_address
+     * @returns
+     */
+    is_payment_token: (token_address: string) => Promise<boolean>;
+    get_balances: () => Promise<[string, number][]>;
+    /**
+     * Gets the payment tokens list
+     * @returns string[]
+     */
+    get_payment_tokens: () => Promise<string[]>;
+    /**
+     * Get admins
+     * @returns string[]
+     */
+    get_admins: () => Promise<string[]>;
+    /**
+     * Adds a token to the payment token list
+     * @param token_address
+     * @returns
+     */
+    add_payment_token: (token_address: string) => Promise<string>;
+    /**
+     * Remove a token from the payment token list
+     * @param token_address
+     * @returns
+     */
+    remove_payment_token: (token_address: string) => Promise<string>;
+    /**
+     * Give the admin role to a wallet
+     * @param wallet_address
+     * @returns string - transaction signature
+     */
+    add_admin: (wallet_address: string) => Promise<string>;
+    /**
+     * Remove the admin role from a wallet
+     * @param wallet_address
+     * @returns string - transaction signature
+     */
+    remove_admin: (wallet_address: string) => Promise<string>;
+    /**
+     * Pause/unpause the program state
+     * @param target_state
+     * @returns string - transaction signature
+     */
+    set_pause_state: (target_state: boolean) => Promise<string>;
+    withdraw_batch: (token_address: string, receivers: BatchReceiver[]) => Promise<string>;
+    /**
+     *
+     * @param token_address Address of the token to withdraw
+     * @param amount_in_decimals amount in human readable decimal format. eg. 0.1SOL
+     * @param receiver_address Wallet address of the receiver
+     * @returns string - transaction signature
+     */
+    withdraw: (token_address: string, amount_in_decimals: number, receiver_address: string) => Promise<string | undefined>;
+    /**
+     *
+     * @param token_address Address of the token to deposit
+     * @param amount_in_decimals Amount in human readable decimal format. eg 0.1SOL
+     * @returns string - transaction signature
+     */
+    deposit: (token_address: string, amount_in_decimals: number) => Promise<string>;
+}
+export default SolanaEscrowAdmin;
+//# sourceMappingURL=SolanaEscrowAdmin.d.ts.map

package/build/services/solana/escrow/SolanaEscrowAdmin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolanaEscrowAdmin.d.ts","sourceRoot":"","sources":["../../../../src/services/solana/escrow/SolanaEscrowAdmin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAqC,MAAM,iBAAiB,CAAC;AAEpG,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAE5C,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAExC,OAAO,EAAE,aAAa,EAAE,4BAA4B,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAkBtG,UAAU,2BAA2B;IACjC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;CACrB;AAED,cAAM,iBAAiB;IACZ,QAAQ,EAAE,MAAM,CAAC,cAAc,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACvC,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,MAAM,CAAC,CAAU;IAClB,UAAU,EAAE,UAAU,CAAC;gBAG1B,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,SAAS,EAC1B,eAAe,EAAE,wBAAwB,EACzC,mBAAmB,EAAE,4BAA4B,EACjD,OAAO,EAAE,MAAM,EACf,gBAAgB,CAAC,EAAE,2BAA2B;IA8BlD;;;OAGG;IACH,OAAO,CAAC,OAAO,CAGb;IAEF;;;OAGG;IACI,kBAAkB,wBAGvB;IAKF;;;OAGG;IACI,SAAS,yBAEf;IAED;;;;OAIG;IACI,QAAQ,GAAU,gBAAgB,MAAM,sBAE9C;IAED;;;;OAIG;IACI,gBAAgB,GAAU,eAAe,MAAM,sBAErD;IAEM,YAAY,oCAElB;IAGD;;;OAGG;IACI,kBAAkB,0BAExB;IAED;;;OAGG;IACI,UAAU,0BAEhB;IAED;;;;OAIG;IACI,iBAAiB,GAAU,eAAe,MAAM,qBAEtD;IAED;;;;OAIG;IACI,oBAAoB,GAAU,eAAe,MAAM,qBAEzD;IAED;;;;OAIG;IACI,SAAS,GAAU,gBAAgB,MAAM,qBAE/C;IAGD;;;;OAIG;IACI,YAAY,GAAU,gBAAgB,MAAM,qBAElD;IAED;;;;OAIG;IACI,eAAe,GAAU,cAAc,OAAO,qBAEpD;IAIM,cAAc,GAAU,eAAe,MAAM,EAAE,WAAW,aAAa,EAAE,qBAE/E;IAGD;;;;;;OAMG;IACI,QAAQ,GAAU,eAAe,MAAM,EAAE,oBAAoB,MAAM,EAAE,kBAAkB,MAAM,iCAEnG;IAED;;;;;OAKG;IACI,OAAO,GAAU,eAAe,MAAM,EAAE,oBAAoB,MAAM,qBAExE;CAKJ;AAED,eAAe,iBAAiB,CAAC"}