@hsuite/smart-engines-cli 1.0.0

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

@@ -0,0 +1,780 @@
+"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