@wipperoz/wipperoz-core 1.0.0

package/dist/billing/services/accountCreditManager.service.js

@@ -0,0 +1,658 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountCreditManagerService = void 0;
+const costCalculator_service_1 = require("./costCalculator.service");
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const enums_1 = require("../enums");
+const account_service_1 = require("../../account/services/account.service");
+class AccountCreditManagerService {
+    db;
+    tableName;
+    costCalculator;
+    sqsClient;
+    autoTopUpQueueUrl;
+    accountService;
+    constructor(db, tableName, sqsClient, autoTopUpQueueUrl, costCalculator, accountService) {
+        this.db = db;
+        this.tableName = tableName;
+        this.sqsClient = sqsClient;
+        this.autoTopUpQueueUrl = autoTopUpQueueUrl;
+        this.costCalculator = costCalculator ?? new costCalculator_service_1.CostCalculatorService();
+        this.accountService = accountService ?? new account_service_1.AccountService(db, tableName);
+    }
+    /**
+     * Update billing alert settings
+     */
+    async updateAlertSettings(accountId, settings) {
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account?.Details.accountSettings?.billing) {
+            return { success: false, error: 'Account Settings not found' };
+        }
+        const updateExpressions = [];
+        const expressionValues = {};
+        if (settings.lowBalanceThresholdTokens !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.alerts.lowBalanceThresholdTokens = :lowThreshold');
+            expressionValues[':lowThreshold'] = settings.lowBalanceThresholdTokens;
+        }
+        if (settings.lowBalanceAlertSent !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.alerts.lowBalanceAlertSent = :lowSent');
+            expressionValues[':lowSent'] = settings.lowBalanceAlertSent;
+        }
+        if (settings.monthlyReportEnabled !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.alerts.monthlyReportEnabled = :monthlyReport');
+            expressionValues[':monthlyReport'] = settings.monthlyReportEnabled;
+        }
+        if (settings.alertEmails !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.alerts.alertEmails = :alertEmails');
+            expressionValues[':alertEmails'] = settings.alertEmails;
+        }
+        if (!updateExpressions.length) {
+            return { success: true };
+        }
+        try {
+            await this.db.update({
+                TableName: this.tableName,
+                Key: {
+                    Pkey: account.Pkey,
+                    Skey: account.Skey,
+                },
+                UpdateExpression: `SET ${updateExpressions.join(', ')}`,
+                ExpressionAttributeValues: expressionValues,
+            });
+            return { success: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Update failed';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Update spending controls
+     */
+    async updateSpendingControls(accountId, controls) {
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account?.Details.accountSettings?.billing) {
+            return { success: false, error: 'Account Settings not found' };
+        }
+        const updateExpressions = [];
+        const expressionValues = {};
+        if (controls.monthlyBudgetTokens !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.controls.monthlyBudgetTokens = :monthlyBudget');
+            expressionValues[':monthlyBudget'] = controls.monthlyBudgetTokens;
+        }
+        if (controls.budgetAlertThresholdPercent !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.controls.budgetAlertThresholdPercent = :budgetThreshold');
+            expressionValues[':budgetThreshold'] = controls.budgetAlertThresholdPercent;
+        }
+        if (controls.currentMonthSpentTokens !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.controls.currentMonthSpentTokens = :currentMonthSpent');
+            expressionValues[':currentMonthSpent'] = controls.currentMonthSpentTokens;
+        }
+        if (controls.budgetResetDay !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.controls.budgetResetDay = :budgetResetDay');
+            expressionValues[':budgetResetDay'] = controls.budgetResetDay;
+        }
+        if (!updateExpressions.length) {
+            return { success: true };
+        }
+        try {
+            await this.db.update({
+                TableName: this.tableName,
+                Key: {
+                    Pkey: account.Pkey,
+                    Skey: account.Skey,
+                },
+                UpdateExpression: `SET ${updateExpressions.join(', ')}`,
+                ExpressionAttributeValues: expressionValues,
+            });
+            return { success: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Update failed';
+            return { success: false, error: errorMessage };
+        }
+    }
+    async updateStripeCustomerId(accountId, customerId) {
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account?.Details.accountSettings?.billing) {
+            return { success: false, error: 'Account Settings not found' };
+        }
+        try {
+            await this.db.update({
+                TableName: this.tableName,
+                Key: {
+                    Pkey: account.Pkey,
+                    Skey: account.Skey,
+                },
+                UpdateExpression: 'SET Details.accountSettings.billing.stripe.customerId = :customerId',
+                ExpressionAttributeValues: {
+                    ':customerId': customerId,
+                },
+            });
+            return { success: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Update failed';
+            return { success: false, error: errorMessage };
+        }
+    }
+    async updateDefaultPaymentMethod(accountId, paymentMethodId) {
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account?.Details.accountSettings?.billing) {
+            return { success: false, error: 'Account Settings not found' };
+        }
+        try {
+            await this.db.update({
+                TableName: this.tableName,
+                Key: {
+                    Pkey: account.Pkey,
+                    Skey: account.Skey,
+                },
+                UpdateExpression: 'SET Details.accountSettings.billing.stripe.defaultPaymentMethodId = :paymentMethodId',
+                ExpressionAttributeValues: {
+                    ':paymentMethodId': paymentMethodId,
+                },
+            });
+            return { success: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Update failed';
+            return { success: false, error: errorMessage };
+        }
+    }
+    async resetMonthlyCounters(accountId) {
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account?.Details.accountSettings?.billing) {
+            return { success: false, error: 'Account Settings not found' };
+        }
+        try {
+            await this.db.update({
+                TableName: this.tableName,
+                Key: {
+                    Pkey: account.Pkey,
+                    Skey: account.Skey,
+                },
+                UpdateExpression: 'SET Details.accountSettings.billing.controls.currentMonthSpentTokens = :zero, Details.accountSettings.billing.autoTopUp.currentMonthTopUpsTokens = :zero',
+                ExpressionAttributeValues: {
+                    ':zero': 0,
+                },
+            });
+            return { success: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Update failed';
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * Get account balance
+     */
+    async getBalance(accountId) {
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account) {
+            throw new Error(`Account not found: ${accountId}`);
+        }
+        const { billing } = account.Details.accountSettings;
+        return {
+            balanceTokens: billing?.balanceTokens ?? 0,
+            balanceFormatted: (0, utils_1.formatTokens)(billing?.balanceTokens ?? 0),
+            totalSpentTokens: billing?.totalSpentTokens ?? 0,
+            totalDepositedTokens: billing?.totalDepositedTokens ?? 0,
+            displayCurrency: billing?.displayCurrency ?? enums_1.DisplayCurrencyEnum.USD,
+        };
+    }
+    /**
+     * Check if account can afford a request
+     */
+    async canAffordRequest(accountId, estimatedCostTokens) {
+        const balance = await this.getBalance(accountId);
+        const canAfford = balance.balanceTokens >= estimatedCostTokens;
+        const shortfallTokens = canAfford ? undefined : estimatedCostTokens - balance.balanceTokens;
+        return {
+            canAfford,
+            currentBalanceTokens: balance.balanceTokens,
+            shortfallTokens,
+        };
+    }
+    /**
+     * Atomically charge account for an AI request
+     */
+    async chargeAccount(accountId, cost, triggeredBy, metadata) {
+        const transactionId = constants_1.BillingKeys.generateTransactionId();
+        const timestamp = new Date().toISOString();
+        const ttl = constants_1.BillingKeys.calculateTtl(90);
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account) {
+            return {
+                success: false,
+                newBalanceTokens: 0,
+                transactionId,
+                error: 'Account not found',
+            };
+        }
+        const { billing } = account.Details.accountSettings;
+        const chargeAmount = cost.userPriceTokens;
+        if ((billing?.balanceTokens ?? 0) < chargeAmount) {
+            return {
+                success: false,
+                newBalanceTokens: billing?.balanceTokens ?? 0,
+                transactionId,
+                error: 'Insufficient balance',
+            };
+        }
+        // Enforce monthly budget limits when spending controls are configured
+        const controls = billing?.controls;
+        if (controls?.monthlyBudgetTokens && controls.monthlyBudgetTokens > 0) {
+            const currentMonthSpent = controls.currentMonthSpentTokens ?? 0;
+            const projectedSpent = currentMonthSpent + chargeAmount;
+            if (projectedSpent > controls.monthlyBudgetTokens) {
+                return {
+                    success: false,
+                    newBalanceTokens: billing?.balanceTokens ?? 0,
+                    transactionId,
+                    error: 'Monthly budget exceeded',
+                };
+            }
+        }
+        const newBalance = (billing?.balanceTokens ?? 0) - chargeAmount;
+        const transactionDetails = {
+            transactionId,
+            type: enums_1.TransactionTypeEnum.USAGE,
+            amountTokens: chargeAmount,
+            timestamp,
+            triggeredBy,
+            usageMetadata: {
+                ...metadata,
+                costBreakdown: cost,
+            },
+        };
+        try {
+            await this.db.transactWrite({
+                TransactItems: [
+                    {
+                        Update: {
+                            TableName: this.tableName,
+                            Key: {
+                                Pkey: account.Pkey,
+                                Skey: account.Skey,
+                            },
+                            UpdateExpression: `
+                SET Details.accountSettings.billing.balanceTokens = :newBalance,
+                    Details.accountSettings.billing.totalSpentTokens = Details.accountSettings.billing.totalSpentTokens + :charge,
+                    Details.accountSettings.billing.lastAiUsage = :timestamp,
+                    Details.accountSettings.billing.controls.currentMonthSpentTokens = if_not_exists(Details.accountSettings.billing.controls.currentMonthSpentTokens, :zero) + :charge
+              `,
+                            ConditionExpression: 'Details.accountSettings.billing.balanceTokens >= :charge',
+                            ExpressionAttributeValues: {
+                                ':newBalance': newBalance,
+                                ':charge': chargeAmount,
+                                ':timestamp': timestamp,
+                                ':zero': 0,
+                            },
+                        },
+                    },
+                    {
+                        Put: {
+                            TableName: this.tableName,
+                            Item: {
+                                Pkey: constants_1.BillingKeys.accountPkey(accountId),
+                                Skey: constants_1.BillingKeys.creditTransactionSkey(transactionId),
+                                Details: transactionDetails,
+                                Ttl: ttl,
+                            },
+                        },
+                    },
+                ],
+            });
+            return {
+                success: true,
+                newBalanceTokens: newBalance,
+                transactionId,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Transaction failed';
+            return {
+                success: false,
+                newBalanceTokens: billing?.balanceTokens ?? 0,
+                transactionId,
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Add credits to account (from Stripe payment)
+     */
+    async addCredits(accountId, tokens, depositMetadata) {
+        const transactionId = constants_1.BillingKeys.generateTransactionId();
+        const timestamp = new Date().toISOString();
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account) {
+            return {
+                success: false,
+                newBalanceTokens: 0,
+                transactionId,
+                error: 'Account not found',
+            };
+        }
+        const { billing } = account.Details.accountSettings;
+        const newBalance = (billing?.balanceTokens ?? 0) + tokens;
+        const transactionType = depositMetadata.isAutoTopUp ? enums_1.TransactionTypeEnum.AUTO_TOPUP : enums_1.TransactionTypeEnum.DEPOSIT;
+        const transactionDetails = {
+            transactionId,
+            type: transactionType,
+            amountTokens: tokens,
+            timestamp,
+            triggeredBy: transactionType === enums_1.TransactionTypeEnum.AUTO_TOPUP ? 'system' : 'user',
+            depositMetadata,
+        };
+        try {
+            await this.db.transactWrite({
+                TransactItems: [
+                    {
+                        Update: {
+                            TableName: this.tableName,
+                            Key: {
+                                Pkey: account.Pkey,
+                                Skey: account.Skey,
+                            },
+                            UpdateExpression: `
+                SET Details.accountSettings.billing.balanceTokens = :newBalance,
+                    Details.accountSettings.billing.totalDepositedTokens = Details.accountSettings.billing.totalDepositedTokens + :tokens,
+                    Details.accountSettings.billing.lastDeposit = :timestamp,
+                    Details.accountSettings.billing.alerts.lowBalanceAlertSent = :resetAlert
+              `,
+                            ExpressionAttributeValues: {
+                                ':newBalance': newBalance,
+                                ':tokens': tokens,
+                                ':timestamp': timestamp,
+                                ':resetAlert': false,
+                            },
+                        },
+                    },
+                    {
+                        Put: {
+                            TableName: this.tableName,
+                            Item: {
+                                Pkey: constants_1.BillingKeys.accountPkey(accountId),
+                                Skey: constants_1.BillingKeys.creditTransactionSkey(transactionId),
+                                Details: transactionDetails,
+                                // No TTL for deposits
+                            },
+                        },
+                    },
+                ],
+            });
+            return {
+                success: true,
+                newBalanceTokens: newBalance,
+                transactionId,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Transaction failed';
+            return {
+                success: false,
+                newBalanceTokens: billing?.balanceTokens ?? 0,
+                transactionId,
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Apply initial credit for new accounts
+     */
+    async applyInitialCredit(accountId) {
+        const transactionId = constants_1.BillingKeys.generateTransactionId();
+        const timestamp = new Date().toISOString();
+        const initialTokens = constants_1.COST_CONFIG.initialCreditTokens;
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account) {
+            return {
+                success: false,
+                applied: false,
+                error: 'Account not found',
+            };
+        }
+        if (account.Details.accountSettings.billing?.initialCreditApplied) {
+            return {
+                success: true,
+                applied: false, // Already applied
+            };
+        }
+        const newBalance = (account.Details.accountSettings.billing?.balanceTokens ?? 0) + initialTokens;
+        const transactionDetails = {
+            transactionId,
+            type: enums_1.TransactionTypeEnum.INITIAL_CREDIT,
+            amountTokens: initialTokens,
+            timestamp,
+            triggeredBy: 'system',
+            reason: enums_1.CreditReasonEnum.INITIAL_CREDIT,
+        };
+        try {
+            await this.db.transactWrite({
+                TransactItems: [
+                    {
+                        Update: {
+                            TableName: this.tableName,
+                            Key: {
+                                Pkey: account.Pkey,
+                                Skey: account.Skey,
+                            },
+                            UpdateExpression: `
+                SET Details.accountSettings.billing.balanceTokens = :newBalance,
+                    Details.accountSettings.billing.initialCreditApplied = :applied
+              `,
+                            ConditionExpression: 'attribute_not_exists(Details.accountSettings.billing.initialCreditApplied) OR Details.accountSettings.billing.initialCreditApplied = :false',
+                            ExpressionAttributeValues: {
+                                ':newBalance': newBalance,
+                                ':applied': true,
+                                ':false': false,
+                            },
+                        },
+                    },
+                    {
+                        Put: {
+                            TableName: this.tableName,
+                            Item: {
+                                Pkey: constants_1.BillingKeys.accountPkey(accountId),
+                                Skey: constants_1.BillingKeys.creditTransactionSkey(transactionId),
+                                Details: transactionDetails,
+                            },
+                        },
+                    },
+                ],
+            });
+            return {
+                success: true,
+                applied: true,
+                transactionId,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Transaction failed';
+            return {
+                success: false,
+                applied: false,
+                error: errorMessage,
+            };
+        }
+    }
+    /**
+     * Check and trigger auto top-up if needed (async via SQS)
+     */
+    async checkAndTriggerAutoTopUp(accountId) {
+        const account = await this.accountService.getAccountById(accountId);
+        if (!account) {
+            return { triggered: false, reason: 'Account not found' };
+        }
+        const billing = account.Details.accountSettings.billing;
+        if (!billing) {
+            return { triggered: false, reason: 'Billing settings not found' };
+        }
+        const { autoTopUp, stripe } = billing;
+        // Check conditions
+        if (!autoTopUp.enabled) {
+            return { triggered: false, reason: 'Auto top-up disabled' };
+        }
+        if (billing.balanceTokens >= autoTopUp.thresholdTokens) {
+            return { triggered: false, reason: 'Balance above threshold' };
+        }
+        if (autoTopUp?.failedAttempts ?? 0 >= 3) {
+            return { triggered: false, reason: 'Too many failed attempts' };
+        }
+        if (autoTopUp.pausedUntil && new Date(autoTopUp.pausedUntil) > new Date()) {
+            return { triggered: false, reason: 'Auto top-up paused' };
+        }
+        if (!stripe?.customerId || !stripe.defaultPaymentMethodId) {
+            return { triggered: false, reason: 'No payment method configured' };
+        }
+        // Check monthly cap
+        if (autoTopUp.maxMonthlyTopUpsTokens) {
+            const wouldExceed = (autoTopUp.currentMonthTopUpsTokens ?? 0) + autoTopUp.amountTokens > autoTopUp.maxMonthlyTopUpsTokens;
+            if (wouldExceed) {
+                return { triggered: false, reason: 'Monthly cap reached' };
+            }
+        }
+        // Queue auto top-up message
+        const message = {
+            accountId,
+            amountTokens: autoTopUp.amountTokens,
+            displayCurrency: billing.displayCurrency,
+            stripeRegion: stripe.stripeRegion,
+            stripeCustomerId: stripe.customerId,
+            stripePaymentMethodId: stripe.defaultPaymentMethodId,
+            triggeredAt: new Date().toISOString(),
+            currentBalanceTokens: billing.balanceTokens,
+            thresholdTokens: autoTopUp.thresholdTokens,
+            attemptNumber: autoTopUp.failedAttempts ? autoTopUp.failedAttempts + 1 : 1,
+        };
+        await this.sqsClient.send(new client_sqs_1.SendMessageCommand({
+            QueueUrl: this.autoTopUpQueueUrl,
+            MessageBody: JSON.stringify(message),
+        }));
+        return {
+            triggered: true,
+            amountTokens: autoTopUp.amountTokens,
+        };
+    }
+    /**
+     * Get transaction history for account
+     */
+    async getTransactionHistory(accountId, limit = 50, cursor) {
+        const exclusiveStartKey = cursor
+            ? JSON.parse(Buffer.from(cursor, 'base64').toString())
+            : undefined;
+        const result = await this.db.query({
+            TableName: this.tableName,
+            KeyConditionExpression: 'Pkey = :pk AND begins_with(Skey, :sk)',
+            ExpressionAttributeValues: {
+                ':pk': constants_1.BillingKeys.accountPkey(accountId),
+                ':sk': 'credit-txn:',
+            },
+            ScanIndexForward: false,
+            Limit: limit + 1,
+            ...(exclusiveStartKey && { ExclusiveStartKey: exclusiveStartKey }),
+        });
+        const items = result?.Items ?? [];
+        const hasMore = items.length > limit;
+        const transactions = items.slice(0, limit).map(item => {
+            const details = item.Details;
+            return {
+                transactionId: details.transactionId,
+                type: details.type,
+                amountTokens: details.amountTokens,
+                amountFormatted: this.formatTransactionAmount(details),
+                timestamp: details.timestamp,
+                triggeredBy: details.triggeredBy,
+                description: this.getTransactionDescription(details),
+            };
+        });
+        const nextCursor = hasMore && result?.LastEvaluatedKey
+            ? Buffer.from(JSON.stringify(result.LastEvaluatedKey)).toString('base64')
+            : undefined;
+        return {
+            transactions,
+            hasMore,
+            nextCursor,
+        };
+    }
+    /**
+     * Update auto top-up settings
+     */
+    async updateAutoTopUpSettings(accountId, settings) {
+        const accountSettings = await this.accountService.getAccountById(accountId);
+        if (!accountSettings) {
+            return { success: false, error: 'Account Settings not found' };
+        }
+        const updateExpressions = [];
+        const expressionValues = {};
+        if (settings.enabled !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.autoTopUp.enabled = :enabled');
+            expressionValues[':enabled'] = settings.enabled;
+            // Update Data2 for GSI
+            updateExpressions.push('Data2 = :data2');
+            expressionValues[':data2'] = constants_1.BillingKeys.autoTopUpData2(settings.enabled);
+        }
+        if (settings.thresholdTokens !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.autoTopUp.thresholdTokens = :threshold');
+            expressionValues[':threshold'] = settings.thresholdTokens;
+        }
+        if (settings.amountTokens !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.autoTopUp.amountTokens = :amount');
+            expressionValues[':amount'] = settings.amountTokens;
+        }
+        if (settings.maxMonthlyTopUpsTokens !== undefined) {
+            updateExpressions.push('Details.accountSettings.billing.autoTopUp.maxMonthlyTopUpsTokens = :maxMonthly');
+            expressionValues[':maxMonthly'] = settings.maxMonthlyTopUpsTokens;
+        }
+        try {
+            await this.db.update({
+                TableName: this.tableName,
+                Key: {
+                    Pkey: accountSettings.Pkey, // we are not returning the full data
+                    Skey: accountSettings.Skey,
+                },
+                UpdateExpression: `SET ${updateExpressions.join(', ')}`,
+                ExpressionAttributeValues: expressionValues,
+            });
+            return { success: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Update failed';
+            return { success: false, error: errorMessage };
+        }
+    }
+    // ===========================================================================
+    // PRIVATE HELPERS
+    // ===========================================================================
+    formatTransactionAmount(details) {
+        const isCredit = [
+            enums_1.TransactionTypeEnum.DEPOSIT,
+            enums_1.TransactionTypeEnum.INITIAL_CREDIT,
+            enums_1.TransactionTypeEnum.AUTO_TOPUP,
+        ].includes(details.type);
+        const sign = isCredit ? '+' : '-';
+        return `${sign}${details.amountTokens} tokens`;
+    }
+    getTransactionDescription(details) {
+        switch (details.type) {
+            case enums_1.TransactionTypeEnum.USAGE: {
+                const feature = details.usageMetadata?.feature ?? 'AI Request';
+                return `AI Usage - ${feature}`;
+            }
+            case enums_1.TransactionTypeEnum.DEPOSIT:
+                return 'Manual Top-up via Stripe';
+            case enums_1.TransactionTypeEnum.AUTO_TOPUP:
+                return 'Auto Top-up via Stripe';
+            case enums_1.TransactionTypeEnum.INITIAL_CREDIT:
+                return 'Welcome Credit';
+            default:
+                return 'Transaction';
+        }
+    }
+}
+exports.AccountCreditManagerService = AccountCreditManagerService;
+//# sourceMappingURL=accountCreditManager.service.js.map