@hsuite/smart-engines-cli 1.0.0

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

@@ -0,0 +1,677 @@
+"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 SubscriptionService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscriptionService = exports.SubscriptionStatus = 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 smart_engines_pricing_core_1 = require("@hsuite/smart-engines-pricing-core");
+const deposit_wallet_service_1 = require("./deposit-wallet.service");
+var SubscriptionStatus;
+(function (SubscriptionStatus) {
+    SubscriptionStatus["PENDING_DEPOSIT"] = "pending_deposit";
+    SubscriptionStatus["DEPOSIT_CONFIRMED"] = "deposit_confirmed";
+    SubscriptionStatus["ACTIVE"] = "active";
+    SubscriptionStatus["EXPIRED"] = "expired";
+    SubscriptionStatus["CANCELLED"] = "cancelled";
+})(SubscriptionStatus || (exports.SubscriptionStatus = SubscriptionStatus = {}));
+let SubscriptionService = SubscriptionService_1 = class SubscriptionService {
+    eventBus;
+    depositWalletService;
+    subscriptionModel;
+    acceptedAssetsRegistry;
+    logger = new common_1.Logger(SubscriptionService_1.name);
+    subscriptionCache = new Map();
+    depositMonitorInterval;
+    expiryCheckInterval;
+    constructor(eventBus, depositWalletService, subscriptionModel, acceptedAssetsRegistry) {
+        this.eventBus = eventBus;
+        this.depositWalletService = depositWalletService;
+        this.subscriptionModel = subscriptionModel;
+        this.acceptedAssetsRegistry = acceptedAssetsRegistry;
+        this.logger.log('SubscriptionService created');
+    }
+    async onModuleInit() {
+        this.logger.log('Initializing SubscriptionService...');
+        await this.loadPendingSubscriptions();
+        this.startDepositMonitoring();
+        this.startExpiryChecking();
+        this.subscribeToEvents();
+        this.logger.log('✓ SubscriptionService initialized');
+    }
+    onModuleDestroy() {
+        if (this.depositMonitorInterval) {
+            clearInterval(this.depositMonitorInterval);
+        }
+        if (this.expiryCheckInterval) {
+            clearInterval(this.expiryCheckInterval);
+        }
+        this.logger.log('SubscriptionService destroyed');
+    }
+    async createSubscription(request) {
+        const { appId, appName, developerAccountId, chain } = request;
+        const selectedTier = request.selectedTier || request.metadata?.selectedTier || 'starter';
+        const selectedNetworks = request.selectedNetworks ||
+            request.metadata?.selectedNetworks || [chain];
+        this.logger.log(`Creating subscription for app ${appId} on ${chain} with tier ${selectedTier}`);
+        try {
+            const existing = await this.getSubscriptionByAppId(appId);
+            if (existing &&
+                existing.status !== SubscriptionStatus.EXPIRED &&
+                existing.status !== SubscriptionStatus.CANCELLED) {
+                return {
+                    success: false,
+                    error: `Active subscription already exists: ${existing.subscriptionId}`,
+                };
+            }
+            const tierConfig = (0, smart_engines_pricing_core_1.getSubscriptionTier)(selectedTier);
+            if (selectedTier === 'free_testnet') {
+                return this.createFreeSubscription({
+                    appId,
+                    appName,
+                    appDescription: request.appDescription,
+                    developerAccountId,
+                    chain,
+                    selectedTier,
+                    selectedNetworks,
+                    tierConfig,
+                    metadata: request.metadata,
+                });
+            }
+            if (request.paymentAsset && this.acceptedAssetsRegistry) {
+                const isAccepted = this.acceptedAssetsRegistry.isAccepted(chain, request.paymentAsset.symbol);
+                if (!isAccepted) {
+                    return {
+                        success: false,
+                        error: `Asset ${request.paymentAsset.symbol} is not accepted on ${chain}`,
+                    };
+                }
+            }
+            return this.createPaidSubscription({
+                appId,
+                appName,
+                appDescription: request.appDescription,
+                developerAccountId,
+                chain,
+                selectedTier,
+                selectedNetworks,
+                tierConfig,
+                paymentAsset: request.paymentAsset,
+                metadata: request.metadata,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Failed to create subscription: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+    async checkSubscriptionStatus(appId) {
+        const subscription = await this.getSubscriptionByAppId(appId);
+        if (!subscription) {
+            return null;
+        }
+        if (subscription.status === SubscriptionStatus.PENDING_DEPOSIT) {
+            const verifyResult = await this.depositWalletService.verifyDeposit(subscription.depositWalletId);
+            if (verifyResult.success && verifyResult.depositConfirmed) {
+                subscription.status = SubscriptionStatus.DEPOSIT_CONFIRMED;
+                subscription.depositConfirmedAt = new Date();
+                this.subscriptionCache.set(appId, subscription);
+                await this.persistSubscription(subscription);
+                await this.eventBus.publishEvent('subscription', 'deposit.verified', {
+                    subscriptionId: subscription.subscriptionId,
+                    appId,
+                    amount: verifyResult.actualAmount,
+                    timestamp: new Date(),
+                });
+            }
+        }
+        return subscription;
+    }
+    async activateSubscription(appId) {
+        this.logger.log(`Activating subscription for app ${appId}`);
+        try {
+            let subscription = await this.getSubscriptionByAppId(appId);
+            if (!subscription) {
+                return {
+                    success: false,
+                    error: 'Subscription not found',
+                };
+            }
+            if (subscription.status === SubscriptionStatus.PENDING_DEPOSIT) {
+                subscription = await this.checkSubscriptionStatus(appId);
+                if (!subscription || subscription.status !== SubscriptionStatus.DEPOSIT_CONFIRMED) {
+                    return {
+                        success: false,
+                        error: 'Deposit not confirmed',
+                    };
+                }
+            }
+            if (subscription.status !== SubscriptionStatus.DEPOSIT_CONFIRMED) {
+                return {
+                    success: false,
+                    error: `Cannot activate subscription in status: ${subscription.status}`,
+                };
+            }
+            const wallet = await this.depositWalletService.getWallet(subscription.depositWalletId);
+            await this.eventBus.publishEvent('subscription', 'nft.mint.request', {
+                subscriptionId: subscription.subscriptionId,
+                appId,
+                appName: subscription.appName,
+                chain: subscription.chain,
+                developerAccountId: subscription.developerAccountId,
+                depositWalletAddress: wallet?.walletAddress,
+                lockedUntil: wallet?.lockedUntil,
+                depositAmount: wallet?.actualDepositAmount || wallet?.depositAmount,
+                timestamp: new Date(),
+            });
+            subscription.status = SubscriptionStatus.ACTIVE;
+            subscription.activatedAt = new Date();
+            subscription.expiresAt = wallet?.lockedUntil;
+            subscription.remainingBalance = wallet?.actualDepositAmount || wallet?.depositAmount;
+            this.subscriptionCache.set(appId, subscription);
+            await this.persistSubscription(subscription);
+            this.logger.log(`✓ Subscription activated for app ${appId}`);
+            return {
+                success: true,
+                subscription,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Failed to activate subscription: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+    async renewSubscription(appId, additionalDays) {
+        this.logger.log(`Renewing subscription for app ${appId}`);
+        try {
+            const subscription = await this.getSubscriptionByAppId(appId);
+            if (!subscription) {
+                return {
+                    success: false,
+                    error: 'Subscription not found',
+                };
+            }
+            if (subscription.status !== SubscriptionStatus.ACTIVE &&
+                subscription.status !== SubscriptionStatus.EXPIRED) {
+                return {
+                    success: false,
+                    error: `Cannot renew subscription in status: ${subscription.status}`,
+                };
+            }
+            const isFreeTier = subscription.tier === 'free_testnet' ||
+                subscription.metadata?.isFreeSubscription === true ||
+                !subscription.depositWalletId;
+            if (isFreeTier) {
+                this.logger.log(`✓ Free-tier subscription for app ${appId} — renew is a no-op`);
+                return { success: true, subscription };
+            }
+            const renewResult = await this.depositWalletService.renewMembership(subscription.depositWalletId, additionalDays);
+            if (!renewResult.success || !renewResult.wallet) {
+                return {
+                    success: false,
+                    error: renewResult.error || 'Failed to renew deposit lock',
+                };
+            }
+            subscription.status = SubscriptionStatus.ACTIVE;
+            subscription.expiresAt = renewResult.wallet.lockedUntil;
+            this.subscriptionCache.set(appId, subscription);
+            await this.persistSubscription(subscription);
+            await this.eventBus.publishEvent('subscription', 'renewed', {
+                subscriptionId: subscription.subscriptionId,
+                appId,
+                newExpiresAt: renewResult.wallet.lockedUntil,
+                timestamp: new Date(),
+            });
+            this.logger.log(`✓ Subscription renewed for app ${appId}`);
+            return {
+                success: true,
+                subscription,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Failed to renew subscription: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+    async deductBalance(appId, amount, reason) {
+        const subscription = await this.getSubscriptionByAppId(appId);
+        if (!subscription) {
+            return {
+                success: false,
+                error: 'Subscription not found',
+            };
+        }
+        if (subscription.status !== SubscriptionStatus.ACTIVE) {
+            return {
+                success: false,
+                error: `Subscription not active: ${subscription.status}`,
+            };
+        }
+        const currentBalance = BigInt(subscription.remainingBalance || '0');
+        const deductAmount = BigInt(amount);
+        if (deductAmount > currentBalance) {
+            return {
+                success: false,
+                error: 'Insufficient balance',
+            };
+        }
+        const newBalance = (currentBalance - deductAmount).toString();
+        subscription.remainingBalance = newBalance;
+        this.subscriptionCache.set(appId, subscription);
+        await this.persistSubscription(subscription);
+        await this.eventBus.publishEvent('subscription', 'balance.deducted', {
+            subscriptionId: subscription.subscriptionId,
+            appId,
+            amount,
+            reason,
+            newBalance,
+            timestamp: new Date(),
+        });
+        return {
+            success: true,
+            newBalance,
+        };
+    }
+    async cancelSubscription(appId, recipientAddress) {
+        this.logger.log(`Processing cancellation for app ${appId}`);
+        try {
+            const subscription = await this.getSubscriptionByAppId(appId);
+            if (!subscription) {
+                return {
+                    success: false,
+                    error: 'Subscription not found',
+                };
+            }
+            if (subscription.status === SubscriptionStatus.CANCELLED) {
+                return {
+                    success: false,
+                    error: 'Subscription is already cancelled',
+                };
+            }
+            if (subscription.subscriptionNftSerial) {
+                this.logger.log(`Requesting NFT revocation for serial ${subscription.subscriptionNftSerial}...`);
+                await this.eventBus.publishEvent('subscription', 'nft.revoke.request', {
+                    subscriptionId: subscription.subscriptionId,
+                    appId,
+                    chain: subscription.chain,
+                    developerAccountId: subscription.developerAccountId,
+                    nftSerial: subscription.subscriptionNftSerial,
+                    chainNfts: subscription.chainNfts,
+                    timestamp: new Date(),
+                });
+            }
+            let depositReleased = false;
+            if (subscription.depositWalletId) {
+                const wallet = await this.depositWalletService.getWallet(subscription.depositWalletId);
+                if (wallet) {
+                    const isExpired = await this.depositWalletService.isDepositExpired(subscription.depositWalletId);
+                    if (isExpired && recipientAddress) {
+                        const releaseResult = await this.depositWalletService.releaseDeposit(subscription.depositWalletId, recipientAddress);
+                        depositReleased = releaseResult.success;
+                        if (depositReleased) {
+                            this.logger.log(`✓ Deposit released to ${recipientAddress}`);
+                        }
+                        else {
+                            this.logger.warn(`⚠️ Deposit release failed: ${releaseResult.error}`);
+                        }
+                    }
+                    else if (!isExpired) {
+                        this.logger.log(`ℹ️ Deposit still locked until ${wallet.lockedUntil}`);
+                    }
+                }
+            }
+            subscription.status = SubscriptionStatus.CANCELLED;
+            this.subscriptionCache.set(appId, subscription);
+            await this.persistSubscription(subscription);
+            await this.eventBus.publishEvent('subscription', 'cancelled', {
+                subscriptionId: subscription.subscriptionId,
+                appId,
+                nftRevoked: !!subscription.subscriptionNftSerial,
+                depositReleased,
+                timestamp: new Date(),
+            });
+            this.logger.log(`✓ Subscription cancelled for app ${appId}`);
+            return {
+                success: true,
+                subscription,
+                depositReleased,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Failed to cancel subscription: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+            };
+        }
+    }
+    async getSubscriptionByAppId(appId) {
+        if (this.subscriptionCache.has(appId)) {
+            return this.subscriptionCache.get(appId);
+        }
+        if (this.subscriptionModel) {
+            const doc = await this.subscriptionModel.findOne({ appId }).exec();
+            if (doc) {
+                const subscription = this.docToSubscription(doc);
+                this.subscriptionCache.set(appId, subscription);
+                return subscription;
+            }
+        }
+        return null;
+    }
+    async getSubscription(subscriptionId) {
+        for (const sub of this.subscriptionCache.values()) {
+            if (sub.subscriptionId === subscriptionId) {
+                return sub;
+            }
+        }
+        if (this.subscriptionModel) {
+            const doc = await this.subscriptionModel.findOne({ subscriptionId }).exec();
+            if (doc) {
+                const subscription = this.docToSubscription(doc);
+                this.subscriptionCache.set(subscription.appId, subscription);
+                return subscription;
+            }
+        }
+        return null;
+    }
+    async hasValidSubscription(appId) {
+        const subscription = await this.getSubscriptionByAppId(appId);
+        if (!subscription)
+            return false;
+        if (subscription.status !== SubscriptionStatus.ACTIVE) {
+            return false;
+        }
+        if (subscription.expiresAt && subscription.expiresAt < new Date()) {
+            subscription.status = SubscriptionStatus.EXPIRED;
+            this.subscriptionCache.set(appId, subscription);
+            await this.persistSubscription(subscription);
+            return false;
+        }
+        if (BigInt(subscription.remainingBalance || '0') <= 0n) {
+            return false;
+        }
+        return true;
+    }
+    async listSubscriptions(filters) {
+        if (this.subscriptionModel) {
+            const query = {};
+            if (filters?.status)
+                query.status = filters.status;
+            if (filters?.chain)
+                query.chain = filters.chain;
+            const docs = await this.subscriptionModel.find(query).exec();
+            return docs.map((doc) => this.docToSubscription(doc));
+        }
+        const subscriptions = Array.from(this.subscriptionCache.values());
+        return subscriptions.filter((sub) => {
+            if (filters?.status && sub.status !== filters.status)
+                return false;
+            if (filters?.chain && sub.chain !== filters.chain)
+                return false;
+            return true;
+        });
+    }
+    generateSubscriptionId(appId) {
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2, 8);
+        return `sub-${appId.substring(0, 8)}-${timestamp}-${random}`;
+    }
+    async createFreeSubscription(params) {
+        const { appId, appName, appDescription, developerAccountId, chain, selectedTier, selectedNetworks, tierConfig, metadata, } = params;
+        this.logger.log(`Creating free tier subscription for app ${appId}`);
+        const subscriptionId = this.generateSubscriptionId(appId);
+        const subscription = {
+            subscriptionId,
+            appId,
+            appName,
+            appDescription,
+            developerAccountId,
+            chain,
+            tier: selectedTier,
+            selectedNetworks,
+            depositWalletId: '',
+            depositWalletAddress: '',
+            status: SubscriptionStatus.ACTIVE,
+            activatedAt: new Date(),
+            createdAt: new Date(),
+            remainingBalance: tierConfig.apiCallsPerDay.toString(),
+            metadata: {
+                ...metadata,
+                selectedTier,
+                selectedNetworks,
+                isFreeSubscription: true,
+            },
+        };
+        this.subscriptionCache.set(appId, subscription);
+        await this.persistSubscription(subscription);
+        await this.eventBus.publishEvent('subscription', 'created', {
+            subscriptionId,
+            appId,
+            chain,
+            tier: selectedTier,
+            selectedNetworks,
+            isFreeSubscription: true,
+            timestamp: new Date(),
+        });
+        this.logger.log(`✓ Free subscription ${subscriptionId} created and activated for app ${appId}`);
+        return {
+            success: true,
+            subscription,
+        };
+    }
+    async createPaidSubscription(params) {
+        const { appId, appName, appDescription, developerAccountId, chain, selectedTier, selectedNetworks, tierConfig, metadata, } = params;
+        this.logger.log(`Creating paid tier (${selectedTier}) subscription for app ${appId}, ` +
+            `deposit: ${tierConfig.monthlyPriceHsuite} HSUITE`);
+        const depositAmount = (tierConfig.monthlyPriceHsuite * 100_000_000).toString();
+        const walletResult = await this.depositWalletService.createDepositWallet({
+            type: 'subscription',
+            ownerId: appId,
+            chain,
+            ownerAccountId: developerAccountId,
+            depositAmount,
+            metadata: {
+                appId,
+                appName,
+                appDescription,
+                developerAccountId,
+                tier: selectedTier,
+                selectedNetworks,
+                ...metadata,
+            },
+        });
+        if (!walletResult.success || !walletResult.wallet) {
+            return {
+                success: false,
+                error: walletResult.error || 'Failed to create deposit wallet',
+            };
+        }
+        const subscriptionId = this.generateSubscriptionId(appId);
+        const subscription = {
+            subscriptionId,
+            appId,
+            appName,
+            appDescription,
+            developerAccountId,
+            chain,
+            tier: selectedTier,
+            selectedNetworks,
+            depositWalletId: walletResult.wallet.walletId,
+            depositWalletAddress: walletResult.wallet.walletAddress,
+            status: SubscriptionStatus.PENDING_DEPOSIT,
+            createdAt: new Date(),
+            metadata: {
+                ...metadata,
+                selectedTier,
+                selectedNetworks,
+                ...(params.paymentAsset ? { paymentAsset: params.paymentAsset } : {}),
+            },
+        };
+        this.subscriptionCache.set(appId, subscription);
+        await this.persistSubscription(subscription);
+        await this.eventBus.publishEvent('subscription', 'created', {
+            subscriptionId,
+            appId,
+            chain,
+            tier: selectedTier,
+            selectedNetworks,
+            depositWalletAddress: walletResult.wallet.walletAddress,
+            depositAmount,
+            timestamp: new Date(),
+        });
+        this.logger.log(`✓ Subscription ${subscriptionId} created for app ${appId}`);
+        const acceptedAssets = this.acceptedAssetsRegistry?.getAcceptedAssets(chain);
+        return {
+            success: true,
+            subscription,
+            depositInstructions: walletResult.depositInstructions
+                ? {
+                    ...walletResult.depositInstructions,
+                    acceptedAssets,
+                }
+                : undefined,
+        };
+    }
+    async loadPendingSubscriptions() {
+        if (!this.subscriptionModel)
+            return;
+        try {
+            const docs = await this.subscriptionModel
+                .find({
+                status: {
+                    $in: [SubscriptionStatus.PENDING_DEPOSIT, SubscriptionStatus.DEPOSIT_CONFIRMED],
+                },
+            })
+                .exec();
+            for (const doc of docs) {
+                const subscription = this.docToSubscription(doc);
+                this.subscriptionCache.set(subscription.appId, subscription);
+            }
+            this.logger.log(`Loaded ${docs.length} pending subscriptions`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to load pending subscriptions: ${error}`);
+        }
+    }
+    startDepositMonitoring() {
+        const intervalMs = parseInt(process.env.DEPOSIT_MONITOR_INTERVAL_MS || '30000', 10);
+        this.depositMonitorInterval = setInterval(async () => {
+            const pending = await this.listSubscriptions({
+                status: SubscriptionStatus.PENDING_DEPOSIT,
+            });
+            for (const sub of pending) {
+                try {
+                    await this.checkSubscriptionStatus(sub.appId);
+                }
+                catch (error) {
+                    this.logger.error(`Error checking deposit for ${sub.appId}: ${error}`);
+                }
+            }
+        }, intervalMs);
+        this.logger.log(`Deposit monitoring started (interval: ${intervalMs}ms)`);
+    }
+    startExpiryChecking() {
+        const intervalMs = parseInt(process.env.EXPIRY_CHECK_INTERVAL_MS || '3600000', 10);
+        this.expiryCheckInterval = setInterval(async () => {
+            const active = await this.listSubscriptions({
+                status: SubscriptionStatus.ACTIVE,
+            });
+            const now = new Date();
+            for (const sub of active) {
+                if (sub.expiresAt && sub.expiresAt < now) {
+                    sub.status = SubscriptionStatus.EXPIRED;
+                    this.subscriptionCache.set(sub.appId, sub);
+                    await this.persistSubscription(sub);
+                    await this.eventBus.publishEvent('subscription', 'expired', {
+                        subscriptionId: sub.subscriptionId,
+                        appId: sub.appId,
+                        expiredAt: sub.expiresAt,
+                        timestamp: new Date(),
+                    });
+                    this.logger.log(`Subscription expired for app ${sub.appId}`);
+                }
+            }
+        }, intervalMs);
+        this.logger.log(`Expiry checking started (interval: ${intervalMs}ms)`);
+    }
+    subscribeToEvents() {
+        this.eventBus.subscribeToEvents('subscription.nft.minted', async (event) => {
+            const { subscriptionId, nftSerial, chainNfts } = event.data;
+            const subscription = await this.getSubscription(subscriptionId);
+            if (subscription) {
+                subscription.subscriptionNftSerial = nftSerial;
+                subscription.chainNfts = chainNfts;
+                this.subscriptionCache.set(subscription.appId, subscription);
+                await this.persistSubscription(subscription);
+                this.logger.log(`NFT minted for subscription ${subscriptionId}: serial ${nftSerial}`);
+            }
+        });
+    }
+    async persistSubscription(subscription) {
+        if (this.subscriptionModel) {
+            await this.subscriptionModel.updateOne({ subscriptionId: subscription.subscriptionId }, { $set: subscription }, { upsert: true });
+        }
+    }
+    docToSubscription(doc) {
+        return {
+            subscriptionId: doc.subscriptionId,
+            appId: doc.appId,
+            appName: doc.appName,
+            appDescription: doc.appDescription,
+            developerAccountId: doc.developerAccountId,
+            chain: doc.chain,
+            tier: doc.tier,
+            selectedNetworks: doc.selectedNetworks,
+            depositWalletId: doc.depositWalletId,
+            depositWalletAddress: doc.depositWalletAddress,
+            status: doc.status,
+            subscriptionNftSerial: doc.subscriptionNftSerial,
+            chainNfts: doc.chainNfts,
+            expiresAt: doc.expiresAt ? new Date(doc.expiresAt) : undefined,
+            remainingBalance: doc.remainingBalance,
+            createdAt: new Date(doc.createdAt),
+            depositConfirmedAt: doc.depositConfirmedAt ? new Date(doc.depositConfirmedAt) : undefined,
+            activatedAt: doc.activatedAt ? new Date(doc.activatedAt) : undefined,
+            metadata: doc.metadata,
+        };
+    }
+};
+exports.SubscriptionService = SubscriptionService;
+exports.SubscriptionService = SubscriptionService = SubscriptionService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, mongoose_1.InjectModel)('Subscription')),
+    __param(3, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [smart_engines_infrastructure_1.EventBusService,
+        deposit_wallet_service_1.DepositWalletService,
+        mongoose_2.Model,
+        smart_engines_pricing_core_1.AcceptedAssetsRegistry])
+], SubscriptionService);
+//# sourceMappingURL=subscription.service.js.map