@hsuite/smart-engines-cli 1.0.0 → 1.0.1

package/dist/libs/multi-chain-core/src/membership/membership-application.service.js

@@ -1,780 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-var MembershipApplicationService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MembershipApplicationService = void 0;
-const common_1 = require("@nestjs/common");
-const mongoose_1 = require("@nestjs/mongoose");
-const mongoose_2 = require("mongoose");
-const smart_engines_infrastructure_1 = require("@hsuite/smart-engines-infrastructure");
-const governance_types_1 = require("../governance/governance.types");
-const dynamic_validator_registry_service_1 = require("../governance/dynamic-validator-registry.service");
-const deposit_wallet_service_1 = require("./deposit-wallet.service");
-let MembershipApplicationService = MembershipApplicationService_1 = class MembershipApplicationService {
-    eventBus;
-    depositWalletService;
-    validatorRegistry;
-    applicationModel;
-    logger = new common_1.Logger(MembershipApplicationService_1.name);
-    applicationCache = new Map();
-    depositMonitorInterval;
-    expiryCheckInterval;
-    constructor(eventBus, depositWalletService, validatorRegistry, applicationModel) {
-        this.eventBus = eventBus;
-        this.depositWalletService = depositWalletService;
-        this.validatorRegistry = validatorRegistry;
-        this.applicationModel = applicationModel;
-        this.logger.log('MembershipApplicationService created');
-    }
-    async onModuleInit() {
-        this.logger.log('Initializing MembershipApplicationService...');
-        await this.loadPendingApplications();
-        this.startDepositMonitoring();
-        this.startExpiryChecking();
-        this.subscribeToEvents();
-        this.logger.log('✓ MembershipApplicationService initialized');
-    }
-    onModuleDestroy() {
-        if (this.depositMonitorInterval) {
-            clearInterval(this.depositMonitorInterval);
-        }
-        if (this.expiryCheckInterval) {
-            clearInterval(this.expiryCheckInterval);
-        }
-        this.logger.log('MembershipApplicationService destroyed');
-    }
-    async submitApplication(request) {
-        const { applicantNodeId, applicantAccountId, chain } = request;
-        const networkType = request.networkType || 'validator';
-        this.logger.log(`Processing ${networkType} membership application from ${applicantNodeId} on ${chain}`);
-        try {
-            const existing = await this.getApplicationByNodeId(applicantNodeId);
-            if (existing &&
-                existing.status !== governance_types_1.MembershipApplicationStatusEnum.EXPIRED &&
-                existing.status !== governance_types_1.MembershipApplicationStatusEnum.LEFT &&
-                existing.status !== governance_types_1.MembershipApplicationStatusEnum.BANNED) {
-                return {
-                    success: false,
-                    error: `Active application already exists: ${existing.applicationId} (status: ${existing.status})`,
-                };
-            }
-            const existingValidator = this.validatorRegistry.getValidator(applicantNodeId);
-            if (existingValidator && existingValidator.status === governance_types_1.ValidatorStatus.ACTIVE) {
-                return {
-                    success: false,
-                    error: `Node is already an active ${existingValidator.networkType || 'validator'}`,
-                };
-            }
-            const applicationId = this.generateApplicationId(applicantNodeId);
-            const walletResult = await this.depositWalletService.createDepositWallet({
-                type: 'membership',
-                ownerId: applicantNodeId,
-                chain,
-                ownerAccountId: applicantAccountId,
-                networkType,
-                metadata: {
-                    applicationId,
-                    applicantNodeId,
-                    applicantAccountId,
-                    publicKey: request.publicKey,
-                    endpoint: request.endpoint,
-                    chainAccounts: request.chainAccounts,
-                    capabilities: request.capabilities,
-                    networkType,
-                },
-            });
-            if (!walletResult.success || !walletResult.wallet) {
-                return {
-                    success: false,
-                    error: walletResult.error || 'Failed to create deposit wallet',
-                };
-            }
-            const application = {
-                applicationId,
-                applicantNodeId,
-                status: governance_types_1.MembershipApplicationStatusEnum.PENDING_DEPOSIT,
-                networkType,
-                depositWallet: walletResult.wallet,
-                submittedAt: new Date(),
-            };
-            this.applicationCache.set(applicationId, application);
-            await this.persistApplication(application);
-            await this.eventBus.publishEvent('membership', 'application.submitted', {
-                applicationId,
-                applicantNodeId,
-                networkType,
-                chain,
-                depositWalletAddress: walletResult.wallet.walletAddress,
-                timestamp: new Date(),
-            });
-            this.logger.log(`✓ ${networkType} application ${applicationId} created for ${applicantNodeId}`);
-            return {
-                success: true,
-                application,
-                depositInstructions: walletResult.depositInstructions,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.error(`Failed to submit application: ${errorMessage}`);
-            return {
-                success: false,
-                error: errorMessage,
-            };
-        }
-    }
-    async checkApplicationStatus(applicationId) {
-        const application = await this.getApplication(applicationId);
-        if (!application) {
-            return null;
-        }
-        if (application.status === governance_types_1.MembershipApplicationStatusEnum.PENDING_DEPOSIT &&
-            application.depositWallet) {
-            const verifyResult = await this.depositWalletService.verifyDeposit(application.depositWallet.walletId);
-            if (verifyResult.success && verifyResult.depositConfirmed) {
-                application.status = governance_types_1.MembershipApplicationStatusEnum.DEPOSIT_CONFIRMED;
-                application.depositWallet =
-                    (await this.depositWalletService.getWallet(application.depositWallet.walletId)) ||
-                        application.depositWallet;
-                this.applicationCache.set(applicationId, application);
-                await this.persistApplication(application);
-                await this.eventBus.publishEvent('membership', 'deposit.verified', {
-                    applicationId,
-                    applicantNodeId: application.applicantNodeId,
-                    amount: verifyResult.actualAmount,
-                    timestamp: new Date(),
-                });
-            }
-        }
-        return application;
-    }
-    async activateMembership(applicationId) {
-        this.logger.log(`Activating membership for application ${applicationId}`);
-        try {
-            const application = await this.getApplication(applicationId);
-            if (!application) {
-                return {
-                    success: false,
-                    error: 'Application not found',
-                };
-            }
-            if (application.status !== governance_types_1.MembershipApplicationStatusEnum.DEPOSIT_CONFIRMED) {
-                await this.checkApplicationStatus(applicationId);
-                const updated = await this.getApplication(applicationId);
-                if (updated?.status !== governance_types_1.MembershipApplicationStatusEnum.DEPOSIT_CONFIRMED) {
-                    return {
-                        success: false,
-                        error: `Application not ready for activation. Current status: ${application.status}`,
-                    };
-                }
-            }
-            if (!application.depositWallet) {
-                return {
-                    success: false,
-                    error: 'No deposit wallet associated with application',
-                };
-            }
-            const entity = await this.getApplicationMetadata(application);
-            const networkType = application.networkType || 'validator';
-            await this.eventBus.publishEvent('membership', 'nft.mint.request', {
-                applicationId,
-                applicantNodeId: application.applicantNodeId,
-                networkType,
-                chain: application.depositWallet.chain,
-                recipientAccountId: entity.applicantAccountId,
-                depositWalletAddress: application.depositWallet.walletAddress,
-                lockedUntil: application.depositWallet.lockedUntil,
-                depositAmount: application.depositWallet.actualDepositAmount || application.depositWallet.depositAmount,
-                publicKey: entity.publicKey,
-                endpoint: entity.endpoint,
-                chainAccounts: entity.chainAccounts,
-                timestamp: new Date(),
-            });
-            const expiresAt = new Date(application.depositWallet.lockedUntil);
-            application.status = governance_types_1.MembershipApplicationStatusEnum.ACTIVE;
-            application.activatedAt = new Date();
-            application.expiresAt = expiresAt;
-            this.applicationCache.set(applicationId, application);
-            await this.persistApplication(application);
-            const validatorEntry = {
-                nodeId: application.applicantNodeId,
-                accountId: entity.applicantAccountId,
-                publicKey: entity.publicKey || '',
-                endpoint: entity.endpoint || '',
-                status: governance_types_1.ValidatorStatus.ONBOARDING,
-                networkType,
-                joinedAt: new Date(),
-                depositWallet: application.depositWallet,
-                membershipExpiresAt: expiresAt,
-                membershipApplicationId: applicationId,
-                capabilities: entity.capabilities,
-            };
-            await this.eventBus.publishEvent('membership', 'activated', {
-                applicationId,
-                networkType,
-                validatorEntry,
-                timestamp: new Date(),
-            });
-            this.logger.log(`✓ ${networkType} membership activated for ${application.applicantNodeId}`);
-            return {
-                success: true,
-                application,
-                validatorEntry,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.error(`Failed to activate membership: ${errorMessage}`);
-            return {
-                success: false,
-                error: errorMessage,
-            };
-        }
-    }
-    async renewMembership(nodeId, additionalDays) {
-        this.logger.log(`Renewing membership for ${nodeId}`);
-        try {
-            const application = await this.getApplicationByNodeId(nodeId);
-            if (!application) {
-                return {
-                    success: false,
-                    error: 'No application found for node',
-                };
-            }
-            if (application.status !== governance_types_1.MembershipApplicationStatusEnum.ACTIVE &&
-                application.status !== governance_types_1.MembershipApplicationStatusEnum.EXPIRED) {
-                return {
-                    success: false,
-                    error: `Cannot renew membership in status: ${application.status}`,
-                };
-            }
-            if (!application.depositWallet) {
-                return {
-                    success: false,
-                    error: 'No deposit wallet associated with membership',
-                };
-            }
-            const renewResult = await this.depositWalletService.renewMembership(application.depositWallet.walletId, additionalDays);
-            if (!renewResult.success || !renewResult.wallet) {
-                return {
-                    success: false,
-                    error: renewResult.error || 'Failed to renew deposit lock',
-                };
-            }
-            application.depositWallet = renewResult.wallet;
-            application.expiresAt = renewResult.wallet.lockedUntil;
-            application.status = governance_types_1.MembershipApplicationStatusEnum.ACTIVE;
-            this.applicationCache.set(application.applicationId, application);
-            await this.persistApplication(application);
-            const validator = this.validatorRegistry.getValidator(nodeId);
-            if (validator) {
-                validator.membershipExpiresAt = renewResult.wallet.lockedUntil;
-                validator.depositWallet = renewResult.wallet;
-            }
-            await this.eventBus.publishEvent('membership', 'renewed', {
-                applicationId: application.applicationId,
-                nodeId,
-                newExpiresAt: renewResult.wallet.lockedUntil,
-                timestamp: new Date(),
-            });
-            this.logger.log(`✓ Membership renewed for ${nodeId} until ${renewResult.wallet.lockedUntil}`);
-            return {
-                success: true,
-                application,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.error(`Failed to renew membership: ${errorMessage}`);
-            return {
-                success: false,
-                error: errorMessage,
-            };
-        }
-    }
-    async requestLeave(nodeId, recipientAddress) {
-        this.logger.log(`Processing leave request for ${nodeId}`);
-        try {
-            const application = await this.getApplicationByNodeId(nodeId);
-            if (!application) {
-                return {
-                    success: false,
-                    depositReleasable: false,
-                    error: 'No membership found for node',
-                };
-            }
-            if (application.status === governance_types_1.MembershipApplicationStatusEnum.BANNED) {
-                return {
-                    success: false,
-                    depositReleasable: false,
-                    error: 'Banned validators cannot request leave',
-                };
-            }
-            if (application.status === governance_types_1.MembershipApplicationStatusEnum.LEFT) {
-                return {
-                    success: false,
-                    depositReleasable: false,
-                    error: 'Already left the network',
-                };
-            }
-            if (!application.depositWallet) {
-                application.status = governance_types_1.MembershipApplicationStatusEnum.LEFT;
-                this.applicationCache.set(application.applicationId, application);
-                await this.persistApplication(application);
-                return {
-                    success: true,
-                    depositReleasable: false,
-                };
-            }
-            const isExpired = await this.depositWalletService.isDepositExpired(application.depositWallet.walletId);
-            if (isExpired) {
-                const releaseResult = await this.depositWalletService.releaseDeposit(application.depositWallet.walletId, recipientAddress);
-                if (releaseResult.success) {
-                    application.status = governance_types_1.MembershipApplicationStatusEnum.LEFT;
-                    application.depositWallet =
-                        (await this.depositWalletService.getWallet(application.depositWallet.walletId)) ||
-                            application.depositWallet;
-                    this.applicationCache.set(application.applicationId, application);
-                    await this.persistApplication(application);
-                    if (application.membershipNftSerial) {
-                        this.logger.log(`Requesting NFT revocation for leaving validator ${nodeId}...`);
-                        await this.eventBus.publishEvent('membership', 'nft.revoke.request', {
-                            type: 'VALIDATOR_LEAVE',
-                            applicationId: application.applicationId,
-                            nodeId,
-                            accountId: application.applicantNodeId,
-                            nftSerial: application.membershipNftSerial,
-                            chainNfts: application.chainNfts,
-                            chain: application.depositWallet?.chain,
-                            timestamp: new Date(),
-                        });
-                    }
-                    await this.eventBus.publishEvent('membership', 'left', {
-                        applicationId: application.applicationId,
-                        nodeId,
-                        depositReleased: true,
-                        nftRevoked: !!application.membershipNftSerial,
-                        timestamp: new Date(),
-                    });
-                    return {
-                        success: true,
-                        depositReleasable: true,
-                    };
-                }
-                else {
-                    return {
-                        success: false,
-                        depositReleasable: true,
-                        error: releaseResult.error,
-                    };
-                }
-            }
-            else {
-                application.status = governance_types_1.MembershipApplicationStatusEnum.LEFT;
-                this.applicationCache.set(application.applicationId, application);
-                await this.persistApplication(application);
-                if (application.membershipNftSerial) {
-                    this.logger.log(`Requesting NFT revocation for leaving validator ${nodeId} (deposit locked)...`);
-                    await this.eventBus.publishEvent('membership', 'nft.revoke.request', {
-                        type: 'VALIDATOR_LEAVE',
-                        applicationId: application.applicationId,
-                        nodeId,
-                        accountId: application.applicantNodeId,
-                        nftSerial: application.membershipNftSerial,
-                        chainNfts: application.chainNfts,
-                        chain: application.depositWallet.chain,
-                        timestamp: new Date(),
-                    });
-                }
-                await this.eventBus.publishEvent('membership', 'leave.requested', {
-                    applicationId: application.applicationId,
-                    nodeId,
-                    releaseableAt: application.depositWallet.lockedUntil,
-                    recipientAddress,
-                    nftRevoked: !!application.membershipNftSerial,
-                    timestamp: new Date(),
-                });
-                return {
-                    success: true,
-                    depositReleasable: false,
-                    releaseableAt: application.depositWallet.lockedUntil,
-                };
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.error(`Failed to process leave request: ${errorMessage}`);
-            return {
-                success: false,
-                depositReleasable: false,
-                error: errorMessage,
-            };
-        }
-    }
-    async handleBan(nodeId, reason) {
-        this.logger.log(`Handling ban for ${nodeId}: ${reason}`);
-        try {
-            const application = await this.getApplicationByNodeId(nodeId);
-            if (!application) {
-                return {
-                    success: true,
-                    slashed: false,
-                };
-            }
-            if (application.depositWallet) {
-                const slashResult = await this.depositWalletService.slashDeposit(application.depositWallet.walletId, reason);
-                if (!slashResult.success) {
-                    this.logger.error(`Failed to slash deposit: ${slashResult.error}`);
-                }
-                application.depositWallet =
-                    (await this.depositWalletService.getWallet(application.depositWallet.walletId)) ||
-                        application.depositWallet;
-            }
-            application.status = governance_types_1.MembershipApplicationStatusEnum.BANNED;
-            this.applicationCache.set(application.applicationId, application);
-            await this.persistApplication(application);
-            if (application.membershipNftSerial) {
-                this.logger.log(`Requesting NFT revocation for banned validator ${nodeId}...`);
-                await this.eventBus.publishEvent('membership', 'nft.revoke.request', {
-                    type: 'VALIDATOR_BAN',
-                    applicationId: application.applicationId,
-                    nodeId,
-                    accountId: application.applicantNodeId,
-                    nftSerial: application.membershipNftSerial,
-                    chainNfts: application.chainNfts,
-                    chain: application.depositWallet?.chain,
-                    reason,
-                    timestamp: new Date(),
-                });
-            }
-            await this.eventBus.publishEvent('membership', 'banned', {
-                applicationId: application.applicationId,
-                nodeId,
-                reason,
-                depositSlashed: application.depositWallet?.status === governance_types_1.DepositWalletStatus.SLASHED,
-                nftRevoked: !!application.membershipNftSerial,
-                timestamp: new Date(),
-            });
-            return {
-                success: true,
-                slashed: application.depositWallet?.status === governance_types_1.DepositWalletStatus.SLASHED,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            this.logger.error(`Failed to handle ban: ${errorMessage}`);
-            return {
-                success: false,
-                slashed: false,
-                error: errorMessage,
-            };
-        }
-    }
-    async getApplication(applicationId) {
-        if (this.applicationCache.has(applicationId)) {
-            return this.applicationCache.get(applicationId);
-        }
-        if (this.applicationModel) {
-            const doc = await this.applicationModel.findOne({ applicationId }).exec();
-            if (doc) {
-                const application = this.docToApplication(doc);
-                this.applicationCache.set(applicationId, application);
-                return application;
-            }
-        }
-        return null;
-    }
-    async getApplicationByNodeId(nodeId) {
-        for (const app of this.applicationCache.values()) {
-            if (app.applicantNodeId === nodeId) {
-                return app;
-            }
-        }
-        if (this.applicationModel) {
-            const doc = await this.applicationModel.findOne({ applicantNodeId: nodeId }).exec();
-            if (doc) {
-                const application = this.docToApplication(doc);
-                this.applicationCache.set(application.applicationId, application);
-                return application;
-            }
-        }
-        return null;
-    }
-    async hasValidMembership(nodeId) {
-        const application = await this.getApplicationByNodeId(nodeId);
-        if (!application)
-            return false;
-        if (application.status !== governance_types_1.MembershipApplicationStatusEnum.ACTIVE) {
-            return false;
-        }
-        if (application.expiresAt && application.expiresAt < new Date()) {
-            application.status = governance_types_1.MembershipApplicationStatusEnum.EXPIRED;
-            this.applicationCache.set(application.applicationId, application);
-            await this.persistApplication(application);
-            return false;
-        }
-        return true;
-    }
-    async listApplications(filters) {
-        if (this.applicationModel) {
-            const query = {};
-            if (filters?.status) {
-                query.status = filters.status;
-            }
-            if (filters?.networkType) {
-                query.networkType = filters.networkType;
-            }
-            const docs = await this.applicationModel.find(query).exec();
-            return docs.map((doc) => this.docToApplication(doc));
-        }
-        const applications = Array.from(this.applicationCache.values());
-        return applications.filter((app) => {
-            if (filters?.status && app.status !== filters.status)
-                return false;
-            if (filters?.networkType && app.networkType !== filters.networkType)
-                return false;
-            return true;
-        });
-    }
-    async listApplicationsByNetworkType(networkType, status) {
-        return this.listApplications({ networkType, status });
-    }
-    async countApplicationsByNetworkType(networkType, status) {
-        const applications = await this.listApplicationsByNetworkType(networkType, status);
-        return applications.length;
-    }
-    async getApplicationCountsByNetworkType() {
-        const networkTypes = ['validator', 'host', 'gateway'];
-        const counts = {};
-        for (const type of networkTypes) {
-            const total = await this.countApplicationsByNetworkType(type);
-            const active = await this.countApplicationsByNetworkType(type, governance_types_1.MembershipApplicationStatusEnum.ACTIVE);
-            counts[type] = { total, active };
-        }
-        return counts;
-    }
-    generateApplicationId(nodeId) {
-        const timestamp = Date.now();
-        const random = Math.random().toString(36).substring(2, 8);
-        return `app-${nodeId.substring(0, 8)}-${timestamp}-${random}`;
-    }
-    async getApplicationMetadata(application) {
-        let metadata = {
-            applicantAccountId: '',
-        };
-        if (application.depositWallet) {
-            const wallet = await this.depositWalletService.getWallet(application.depositWallet.walletId);
-            if (wallet) {
-                metadata = {
-                    applicantAccountId: wallet.walletAddress,
-                    ...metadata,
-                };
-            }
-        }
-        return metadata;
-    }
-    async loadPendingApplications() {
-        if (!this.applicationModel)
-            return;
-        try {
-            const pendingStatuses = [
-                governance_types_1.MembershipApplicationStatusEnum.PENDING_WALLET,
-                governance_types_1.MembershipApplicationStatusEnum.PENDING_DEPOSIT,
-                governance_types_1.MembershipApplicationStatusEnum.DEPOSIT_CONFIRMED,
-            ];
-            const docs = await this.applicationModel
-                .find({
-                status: { $in: pendingStatuses },
-            })
-                .exec();
-            for (const doc of docs) {
-                const application = this.docToApplication(doc);
-                this.applicationCache.set(application.applicationId, application);
-            }
-            this.logger.log(`Loaded ${docs.length} pending applications`);
-        }
-        catch (error) {
-            this.logger.error(`Failed to load pending applications: ${error}`);
-        }
-    }
-    startDepositMonitoring() {
-        const intervalMs = parseInt(process.env.DEPOSIT_MONITOR_INTERVAL_MS || '30000', 10);
-        this.depositMonitorInterval = setInterval(async () => {
-            await this.checkPendingDeposits();
-        }, intervalMs);
-        this.logger.log(`Deposit monitoring started (interval: ${intervalMs}ms)`);
-    }
-    async checkPendingDeposits() {
-        const pendingApplications = await this.listApplications({
-            status: governance_types_1.MembershipApplicationStatusEnum.PENDING_DEPOSIT,
-        });
-        for (const app of pendingApplications) {
-            try {
-                await this.checkApplicationStatus(app.applicationId);
-            }
-            catch (error) {
-                this.logger.error(`Error checking deposit for ${app.applicationId}: ${error}`);
-            }
-        }
-    }
-    startExpiryChecking() {
-        const intervalMs = parseInt(process.env.EXPIRY_CHECK_INTERVAL_MS || '3600000', 10);
-        this.expiryCheckInterval = setInterval(async () => {
-            await this.checkExpiringMemberships();
-        }, intervalMs);
-        this.logger.log(`Expiry checking started (interval: ${intervalMs}ms)`);
-    }
-    async checkExpiringMemberships() {
-        const renewalWindowDays = parseInt(process.env.MEMBERSHIP_RENEWAL_WINDOW_DAYS || '30', 10);
-        const expiringWallets = await this.depositWalletService.findExpiringWallets(renewalWindowDays);
-        for (const wallet of expiringWallets) {
-            const applications = await this.listApplications({
-                status: governance_types_1.MembershipApplicationStatusEnum.ACTIVE,
-            });
-            const app = applications.find((a) => a.depositWallet?.walletId === wallet.walletId);
-            if (app) {
-                await this.eventBus.publishEvent('membership', 'expiring.warning', {
-                    applicationId: app.applicationId,
-                    nodeId: app.applicantNodeId,
-                    expiresAt: wallet.lockedUntil,
-                    daysRemaining: Math.ceil((wallet.lockedUntil.getTime() - Date.now()) / (24 * 60 * 60 * 1000)),
-                    timestamp: new Date(),
-                });
-            }
-        }
-        const activeApplications = await this.listApplications({
-            status: governance_types_1.MembershipApplicationStatusEnum.ACTIVE,
-        });
-        const now = new Date();
-        for (const app of activeApplications) {
-            if (app.expiresAt && app.expiresAt < now) {
-                app.status = governance_types_1.MembershipApplicationStatusEnum.EXPIRED;
-                this.applicationCache.set(app.applicationId, app);
-                await this.persistApplication(app);
-                await this.eventBus.publishEvent('membership', 'expired', {
-                    applicationId: app.applicationId,
-                    nodeId: app.applicantNodeId,
-                    expiredAt: app.expiresAt,
-                    timestamp: new Date(),
-                });
-                this.logger.log(`Membership expired for ${app.applicantNodeId}`);
-            }
-        }
-    }
-    subscribeToEvents() {
-        this.eventBus.subscribeToEvents('membership.nft.minted', async (event) => {
-            const { applicationId, nftSerial, chainNfts } = event.data;
-            const application = await this.getApplication(applicationId);
-            if (application) {
-                application.membershipNftSerial = nftSerial;
-                application.chainNfts = chainNfts;
-                this.applicationCache.set(applicationId, application);
-                await this.persistApplication(application);
-                this.logger.log(`NFT minted for application ${applicationId}: serial ${nftSerial}`);
-            }
-        });
-        this.eventBus.subscribeToEvents('membership.validation.request', async (event) => {
-            const { requestId, nodeId } = event.data;
-            this.logger.debug(`Received membership validation request for ${nodeId}`);
-            try {
-                const genesisComplete = this.validatorRegistry.isGenesisComplete();
-                if (!genesisComplete) {
-                    await this.eventBus.publishEvent('membership', `validation.response.${requestId}`, {
-                        valid: true,
-                        skipped: true,
-                        reason: 'Genesis not complete - validation skipped',
-                    });
-                    return;
-                }
-                const isGenesisValidator = this.isGenesisValidator(nodeId);
-                if (isGenesisValidator) {
-                    await this.eventBus.publishEvent('membership', `validation.response.${requestId}`, {
-                        valid: true,
-                        skipped: false,
-                        reason: 'Genesis validator - always valid',
-                    });
-                    return;
-                }
-                const hasValidMembership = await this.hasValidMembership(nodeId);
-                const application = await this.getApplicationByNodeId(nodeId);
-                await this.eventBus.publishEvent('membership', `validation.response.${requestId}`, {
-                    valid: hasValidMembership,
-                    skipped: false,
-                    reason: hasValidMembership
-                        ? 'Active membership'
-                        : application
-                            ? `Membership status: ${application.status}`
-                            : 'No membership application found',
-                    expiresAt: application?.expiresAt?.toISOString(),
-                });
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                this.logger.error(`Error validating membership for ${nodeId}: ${errorMessage}`);
-                await this.eventBus.publishEvent('membership', `validation.response.${requestId}`, {
-                    valid: true,
-                    skipped: true,
-                    reason: `Validation error: ${errorMessage}`,
-                });
-            }
-        });
-    }
-    isGenesisValidator(nodeId) {
-        const genesisConfig = this.validatorRegistry.getGenesisConfig();
-        if (!genesisConfig)
-            return false;
-        return genesisConfig.validators.some((v) => v.nodeId === nodeId);
-    }
-    async persistApplication(application) {
-        if (this.applicationModel) {
-            await this.applicationModel.updateOne({ applicationId: application.applicationId }, { $set: application }, { upsert: true });
-        }
-    }
-    docToApplication(doc) {
-        return {
-            applicationId: doc.applicationId,
-            applicantNodeId: doc.applicantNodeId,
-            status: doc.status,
-            networkType: doc.networkType || 'validator',
-            depositWallet: doc.depositWallet
-                ? {
-                    ...doc.depositWallet,
-                    lockedUntil: new Date(doc.depositWallet.lockedUntil),
-                    createdAt: new Date(doc.depositWallet.createdAt),
-                    depositConfirmedAt: doc.depositWallet.depositConfirmedAt
-                        ? new Date(doc.depositWallet.depositConfirmedAt)
-                        : undefined,
-                    closedAt: doc.depositWallet.closedAt ? new Date(doc.depositWallet.closedAt) : undefined,
-                }
-                : undefined,
-            membershipNftSerial: doc.membershipNftSerial,
-            chainNfts: doc.chainNfts,
-            expiresAt: doc.expiresAt ? new Date(doc.expiresAt) : undefined,
-            submittedAt: new Date(doc.submittedAt),
-            activatedAt: doc.activatedAt ? new Date(doc.activatedAt) : undefined,
-            error: doc.error,
-        };
-    }
-};
-exports.MembershipApplicationService = MembershipApplicationService;
-exports.MembershipApplicationService = MembershipApplicationService = MembershipApplicationService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __param(3, (0, common_1.Optional)()),
-    __param(3, (0, mongoose_1.InjectModel)('MembershipApplication')),
-    __metadata("design:paramtypes", [smart_engines_infrastructure_1.EventBusService,
-        deposit_wallet_service_1.DepositWalletService,
-        dynamic_validator_registry_service_1.DynamicValidatorRegistryService,
-        mongoose_2.Model])
-], MembershipApplicationService);
-//# sourceMappingURL=membership-application.service.js.map