@ercworldio/blockchain-shared 1.0.0-dev.10

package/build/services/ClaimJobService.js

@@ -0,0 +1,407 @@
+"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 ClaimJob_1 = require("../entities/ClaimJob");
+const typeorm_1 = require("typeorm");
+const TransactionsErrors_1 = __importDefault(require("../errors/TransactionsErrors"));
+const ClaimHistoryService_1 = __importDefault(require("./ClaimHistoryService"));
+const uuid_1 = require("uuid");
+const constants_1 = require("../constants");
+class ClaimJobsService {
+    constructor(dbPool) {
+        this.errors = new TransactionsErrors_1.default();
+        this.get_repo = () => {
+            const repo = this.dbPool.claimRequestRepo;
+            if (!repo)
+                throw new Error("App data source is not initialized.");
+            return repo;
+        };
+        this.get_history_repo = () => {
+            const repo = this.dbPool.claimHistoryRepo;
+            if (!repo)
+                throw new Error("App data source is not initialized.");
+            return repo;
+        };
+        this.paginate = (page, page_size, filters) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            if (page === 0)
+                page = 1;
+            // Use separate queries to avoid TypeORM findAndCount issues
+            const [items, totalCount] = yield Promise.all([
+                repo.find({
+                    take: page_size,
+                    skip: (page - 1) * page_size,
+                    where: Object.assign({}, filters),
+                    order: { created_at: "DESC" }
+                }),
+                repo.count({ where: Object.assign({}, filters) })
+            ]);
+            return {
+                total_count: totalCount,
+                pages_count: Math.ceil(totalCount / page_size),
+                has_next: totalCount > page * page_size,
+                current_page: page,
+                items: items || []
+            };
+        });
+        this.get_available_jobs = (...args_1) => __awaiter(this, [...args_1], void 0, function* (limit = 10, job_ttl_s = 120, lock_metadata = { lock_owner: "claim-worker", lock_reason: "process_queued" }) {
+            const repo = this.get_repo();
+            const ttlSeconds = job_ttl_s;
+            const batchGroupId = (0, uuid_1.v4)();
+            const rows = yield repo.query(`
+  WITH candidates AS (
+    SELECT id
+    FROM accounting.claim_jobs
+    WHERE job_status = 'queued'
+      AND (lock_expires_at IS NULL OR lock_expires_at < now())
+    ORDER BY blockchain, chain_id ASC
+    LIMIT $1
+    FOR UPDATE SKIP LOCKED
+  )
+  UPDATE accounting.claim_jobs cj
+  SET
+    job_status = 'processing',
+    locked_at = now(),
+    lock_expires_at = now() + ($2 || ' seconds')::interval,
+    batch_group_id = $3,
+    metadata = jsonb_set(
+                    jsonb_set(
+                        coalesce(cj.metadata, '{}'::jsonb),
+                        '{lock_owner}',
+                        to_jsonb($4::text)
+                    ),
+                    '{lock_reason}',
+                    to_jsonb($5::text)
+                ),
+    updated_at = now()
+  FROM candidates c
+  WHERE cj.id = c.id
+  RETURNING cj.*;
+  `, [limit, ttlSeconds, batchGroupId, lock_metadata.lock_owner, lock_metadata.lock_reason]);
+            return rows[0];
+        });
+        this.requeue_expired_jobs = (current_status, ttl_seconds, limit, lock_owner, lock_reason, max_retries) => __awaiter(this, void 0, void 0, function* () {
+            const rows = yield this.get_repo().query(`
+    WITH expired AS (
+      SELECT id
+      FROM accounting.claim_jobs
+      WHERE job_status = $4
+        AND lock_expires_at < now()
+        AND retry_count < $5
+      ORDER BY lock_expires_at ASC
+      LIMIT $1
+      FOR UPDATE SKIP LOCKED
+    )
+    UPDATE accounting.claim_jobs cj
+    SET
+      job_status = 'queued',
+      locked_at = NULL,
+      lock_expires_at = NULL,
+      metadata = jsonb_set(
+        jsonb_set(
+          coalesce(metadata, '{}'::jsonb),
+          '{requeued_by}',
+          to_jsonb($2::text),
+          true
+        ),
+        '{requeue_reason}',
+        to_jsonb($3::text),
+        true
+      ),
+      updated_at = now()
+    FROM expired e
+    WHERE cj.id = e.id
+    RETURNING cj.*;
+    `, [limit, lock_owner, lock_reason, current_status, max_retries]);
+            return rows[0];
+        });
+        // TODO: Increment the retry count for stale jobs
+        this.get_stale_jobs = (status_1, stale_time_mins_1, ttl_mins_1, lock_owner_1, lock_reason_1, ...args_1) => __awaiter(this, [status_1, stale_time_mins_1, ttl_mins_1, lock_owner_1, lock_reason_1, ...args_1], void 0, function* (status, stale_time_mins, ttl_mins, lock_owner, lock_reason, limit = 10) {
+            const repo = this.get_repo();
+            const ttlSeconds = ttl_mins * 60;
+            const metadata = {
+                lock_owner: lock_owner,
+                lock_reason: lock_reason
+            };
+            const rows = yield repo.query(`
+            WITH candidates AS (
+                SELECT id
+                FROM accounting.claim_jobs
+                WHERE job_status = $1
+                    AND (lock_expires_at IS NULL OR lock_expires_at < now()) 
+                    AND tx_hash IS NOT NULL 
+                    AND sent_at + ($2 || ' minutes')::interval  < NOW() 
+                ORDER BY tx_hash
+                LIMIT $3
+                FOR UPDATE SKIP LOCKED
+            )
+            UPDATE accounting.claim_jobs cj
+            SET
+                locked_at = now(),
+                lock_expires_at = now() + ($4 || ' seconds')::interval,
+                metadata = jsonb_set(
+                                jsonb_set(
+                                    coalesce(cj.metadata, '{}'::jsonb),
+                                    '{lock_owner}',
+                                    to_jsonb($5::text)
+                                ),
+                                '{lock_reason}',
+                                to_jsonb($6::text)
+                            ),
+                updated_at = now()
+            FROM candidates c
+            WHERE cj.id = c.id
+            RETURNING cj.*;
+    `, [status.toLowerCase(), stale_time_mins, limit, ttlSeconds, metadata.lock_owner, metadata.lock_reason]);
+            return rows[0];
+        });
+        this.get_stale_jobs_deprecated = (status_1, stale_time_mins_1, ...args_1) => __awaiter(this, [status_1, stale_time_mins_1, ...args_1], void 0, function* (status, stale_time_mins, limit = 10) {
+            const repo = this.get_repo();
+            const rows = yield repo.query(`
+    SELECT * FROM accounting.claim_jobs
+    WHERE job_status = $1 
+    AND tx_hash IS NOT NULL 
+    AND sent_at + ($2 || ' minutes')::interval  < NOW() 
+    ORDER BY blockchain, chain_id DESC
+    LIMIT $3
+    `, [status.toLowerCase(), stale_time_mins, limit]);
+            return rows;
+        });
+        this.find_job_by_blockchain_and_hash = (tx_hash, blockchain, receiver) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            const rows = yield repo.query(`
+        SELECT * FROM accounting.claim_jobs
+        WHERE tx_hash = $1
+        AND receiver = $3
+        AND blockchain = $2
+        ORDER BY created_at ASC; 
+            `, [tx_hash, blockchain, receiver]);
+            return rows;
+        });
+        this.get_claim_jobs = (status) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.findBy({ job_status: status });
+        });
+        this.get_claim_jobs_paginated = (page_1, ...args_1) => __awaiter(this, [page_1, ...args_1], void 0, function* (page, page_size = 10, filters) {
+            return this.paginate(page, page_size, filters);
+        });
+        this.get_claim_jobs_by_user = (user_id) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.findBy({ user_id });
+        });
+        this.get_claim_jobs_by_blockchain = (blockchain) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.findBy({ blockchain });
+        });
+        this.get_claim_jobs_by_chain_id = (chain_id) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.findBy({ chain_id });
+        });
+        this.get_claim_jobs_by_receiver = (address) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.findBy({ receiver: address });
+        });
+        this.get_claim_jobs_by_token = (token) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.findBy({ token });
+        });
+        this.get_claim_jobs_by_request_id = (request_id) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.findOne({ where: { request_id } });
+        });
+        this.get_claim_jobs_by_status = (status) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.findBy({ job_status: status });
+        });
+        this.create_claim_job = (payload) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            const entity = this.build_entity(payload);
+            try {
+                return yield repo.save(entity);
+            }
+            catch (error) {
+                if (error instanceof typeorm_1.QueryFailedError) {
+                    // Check if it's a duplicate key error for request_id
+                    if (error.driverError.error &&
+                        error.driverError.detail &&
+                        error.driverError.error.includes('duplicate key violates unique constraint') &&
+                        error.driverError.detail.includes("request_id") &&
+                        error.driverError.detail.includes("already exists")) {
+                        throw new Error(this.errors.DuplicateClaimJob(payload.request_id));
+                    }
+                    // Check for unique constraint violation (PostgreSQL error code 23505)
+                    if (error.driverError.detail &&
+                        error.driverError.code === '23505' &&
+                        error.driverError.detail.includes('request_id')) {
+                        throw new Error(this.errors.DuplicateClaimJob(payload.request_id));
+                    }
+                }
+                // Re-throw other errors
+                throw error;
+            }
+        });
+        this.update_claim_job_status = (request_id, new_status) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.update({ request_id }, { job_status: new_status });
+        });
+        this.batch_update_status = (request_ids, new_status) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            const status = new_status;
+            yield repo.query(`
+        UPDATE ${this.schema}.${this.table}
+        SET job_status = $1, updated_at = CURRENT_TIMESTAMP 
+        WHERE request_id = ANY($2)
+    `, [status, request_ids]);
+            return;
+        });
+        this.batch_update_failed_jobs = (request_ids, new_status, error_message, retryable) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            yield repo.query(`
+        UPDATE ${this.schema}.${this.table}
+        SET 
+            job_status = $1,
+            updated_at = CURRENT_TIMESTAMP,
+            error_message = COALESCE($2, error_message),
+            last_error_at = CASE 
+                                WHEN $2 IS NOT NULL THEN CURRENT_TIMESTAMP
+                                ELSE last_error_at
+                            END,
+            retry_count = CASE
+                              WHEN $3 = true THEN retry_count + 1
+                              ELSE retry_count
+                          END
+        WHERE request_id = ANY($4)
+    `, [
+                new_status,
+                error_message || null,
+                retryable === true,
+                request_ids
+            ]);
+        });
+        this.mark_complete = (payloads) => __awaiter(this, void 0, void 0, function* () {
+            if (payloads.length === 0)
+                return;
+            const repo = this.get_repo();
+            const history_service = new ClaimHistoryService_1.default(this.dbPool);
+            // Get all claim jobs that need to be completed
+            const request_ids = payloads.map(p => p.request_id);
+            // const jobs = await repo.findByIds(request_ids);
+            const jobs = yield repo.findBy({ request_id: (0, typeorm_1.In)(request_ids) });
+            if (jobs.length !== payloads.length) {
+                throw new Error(`Not all claim jobs found. Expected ${payloads.length}, found ${jobs.length}`);
+            }
+            // Build history records from jobs and completion data
+            const history_payloads = jobs.map(job => {
+                const completion_data = payloads.find(p => p.request_id === job.request_id);
+                if (!completion_data) {
+                    throw new Error(`No completion data found for request_id ${job.request_id}`);
+                }
+                return {
+                    request_id: job.request_id,
+                    blockchain: job.blockchain,
+                    chain_id: job.chain_id,
+                    payment_type: job.payment_type,
+                    user_id: job.user_id,
+                    from: completion_data.from,
+                    to: job.receiver,
+                    amount: job.amount,
+                    token: job.token,
+                    decimals: job.decimals,
+                    tx_hash: completion_data.tx_hash
+                };
+            });
+            // Save history records and delete completed jobs in a transaction
+            yield repo.manager.transaction((transactionalEntityManager) => __awaiter(this, void 0, void 0, function* () {
+                // Create history records
+                yield history_service.bulk_create_claim_history(history_payloads, transactionalEntityManager);
+                // Delete completed jobs
+                yield transactionalEntityManager.remove(jobs);
+            }));
+            return true;
+        });
+        this.batch_update_executed_jobs = (data) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            const requestIds = data.map(d => d.request_id);
+            const txHashes = data.map(d => d.tx_hash);
+            const sentAts = data.map(d => d.sent_at);
+            //    from_address = c.from,
+            yield repo.query(`
+        UPDATE ${this.schema}.${this.table} AS t
+        SET 
+            tx_hash = c.tx_hash,
+            sent_at = c.sent_at,
+            job_status = 'confirming',
+            updated_at = CURRENT_TIMESTAMP
+        FROM (
+            SELECT 
+                UNNEST($1::int[]) AS request_id,
+                UNNEST($2::text[]) AS tx_hash,
+                UNNEST($3::timestamptz[]) AS sent_at
+        ) AS c
+        WHERE t.request_id = c.request_id;
+    `, [requestIds, txHashes, sentAts]);
+        });
+        this.get_queued_count = (blockchain, chain_id) => __awaiter(this, void 0, void 0, function* () {
+            if (blockchain !== "evm" && blockchain !== "solana")
+                throw new Error(this.errors.UnsupportedResource("blockchain"));
+            const repo = this.get_repo();
+            return repo.count({ where: { blockchain: blockchain, chain_id: chain_id } });
+        });
+        this.get_next_queued_jobs = (blockchain_1, chain_id_1, ...args_1) => __awaiter(this, [blockchain_1, chain_id_1, ...args_1], void 0, function* (blockchain, chain_id, limit = 10) {
+            if (limit <= 0)
+                return [];
+            const repo = this.get_repo();
+            const query = `
+            select * from ${this.schema}.${this.table}
+            where (job_status = 'queued' and blockchain = '${blockchain}' and chain_id = '${chain_id}')
+            limit ${limit}
+        `;
+            let results = yield repo.query(query);
+            return results;
+        });
+        this.reset_retry_count = (request_ids) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            const parsed_ids = request_ids.map(id => Number(id));
+            yield repo.query(`
+            UPDATE ${this.schema}.${this.table}
+            SET retry_count = 0, updated_at = CURRENT_TIMESTAMP
+            WHERE request_id = ANY($1)
+        `, [parsed_ids]);
+        });
+        this.delete_claim_job = (request_id) => __awaiter(this, void 0, void 0, function* () {
+            const repo = this.get_repo();
+            return repo.delete({ request_id });
+        });
+        this.build_entity = (payload) => {
+            if (payload.blockchain !== constants_1.BLOCKCHAINS.EVM && payload.blockchain !== constants_1.BLOCKCHAINS.SOLANA && payload.blockchain !== constants_1.BLOCKCHAINS.TRON)
+                throw new Error("Unsupported blockchain for claim job");
+            const entity = new ClaimJob_1.ClaimJobs();
+            entity.request_id = payload.request_id;
+            entity.blockchain = payload.blockchain;
+            entity.chain_id = payload.chain_id;
+            entity.payment_type = payload.payment_type;
+            entity.user_id = payload.user_id;
+            entity.receiver = payload.receiver;
+            entity.amount = payload.amount;
+            entity.token = payload.token;
+            entity.decimals = payload.decimals;
+            entity.job_status = "queued";
+            return entity;
+        };
+        this.dbPool = dbPool;
+        this.schema = "accounting";
+        this.table = "claim_jobs";
+    }
+}
+exports.default = ClaimJobsService;

package/build/services/CryptoConfirmationLocksService.d.ts

@@ -0,0 +1,13 @@
+import BaseErrors from "../errors/errors";
+import { IConfig } from "../interfaces/config";
+import { IDatabasePool } from "../interfaces/database";
+declare class CryptoConfirmationLocksService extends BaseErrors {
+    private config;
+    private dbPool;
+    constructor(config: IConfig, dbPool: IDatabasePool);
+    private get_repo;
+    delete_locks(ids: number[]): Promise<import("typeorm").DeleteResult>;
+    update_locks(ids: number[], error_message: string): Promise<import("typeorm").UpdateResult>;
+}
+export default CryptoConfirmationLocksService;
+//# sourceMappingURL=CryptoConfirmationLocksService.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoConfirmationLocksService.d.ts","sourceRoot":"","sources":["../../src/services/CryptoConfirmationLocksService.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAGvD,cAAM,8BAA+B,SAAQ,UAAU;IACnD,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa;IAMlD,OAAO,CAAC,QAAQ;IAOH,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE;IAI1B,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,aAAa,EAAE,MAAM;CAWjE;AAED,eAAe,8BAA8B,CAAC"}

package/build/services/CryptoConfirmationLocksService.js

@@ -0,0 +1,46 @@
+"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 typeorm_1 = require("typeorm");
+const errors_1 = __importDefault(require("../errors/errors"));
+class CryptoConfirmationLocksService extends errors_1.default {
+    constructor(config, dbPool) {
+        super();
+        this.dbPool = dbPool;
+        this.config = config;
+    }
+    get_repo() {
+        const repo = this.dbPool.cryptoConfirmationLocksRepo;
+        if (!repo)
+            throw new Error(this.UnexpectedError(`Database pool is not initialized`));
+        return repo;
+    }
+    delete_locks(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.get_repo().delete({ id: (0, typeorm_1.In)(ids) });
+        });
+    }
+    update_locks(ids, error_message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.get_repo().update({ id: (0, typeorm_1.In)(ids) }, {
+                retry_count: () => 'retry_count + 1',
+                last_error_at: new Date(),
+                error_message: error_message,
+                locked_at: null,
+                lock_expires_at: null
+            });
+        });
+    }
+}
+exports.default = CryptoConfirmationLocksService;

package/build/services/CryptoKeysManager.d.ts

@@ -0,0 +1,16 @@
+import { BlockchainType } from "../interfaces";
+import { IConfig } from "../interfaces/config";
+import { BtcWallet } from "./types";
+declare class CryptoKeysManager {
+    constructor();
+    generate_wallet_keypair: (blockchain: BlockchainType, config: IConfig) => {
+        publicKey: string;
+        privateKey: string;
+    } | undefined;
+    private create_evm_wallet;
+    private create_sol_wallet;
+    private create_tron_wallet;
+    deriveWallet: (parentIndex: number, childIndex: number, blockchain: BlockchainType, mnemonic: string, config: IConfig) => BtcWallet;
+}
+export default CryptoKeysManager;
+//# sourceMappingURL=CryptoKeysManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CryptoKeysManager.d.ts","sourceRoot":"","sources":["../../src/services/CryptoKeysManager.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,OAAO,EAAE,SAAS,EAAyC,MAAM,SAAS,CAAC;AAQ3E,cAAM,iBAAiB;;IAIZ,uBAAuB,GAAI,YAAY,cAAc,EAAE,QAAQ,OAAO;;;kBAW5E;IAED,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,kBAAkB;IAMnB,YAAY,GAAI,aAAa,MAAM,EAAE,YAAY,MAAM,EAAE,YAAY,cAAc,EAAE,UAAU,MAAM,EAAE,QAAQ,OAAO,eAmE5H;CAGJ;AAED,eAAe,iBAAiB,CAAC"}

package/build/services/CryptoKeysManager.js

@@ -0,0 +1,136 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const constants_1 = require("../constants");
+const tronweb_1 = require("tronweb");
+const bip39 = __importStar(require("bip39"));
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const ed25519 = __importStar(require("ed25519-hd-key"));
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+class CryptoKeysManager {
+    constructor() {
+        this.generate_wallet_keypair = (blockchain, config) => {
+            switch (blockchain) {
+                case constants_1.BLOCKCHAINS.EVM:
+                    return this.create_evm_wallet(config);
+                case constants_1.BLOCKCHAINS.SOLANA:
+                    return this.create_sol_wallet(config);
+                case constants_1.BLOCKCHAINS.TRON:
+                    return this.create_tron_wallet(config);
+                default:
+            }
+        };
+        this.deriveWallet = (parentIndex, childIndex, blockchain, mnemonic, config) => {
+            try {
+                // Construct derivation path using parent id and child index based on blockchain type
+                let path = "";
+                switch (blockchain) {
+                    case constants_1.BLOCKCHAINS.TRON:
+                        path = `m/44'/195'/${parentIndex}'/0/${childIndex}`;
+                        // Derive private key
+                        const hdNode = ethers_1.ethers.HDNodeWallet.fromPhrase(mnemonic, "", path);
+                        const privateKey = hdNode.privateKey.replace("0x", "");
+                        // Create TRON account
+                        const hostUrl = config.config.environment === 'dev' || config.config.environment === 'local' ? "https://nile.trongrid.io" : "https://api.trongrid.io";
+                        const tronWeb = new tronweb_1.TronWeb({ fullHost: hostUrl });
+                        const address = tronWeb.address.fromPrivateKey(privateKey);
+                        if (!address)
+                            throw new Error("Failed to derive wallet address from private key on tron network");
+                        const tronWallet = {
+                            wallet: {
+                                address,
+                                publicKey: address,
+                                privateKey: privateKey,
+                                sign: (tx) => tronWeb.trx.sign(tx, privateKey),
+                            },
+                            address: address
+                        };
+                        return tronWallet;
+                    case "evm":
+                        // Use Ethereum path standard
+                        path = `m/44'/60'/${parentIndex}'/0/${childIndex}`;
+                        // Just derive wallet from mnemonic and custom path
+                        const derivedWallet = ethers_1.ethers.HDNodeWallet.fromPhrase(mnemonic, "", path);
+                        return { wallet: derivedWallet, address: derivedWallet.address };
+                    case "solana":
+                        // Use Solana path standard
+                        path = `m/44'/501'/${parentIndex}'/${childIndex}'`;
+                        // Convert the mnemonic to a seed
+                        const seed = bip39.mnemonicToSeedSync(mnemonic);
+                        // Derive a seed from the given path
+                        const derivedSeed = ed25519.derivePath(path, seed.toString('hex')).key;
+                        // Generate a keypair from the derived seed
+                        const derivedUint8Keypair = tweetnacl_1.default.sign.keyPair.fromSeed(new Uint8Array(derivedSeed));
+                        // Convert to Solana web3.js Keypair object
+                        const customPathKeypair = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(derivedUint8Keypair.secretKey));
+                        return { address: customPathKeypair.publicKey.toBase58(), wallet: customPathKeypair };
+                    case "btc":
+                        // Use BTC path standard
+                        path = `m/44'/0'/${parentIndex}'/0/${childIndex}`;
+                        return {
+                            address: "",
+                            wallet: {}
+                        };
+                    default:
+                        throw new Error(`Unsupported blockchain: ${blockchain}.`);
+                }
+            }
+            catch (error) {
+                throw error;
+            }
+        };
+    }
+    create_evm_wallet(config) {
+        const mnemonic = '';
+        const wallet = this.deriveWallet(0, 2, constants_1.BLOCKCHAINS.EVM, mnemonic, config);
+        return { publicKey: wallet.address, privateKey: wallet.wallet.privateKey.slice(2) };
+    }
+    create_sol_wallet(config) {
+        const mnemonic = '';
+        const wallet = this.deriveWallet(2, 0, constants_1.BLOCKCHAINS.SOLANA, mnemonic, config);
+        return { publicKey: wallet.address, privateKey: bs58_1.default.encode(wallet.wallet.secretKey) };
+    }
+    create_tron_wallet(config) {
+        const mnemonic = '';
+        const wallet = this.deriveWallet(0, 2, constants_1.BLOCKCHAINS.TRON, mnemonic, config);
+        return { publicKey: wallet.address, privateKey: wallet.wallet.privateKey };
+    }
+}
+exports.default = CryptoKeysManager;

package/build/services/DepositAddressService.d.ts

@@ -0,0 +1,42 @@
+import { DepositAddress } from "../entities/DepositAddress";
+import { BlockchainType } from "../interfaces";
+import { IDatabasePool } from "../interfaces/database";
+interface CreateDepositResult {
+    id: number;
+    userId: number;
+    address: string;
+    parentIndex: number;
+    childIndex: number;
+    transactionCount: number;
+    blockchain: string;
+    updatedAt: Date;
+    createdAt: Date;
+}
+export interface UpdateDepositAddressValues {
+    blockchain: string;
+    parentIndex: number;
+    childIndex: number;
+    address: string;
+}
+interface UpdateDepositResult extends CreateDepositResult {
+}
+declare class DepositAddressService {
+    private dbPool;
+    constructor(dbPool: IDatabasePool);
+    private normalizeAddress;
+    getDepositAddress(userId: number, blockchain: string): Promise<DepositAddress>;
+    findById(walletId: number): Promise<DepositAddress>;
+    findByUserId(userId: number, blockchain: string): Promise<DepositAddress>;
+    findByBlockchainAndParentIndex(blockchain: BlockchainType, parentIndex: number): Promise<null>;
+    private findByBlockchainAndUserId;
+    createDepositAddress(userId: number, blockchain: string, parentIndex: number, address: string): Promise<CreateDepositResult>;
+    updateDepositAddress(userId: number, values: UpdateDepositAddressValues): Promise<UpdateDepositResult>;
+    deleteDepositAddress(userId: number, blockchain: string): Promise<{
+        status: boolean;
+        address: string;
+    }>;
+    getDepositAddressByAddress(blockchain: BlockchainType, address: string): Promise<DepositAddress | null>;
+    findByBlockchainAndAddressRaw(blockchain: BlockchainType, address: string): Promise<DepositAddress | null>;
+}
+export default DepositAddressService;
+//# sourceMappingURL=DepositAddressService.d.ts.map