@casual-simulation/aux-records 3.8.1 → 3.10.2

package/financial/FinancialController.js

@@ -0,0 +1,762 @@
+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;
+};
+import { AccountBalance } from '@casual-simulation/aux-common';
+import { failure, isFailure, logErrors, success, unwrap, } from '@casual-simulation/aux-common';
+import { ACCOUNT_IDS, AccountCodes, AMOUNT_MAX, CREDITS_DISPLAY_FACTOR, CURRENCIES, getAccountCurrency, getFlagsForAccountCode, getFlagsForTransferCode, getMessageForAccountError, LEDGERS, processAccountErrors, processTransferErrors, USD_DISPLAY_FACTOR, } from './FinancialInterface';
+import { AccountFilterFlags, AccountFlags, CreateAccountError, TransferFlags, } from 'tigerbeetle-node';
+import { traced } from '../tracing/TracingDecorators';
+const TRACE_NAME = 'FinancialController';
+export class FinancialController {
+    constructor(financialInterface, financialStore) {
+        this._idempotentKeyMaxAgeMS = 3600000; // 1 hour
+        this._financialInterface = financialInterface;
+        this._financialStore = financialStore;
+    }
+    async init() {
+        // Ensure that the financial interface has the correct accounts
+        const results = await this._financialInterface.createAccounts([
+            {
+                id: ACCOUNT_IDS.assets_cash,
+                code: AccountCodes.assets_cash,
+                flags: getFlagsForAccountCode(AccountCodes.assets_cash),
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.usd,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.assets_stripe,
+                code: AccountCodes.assets_stripe,
+                flags: getFlagsForAccountCode(AccountCodes.assets_stripe),
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.usd,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.revenue_xp_platform_fees,
+                code: AccountCodes.revenue_platform_fees,
+                flags: getFlagsForAccountCode(AccountCodes.revenue_platform_fees),
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.usd,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.revenue_store_platform_fees,
+                code: AccountCodes.revenue_platform_fees,
+                flags: getFlagsForAccountCode(AccountCodes.revenue_platform_fees),
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.usd,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.liquidity_usd,
+                code: AccountCodes.liquidity_pool,
+                flags: getFlagsForAccountCode(AccountCodes.liquidity_pool) |
+                    AccountFlags.debits_must_not_exceed_credits,
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.usd,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.liquidity_credits,
+                code: AccountCodes.liquidity_pool,
+                flags: getFlagsForAccountCode(AccountCodes.liquidity_pool) |
+                    AccountFlags.credits_must_not_exceed_debits,
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.credits,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.USD_SETUP,
+                code: AccountCodes.control,
+                flags: AccountFlags.none,
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.usd,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.USD_LIMIT_CREDITS,
+                code: AccountCodes.control,
+                flags: AccountFlags.credits_must_not_exceed_debits,
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.usd,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.USD_LIMIT_DEBITS,
+                code: AccountCodes.control,
+                flags: AccountFlags.debits_must_not_exceed_credits,
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.usd,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.CREDITS_SETUP,
+                code: AccountCodes.control,
+                flags: AccountFlags.none,
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.credits,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.CREDITS_LIMIT_CREDITS,
+                code: AccountCodes.control,
+                flags: AccountFlags.credits_must_not_exceed_debits,
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.credits,
+                reserved: 0,
+            },
+            {
+                id: ACCOUNT_IDS.CREDITS_LIMIT_DEBITS,
+                code: AccountCodes.control,
+                flags: AccountFlags.debits_must_not_exceed_credits,
+                credits_pending: 0n,
+                credits_posted: 0n,
+                debits_pending: 0n,
+                debits_posted: 0n,
+                user_data_128: 0n,
+                user_data_64: 0n,
+                user_data_32: 0,
+                timestamp: 0n,
+                ledger: LEDGERS.credits,
+                reserved: 0,
+            },
+        ]);
+        let failed = false;
+        for (let result of results) {
+            if (result.result !== CreateAccountError.ok) {
+                console.error(`[FinancialController] Failed to create default accounts (${result.index},${result.result})`, getMessageForAccountError(result.result));
+                failed = true;
+            }
+        }
+        if (failed) {
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'Failed to create default accounts.',
+            });
+        }
+        else {
+            return success();
+        }
+    }
+    generateId() {
+        return this._financialInterface.generateId();
+    }
+    /**
+     * Creates a new account with the given code.
+     * For internal use only.
+     * @param code The code for the new account.
+     * @param ledger The ledger for the new account.
+     */
+    async createAccount(code, ledger) {
+        const id = this._financialInterface.generateId();
+        const results = await this._financialInterface.createAccount({
+            id: id,
+            code: code,
+            flags: getFlagsForAccountCode(code),
+            credits_pending: 0n,
+            credits_posted: 0n,
+            debits_pending: 0n,
+            debits_posted: 0n,
+            user_data_128: 0n,
+            user_data_64: 0n,
+            user_data_32: 0,
+            timestamp: 0n,
+            ledger: ledger,
+            reserved: 0,
+        });
+        const accountErrors = processAccountErrors(results);
+        if (isFailure(accountErrors)) {
+            logErrors(accountErrors.error, '[FinancialController] [createAccount]');
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'Failed to create account.',
+            });
+        }
+        return success({
+            id: id.toString(),
+        });
+    }
+    /**
+     * Gets the account with the given ID.
+     * @param accountId The ID of the account to get.
+     * @returns
+     */
+    async getAccount(accountId) {
+        if (typeof accountId === 'string') {
+            accountId = BigInt(accountId);
+        }
+        const [account] = await this._financialInterface.lookupAccounts([
+            accountId,
+        ]);
+        if (!account) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: `The account with ID '${accountId}' does not exist.`,
+            });
+        }
+        return success(account);
+    }
+    async getTransfer(transferId) {
+        if (typeof transferId === 'string') {
+            transferId = BigInt(transferId);
+        }
+        const transfers = await this._financialInterface.lookupTransfers([
+            transferId,
+        ]);
+        if (transfers.length === 0) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: `The transfer with ID '${transferId}' does not exist.`,
+            });
+        }
+        return success(transfers[0]);
+    }
+    /**
+     * Gets the details for the financial account with the given ID.
+     * @param accountId The ID of the account to get details for.
+     */
+    async getAccountDetails(accountId) {
+        const financialAccount = await this._financialStore.getAccountById(accountId.toString());
+        if (!financialAccount) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: `The financial account does not exist.`,
+            });
+        }
+        const account = await this.getAccount(financialAccount.id);
+        if (isFailure(account)) {
+            return account;
+        }
+        return success({
+            account: account.value,
+            financialAccount,
+        });
+    }
+    /**
+     * Attempts to get the financial account for the given filter.
+     * @param filter The filter to use.
+     */
+    async getFinancialAccount(filter) {
+        const financialAccount = await this._financialStore.getAccountByFilter(filter);
+        if (!financialAccount) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: `The financial account does not exist.`,
+            });
+        }
+        const account = await this.getAccount(financialAccount.id);
+        if (isFailure(account)) {
+            return account;
+        }
+        return success({
+            account: account.value,
+            financialAccount,
+        });
+    }
+    /**
+     * Gets or creates a financial account for the given filter.
+     * @param filter The filter to use.
+     */
+    async getOrCreateFinancialAccount(filter) {
+        let account = await this._financialStore.getAccountByFilter(filter);
+        let accountResult;
+        if (!account) {
+            console.log(`[FinancialController] [getOrCreateFinancialAccount] Creating account for filter [userId: ${filter.userId}, studioId: ${filter.studioId}, contractId: ${filter.contractId}] on ledger ${filter.ledger}`);
+            let result;
+            if (filter.userId) {
+                result = await this.createAccount(AccountCodes.liabilities_user, filter.ledger);
+            }
+            else if (filter.studioId) {
+                result = await this.createAccount(AccountCodes.liabilities_studio, filter.ledger);
+            }
+            else if (filter.contractId) {
+                result = await this.createAccount(AccountCodes.liabilities_contract, filter.ledger);
+            }
+            if (isFailure(result)) {
+                return result;
+            }
+            account = {
+                id: result.value.id.toString(),
+                userId: filter.userId,
+                studioId: filter.studioId,
+                contractId: filter.contractId,
+                ledger: filter.ledger,
+                currency: CURRENCIES.get(filter.ledger),
+            };
+            await this._financialStore.createAccount(account);
+            accountResult = await this.getAccount(result.value.id);
+        }
+        else {
+            accountResult = await this.getAccount(account.id);
+        }
+        if (isFailure(accountResult)) {
+            return accountResult;
+        }
+        return success({
+            account: accountResult.value,
+            financialAccount: account,
+        });
+    }
+    /**
+     * Gets the list of accounts for the given filter.
+     * @param filter The filter to use.
+     */
+    async listAccounts(filter) {
+        const accounts = await this._financialStore.listAccounts(filter);
+        const results = await Promise.all(accounts.map((account) => this.getAccount(account.id)));
+        const errors = results.filter((result) => isFailure(result));
+        if (errors.length > 0) {
+            return failure({
+                errorCode: 'multi_error',
+                errorMessage: 'Some accounts could not be retrieved.',
+                errors: errors.map((e) => e.error),
+            });
+        }
+        return success({
+            accounts: results.map((r) => unwrap(r)),
+        });
+    }
+    /**
+     * Gets the account balances for the given account filter.
+     * @param filter The filter to use.
+     */
+    async getAccountBalances(filter) {
+        const [usdResult, creditsResult] = await Promise.all([
+            this.getAccountBalance({
+                ...filter,
+                ledger: LEDGERS.usd,
+            }),
+            this.getAccountBalance({
+                ...filter,
+                ledger: LEDGERS.credits,
+            }),
+        ]);
+        if (isFailure(usdResult)) {
+            return usdResult;
+        }
+        else if (isFailure(creditsResult)) {
+            return creditsResult;
+        }
+        if (!usdResult.value && !creditsResult.value) {
+            return success(undefined);
+        }
+        return success({
+            usd: usdResult.value,
+            credits: creditsResult.value,
+        });
+    }
+    /**
+     * Gets the balance for the account matching the given filter.
+     * @param filter The filter to use.
+     */
+    async getAccountBalance(filter) {
+        const result = await this.getFinancialAccount(filter);
+        if (isFailure(result)) {
+            if (result.error.errorCode === 'not_found') {
+                return success(undefined);
+            }
+            else {
+                return result;
+            }
+        }
+        return success(this.convertToAccountBalance(result.value.account));
+    }
+    /**
+     * Converts the given account data to an account balance.
+     * @param account The account to convert.
+     */
+    convertToAccountBalance(account) {
+        return new AccountBalance({
+            accountId: account.id.toString(),
+            credits: account.credits_posted,
+            debits: account.debits_posted,
+            pendingCredits: account.credits_pending,
+            pendingDebits: account.debits_pending,
+            currency: getAccountCurrency(account),
+            displayFactor: account.ledger === LEDGERS.credits
+                ? CREDITS_DISPLAY_FACTOR
+                : USD_DISPLAY_FACTOR,
+        });
+    }
+    /**
+     * Transfers funds between two internal accounts.
+     * Suitable for moving money between user accounts and contracts.
+     * Not suitable for interfacing with external systems such as Stripe.
+     *
+     * Not for public use.
+     * @param request The request for the transfer.
+     */
+    async internalTransaction(request) {
+        let transfers = [];
+        const transactionId = typeof request.transactionId === 'string'
+            ? BigInt(request.transactionId)
+            : typeof request.transactionId === 'bigint'
+                ? request.transactionId
+                : this._financialInterface.generateId();
+        for (let i = 0; i < request.transfers.length; i++) {
+            const transfer = request.transfers[i];
+            const transferId = typeof transfer.transferId === 'string'
+                ? BigInt(transfer.transferId)
+                : typeof transfer.transferId === 'bigint'
+                    ? transfer.transferId
+                    : this._financialInterface.generateId();
+            const currency = transfer.currency.toLowerCase();
+            const ledger = LEDGERS[currency];
+            if (typeof ledger !== 'number') {
+                return failure({
+                    errorCode: 'unsupported_currency',
+                    errorMessage: `The currency '${currency}' is not supported.`,
+                    errors: [],
+                });
+            }
+            let flags = getFlagsForTransferCode(transfer.code);
+            let timeout = 0;
+            if (i < request.transfers.length - 1) {
+                flags |= TransferFlags.linked;
+            }
+            if ('pending' in transfer && transfer.pending) {
+                flags |= TransferFlags.pending;
+                if (transfer.timeoutSeconds <= 0) {
+                    return failure({
+                        errorCode: 'invalid_transfer',
+                        errorMessage: 'Pending transfers must have a positive timeoutSeconds value.',
+                        errors: [],
+                    });
+                }
+                timeout = transfer.timeoutSeconds;
+            }
+            if (transfer.balancingCredit) {
+                flags |= TransferFlags.balancing_credit;
+            }
+            if (transfer.balancingDebit) {
+                flags |= TransferFlags.balancing_debit;
+            }
+            if (transfer.closingCredit) {
+                flags |= TransferFlags.closing_credit | TransferFlags.pending;
+            }
+            if (transfer.closingDebit) {
+                flags |= TransferFlags.closing_debit | TransferFlags.pending;
+            }
+            transfers.push({
+                id: transferId,
+                amount: typeof transfer.amount === 'number'
+                    ? BigInt(transfer.amount)
+                    : transfer.amount,
+                code: transfer.code,
+                credit_account_id: BigInt(transfer.creditAccountId),
+                debit_account_id: BigInt(transfer.debitAccountId),
+                flags: flags,
+                ledger: ledger,
+                pending_id: 0n,
+                timeout: 0,
+                timestamp: 0n,
+                user_data_128: transactionId,
+                user_data_64: 0n,
+                user_data_32: 0,
+            });
+        }
+        const results = await this._financialInterface.createTransfers(transfers);
+        const transferResult = processTransferErrors(results, transfers);
+        return this._processTransferResult(transactionId, transfers, transferResult);
+    }
+    async completePendingTransfers(request) {
+        let transfers = [];
+        const transactionId = typeof request.transactionId === 'string'
+            ? BigInt(request.transactionId)
+            : typeof request.transactionId === 'bigint'
+                ? request.transactionId
+                : this._financialInterface.generateId();
+        for (let i = 0; i < request.transfers.length; i++) {
+            const id = request.transfers[i];
+            const transferId = typeof id === 'string' ? BigInt(id) : id;
+            let flags = request.flags ?? TransferFlags.post_pending_transfer;
+            if (i < request.transfers.length - 1) {
+                flags |= TransferFlags.linked;
+            }
+            transfers.push({
+                id: this._financialInterface.generateId(),
+                amount: (flags & TransferFlags.void_pending_transfer) ===
+                    TransferFlags.void_pending_transfer
+                    ? 0n
+                    : AMOUNT_MAX,
+                code: 0,
+                credit_account_id: 0n,
+                debit_account_id: 0n,
+                pending_id: transferId,
+                flags,
+                ledger: 0,
+                timeout: 0,
+                timestamp: 0n,
+                user_data_128: transactionId,
+                user_data_64: 0n,
+                user_data_32: 0,
+            });
+        }
+        const results = await this._financialInterface.createTransfers(transfers);
+        const transferResult = processTransferErrors(results, transfers);
+        return this._processTransferResult(transactionId, transfers, transferResult);
+    }
+    async listTransfers(accountId) {
+        if (typeof accountId === 'string') {
+            accountId = BigInt(accountId);
+        }
+        const transfers = await this._financialInterface.getAccountTransfers({
+            account_id: accountId,
+            code: 0, // 0 means all codes
+            flags: AccountFilterFlags.credits | AccountFilterFlags.debits,
+            limit: 1000, // Limit to 1000 transfers
+            timestamp_max: 0n, // No timestamp limit
+            timestamp_min: 0n, // No timestamp limit
+            user_data_128: 0n, // No user data filter
+            user_data_64: 0n, // No user data filter
+            user_data_32: 0, // No user data filter
+        });
+        return success(transfers);
+    }
+    async queryTransfers(query) {
+        const transfers = await this._financialInterface.queryTransfers({
+            user_data_128: BigInt(query.transactionId ?? 0n),
+            code: query.code ?? 0,
+            flags: 0,
+            ledger: 0,
+            limit: 1000,
+            timestamp_max: 0n,
+            timestamp_min: 0n,
+            user_data_64: 0n,
+            user_data_32: 0,
+        });
+        return success(transfers);
+    }
+    _processTransferResult(transactionId, transfers, transferResult) {
+        if (isFailure(transferResult)) {
+            // logErrors(
+            //     transferResult.error,
+            //     `[XpController] [transfer transactionId: ${transactionId}]`
+            // );
+            const errors = transferResult.error.errors.map(({ transfer, ...e }) => e);
+            const exceedsDebits = transferResult.error.errors.find((e) => e.errorCode === 'exceeds_debits');
+            if (exceedsDebits) {
+                return failure({
+                    errorCode: 'credits_exceed_debits',
+                    errorMessage: 'The transfer would cause the account credits to exceed its debits.',
+                    accountId: exceedsDebits.transfer.credit_account_id.toString(),
+                    errors: errors,
+                });
+            }
+            const exceedsCredits = transferResult.error.errors.find((e) => e.errorCode === 'exceeds_credits');
+            if (exceedsCredits) {
+                return failure({
+                    errorCode: 'debits_exceed_credits',
+                    errorMessage: 'The transfer would cause the account debits to exceed its credits.',
+                    accountId: exceedsCredits.transfer.debit_account_id.toString(),
+                    errors: errors,
+                });
+            }
+            const exists = transferResult.error.errors.find((e) => e.errorCode === 'exists');
+            if (exists) {
+                return failure({
+                    errorCode: 'transfer_already_exists',
+                    errorMessage: `The transfer (${exists.transfer.id}) already exists.`,
+                    errors: errors,
+                });
+            }
+            const completed = transferResult.error.errors.find((e) => e.errorCode === 'already_posted' ||
+                e.errorCode === 'already_voided');
+            if (completed) {
+                return failure({
+                    errorCode: 'transfer_already_completed',
+                    errorMessage: `The transfer (${completed.transfer.pending_id}) has already been posted/voided.`,
+                    errors: errors,
+                });
+            }
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'An error occurred while transferring the funds.',
+                errors: errors,
+            });
+        }
+        return success({
+            transactionId: transactionId.toString(),
+            transferIds: transfers.map((t) => t.id.toString()),
+        });
+    }
+}
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "init", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "createAccount", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "getAccount", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "getTransfer", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "getAccountDetails", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "getFinancialAccount", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "getOrCreateFinancialAccount", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "listAccounts", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "getAccountBalances", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "getAccountBalance", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "internalTransaction", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "completePendingTransfers", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "listTransfers", null);
+__decorate([
+    traced(TRACE_NAME)
+], FinancialController.prototype, "queryTransfers", null);
+/**
+ * Gets the balance of the given account.
+ *
+ * For asset accounts, the balance is calculated as: debits_posted - credits_posted.
+ * For liability accounts, the balance is calculated as: credits_posted - debits_posted.
+ * For revenue accounts, the balance is calculated as: credits_posted - debits_posted.
+ *
+ * @param account The account to get the balance of.
+ * @returns
+ */
+export function getAccountBalance(account) {
+    switch (account.code) {
+        case AccountCodes.assets_cash:
+            return getAssetAccountBalance(account);
+        case AccountCodes.liabilities_user:
+        case AccountCodes.liabilities_contract:
+        case AccountCodes.revenue_platform_fees:
+            return getLiabilityAccountBalance(account);
+        case AccountCodes.liquidity_pool:
+            return getLiquidityPoolBalance(account);
+        // Add other cases for different account codes as needed
+        default:
+            throw new Error(`Unsupported account code: ${account.code}`);
+    }
+}
+/**
+ * Gets the balance of the given liability account.
+ * For liability accounts, the balance is calculated as: credits_posted - debits_posted.
+ * @param account The account to get the balance of.
+ */
+export function getLiabilityAccountBalance(account) {
+    return Number(account.credits_posted -
+        account.debits_posted -
+        (account.credits_pending - account.debits_pending));
+}
+/**
+ * Gets the balance of the given asset account.
+ * For asset accounts, the balance is calculated as: debits_posted - credits_posted.
+ * @param account The account to get the balance of.
+ */
+export function getAssetAccountBalance(account) {
+    return Number(account.debits_posted -
+        account.credits_posted -
+        (account.debits_pending - account.credits_pending));
+}
+/**
+ * Gets the balance of the given liquidity pool account.
+ * For liquidity accounts, the balance is calculated as: debits_posted - credits_posted.
+ * @param account The account to get the balance of.
+ */
+export function getLiquidityPoolBalance(account) {
+    return Number(account.debits_posted -
+        account.credits_posted -
+        (account.debits_pending - account.credits_pending));
+}
+//# sourceMappingURL=FinancialController.js.map