@casual-simulation/aux-records 3.8.2-alpha.19511653187 → 3.10.3-alpha.20787554310

package/SubscriptionController.js

@@ -5,22 +5,48 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { INVALID_KEY_ERROR_MESSAGE } from './AuthController';
-import { STRIPE_EVENT_INVOICE_PAID_SCHEMA } from './StripeInterface';
+import { STRIPE_EVENT_ACCOUNT_UPDATED_SCHEMA, STRIPE_EVENT_CHECKOUT_SESSION_SCHEMA, STRIPE_EVENT_INVOICE_PAID_SCHEMA, } from './StripeInterface';
 import { isActiveSubscription } from './Utils';
+import { getContractFeatures, getPurchasableItemsFeatures, } from './SubscriptionConfiguration';
 import { traced } from './tracing/TracingDecorators';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
-import { isSuperUserRole } from '@casual-simulation/aux-common';
+import { failure, genericResult, isFailure, isSuccess, isSuperUserRole, logError, success, wrap, } from '@casual-simulation/aux-common';
 const TRACE_NAME = 'SubscriptionController';
+import { ADMIN_ROLE_NAME, fromBase64String, toBase64String, } from '@casual-simulation/aux-common';
+import { v4 as uuid } from 'uuid';
+import { hashHighEntropyPasswordWithSalt } from '@casual-simulation/crypto';
+import { randomBytes } from 'tweetnacl';
+import { fromByteArray } from 'base64-js';
+import { ACCOUNT_IDS, ACCOUNT_NAMES, AMOUNT_MAX, convertBetweenLedgers, CURRENCIES, CurrencyCodes, getAccountBalance, getLiquidityAccountByLedger, LEDGERS, TransferCodes, } from './financial';
+import { TransferFlags } from 'tigerbeetle-node';
+/**
+ * The number of bytes that the access key secret should be.
+ */
+export const ACCESS_KEY_SECRET_BYTE_LENGTH = 16; // 128-bit
+/**
+ * The number of bytes that the access key ID should be.
+ */
+export const ACCESS_KEY_ID_BYTE_LENGTH = 16; // 128-bit
+/**
+ * The number of seconds to wait before a Stripe payout transfer times out.
+ */
+export const STRIPE_PAYOUT_TIMEOUT_SECONDS = 60 * 5; // 5 minutes
 /**
  * Defines a class that is able to handle subscriptions.
  */
 export class SubscriptionController {
-    constructor(stripe, auth, authStore, recordsStore, config) {
+    constructor(stripe, auth, authStore, recordsStore, config, policies, policyStore, purchasableItems, financialController, financialStore, contractRecords) {
         this._stripe = stripe;
         this._auth = auth;
         this._authStore = authStore;
         this._recordsStore = recordsStore;
         this._config = config;
+        this._policies = policies;
+        this._policyStore = policyStore;
+        this._purchasableItems = purchasableItems;
+        this._financialController = financialController;
+        this._financialStore = financialStore;
+        this._contractRecords = contractRecords;
     }
     async _getConfig() {
         return await this._config.getSubscriptionConfiguration();
@@ -30,7 +56,6 @@ export class SubscriptionController {
      * @param request
      */
     async getSubscriptionStatus(request) {
-        var _a, _b;
         if (!this._stripe) {
             return {
                 success: false,
@@ -74,6 +99,7 @@ export class SubscriptionController {
                 };
             }
             const keyResult = await this._auth.validateSessionKey(request.sessionKey);
+            let accountBalances = success(undefined);
             let customerId;
             let role;
             if (keyResult.success === false) {
@@ -93,6 +119,12 @@ export class SubscriptionController {
                     const user = await this._authStore.findUser(request.userId);
                     customerId = user.stripeCustomerId;
                     role = 'user';
+                    if (this._financialController) {
+                        accountBalances =
+                            await this._financialController.getAccountBalances({
+                                userId: request.userId,
+                            });
+                    }
                 }
                 else if (request.studioId) {
                     const assignments = await this._recordsStore.listStudioAssignments(request.studioId, {
@@ -111,19 +143,30 @@ export class SubscriptionController {
                     const studio = await this._recordsStore.getStudioById(request.studioId);
                     customerId = studio.stripeCustomerId;
                     role = 'studio';
+                    if (this._financialController) {
+                        accountBalances =
+                            await this._financialController.getAccountBalances({
+                                studioId: request.studioId,
+                            });
+                    }
                 }
             }
+            if (isFailure(accountBalances)) {
+                logError(accountBalances.error, '[SubscriptionController] [getSubscriptionStatus] Failed to get account balances:');
+                return genericResult(accountBalances);
+            }
             // const user = await this._authStore.findUser(keyResult.userId);
             // let customerId = user.stripeCustomerId;
             if (!customerId) {
                 const config = await this._getConfig();
                 return {
                     success: true,
-                    userId: (_a = request.userId) !== null && _a !== void 0 ? _a : keyResult.userId,
+                    userId: request.userId ?? keyResult.userId,
                     studioId: request.studioId,
                     publishableKey: this._stripe.publishableKey,
                     subscriptions: [],
                     purchasableSubscriptions: await this._getPurchasableSubscriptions(role, config),
+                    accountBalances: accountBalances.value,
                 };
             }
             const listResult = await this._stripe.listActiveSubscriptionsForCustomer(customerId);
@@ -134,7 +177,7 @@ export class SubscriptionController {
                     return (sub.eligibleProducts &&
                         sub.eligibleProducts.some((p) => p === item.price.product.id));
                 });
-                const featureList = subscriptionInfo === null || subscriptionInfo === void 0 ? void 0 : subscriptionInfo.featureList;
+                const featureList = subscriptionInfo?.featureList;
                 return {
                     active: s.status === 'active',
                     statusCode: s.status,
@@ -157,17 +200,18 @@ export class SubscriptionController {
                 : await this._getPurchasableSubscriptions(role, config);
             return {
                 success: true,
-                userId: (_b = request.userId) !== null && _b !== void 0 ? _b : keyResult.userId,
+                userId: request.userId ?? keyResult.userId,
                 studioId: request.studioId,
                 publishableKey: this._stripe.publishableKey,
                 subscriptions,
                 purchasableSubscriptions,
+                accountBalances: accountBalances.value,
             };
         }
         catch (err) {
             const span = trace.getActiveSpan();
-            span === null || span === void 0 ? void 0 : span.recordException(err);
-            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            span?.recordException(err);
+            span?.setStatus({ code: SpanStatusCode.ERROR });
             console.error('[SubscriptionController] An error occurred while getting subscription status:', err);
             return {
                 success: false,
@@ -176,6 +220,136 @@ export class SubscriptionController {
             };
         }
     }
+    /**
+     * Gets the account balances for the user/studio/contract.
+     * @param request
+     */
+    async getBalances(request) {
+        if (!this._financialController) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This feature is not supported.',
+            });
+        }
+        const authorizationResult = await this._checkAuthorizationForFilter(request.filter, request.userId, request.userRole);
+        if (isFailure(authorizationResult)) {
+            return authorizationResult;
+        }
+        return await this._financialController.getAccountBalances(request.filter);
+    }
+    async _checkAuthorizationForFilter(filter, userId, userRole) {
+        if (!this._financialController) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This feature is not supported.',
+            });
+        }
+        // Check if the user has permission to access this account
+        if (!isSuperUserRole(userRole)) {
+            // Users can only access their own accounts
+            if ('userId' in filter && filter.userId) {
+                if (filter.userId !== userId) {
+                    return failure({
+                        errorCode: 'not_authorized',
+                        errorMessage: 'You are not authorized to perform this action.',
+                    });
+                }
+            }
+            else if ('studioId' in filter && filter.studioId) {
+                const assignments = await this._recordsStore.listStudioAssignments(filter.studioId, {
+                    role: 'admin',
+                });
+                const userAssignment = assignments.find((a) => a.userId === userId);
+                if (!userAssignment || userAssignment.role !== 'admin') {
+                    return failure({
+                        errorCode: 'not_authorized',
+                        errorMessage: 'You are not authorized to perform this action.',
+                    });
+                }
+            }
+            else if ('contractId' in filter && filter.contractId) {
+                const contract = await this._contractRecords.getItemById(filter.contractId);
+                if (!contract) {
+                    return failure({
+                        errorCode: 'not_found',
+                        errorMessage: 'The contract was not found.',
+                    });
+                }
+                // Holding and issuing users can read contract accounts by default.
+                // Other users need an explicit check
+                if (contract.contract.holdingUserId !== userId &&
+                    contract.contract.issuingUserId !== userId) {
+                    const context = await this._policies.constructAuthorizationContext({
+                        recordKeyOrRecordName: contract.recordName,
+                        userId: userId,
+                        userRole: userRole,
+                    });
+                    if (context.success === false) {
+                        return failure(context);
+                    }
+                    const authorization = await this._policies.authorizeSubject(context, {
+                        action: 'read',
+                        resourceKind: 'contract',
+                        resourceId: contract.contract.address,
+                        subjectType: 'user',
+                        subjectId: userId,
+                        markers: contract.contract.markers,
+                    });
+                    if (authorization.success === false) {
+                        return failure(authorization);
+                    }
+                }
+            }
+        }
+        return success();
+    }
+    /**
+     * Lists the transfers for the given account.
+     * @param request The request.
+     */
+    async listAccountTransfers(request) {
+        if (!this._financialController) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This feature is not supported.',
+            });
+        }
+        // Get the account details to verify it exists and get permissions info
+        const accountDetailsResult = await this._financialController.getAccountDetails(request.accountId);
+        if (isFailure(accountDetailsResult)) {
+            return accountDetailsResult;
+        }
+        const { account, financialAccount } = accountDetailsResult.value;
+        const authorizationResult = await this._checkAuthorizationForFilter(financialAccount, request.userId, request.userRole);
+        if (isFailure(authorizationResult)) {
+            return authorizationResult;
+        }
+        // Get the transfers for this account
+        const transfersResult = await this._financialController.listTransfers(request.accountId);
+        if (isFailure(transfersResult)) {
+            return transfersResult;
+        }
+        const transfers = transfersResult.value;
+        // Map Transfer objects to AccountTransfer objects
+        const accountTransfers = transfers.map((transfer) => ({
+            id: transfer.id.toString(),
+            amount: transfer.amount,
+            debitAccountId: transfer.debit_account_id.toString(),
+            creditAccountId: transfer.credit_account_id.toString(),
+            pending: (transfer.flags & TransferFlags.pending) !== 0,
+            code: transfer.code,
+            timeMs: Number(transfer.timestamp / 1000000n), // Convert nanoseconds to milliseconds
+            transactionId: transfer.user_data_128 !== 0n
+                ? transfer.user_data_128.toString()
+                : undefined,
+            note: charactarizeTransfer(transfer),
+        }));
+        return success({
+            accountDetails: financialAccount,
+            account: this._financialController.convertToAccountBalance(account),
+            transfers: accountTransfers,
+        });
+    }
     /**
      * Attempts to update the subscription for the given user.
      * @param request The request to update the subscription.
@@ -280,8 +454,8 @@ export class SubscriptionController {
         }
         catch (err) {
             const span = trace.getActiveSpan();
-            span === null || span === void 0 ? void 0 : span.recordException(err);
-            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            span?.recordException(err);
+            span?.setStatus({ code: SpanStatusCode.ERROR });
             console.error('[SubscriptionController] An error occurred while updating a subscription:', err);
             return {
                 success: false,
@@ -292,10 +466,9 @@ export class SubscriptionController {
     }
     _getPurchasableSubscriptionsForRole(role, config) {
         return config.subscriptions.filter((s) => {
-            var _a, _b, _c;
-            const isPurchasable = (_a = s.purchasable) !== null && _a !== void 0 ? _a : true;
-            const isUserOnly = (_b = s.userOnly) !== null && _b !== void 0 ? _b : false;
-            const isStudioOnly = (_c = s.studioOnly) !== null && _c !== void 0 ? _c : false;
+            const isPurchasable = s.purchasable ?? true;
+            const isUserOnly = s.userOnly ?? false;
+            const isStudioOnly = s.studioOnly ?? false;
             const matchesRole = (isUserOnly && role === 'user') ||
                 (isStudioOnly && role === 'studio') ||
                 (!isUserOnly && !isStudioOnly);
@@ -354,7 +527,6 @@ export class SubscriptionController {
      * Returns a link that the user can be redirected to to initiate a purchase of the subscription.
      */
     async createManageSubscriptionLink(request) {
-        var _a;
         if (!this._stripe) {
             return {
                 success: false,
@@ -537,7 +709,7 @@ export class SubscriptionController {
             if (hasSubscription) {
                 console.log(`[SubscriptionController] [createManageSubscriptionLink] Customer has a managable subscription. Creating a portal session.`);
                 const session = await this._stripe.createPortalSession({
-                    ...((_a = config.portalConfig) !== null && _a !== void 0 ? _a : {}),
+                    ...(config.portalConfig ?? {}),
                     customer: customerId,
                     return_url: returnRoute(config.returnUrl, user, studio),
                 });
@@ -552,8 +724,8 @@ export class SubscriptionController {
         }
         catch (err) {
             const span = trace.getActiveSpan();
-            span === null || span === void 0 ? void 0 : span.recordException(err);
-            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            span?.recordException(err);
+            span?.setStatus({ code: SpanStatusCode.ERROR });
             console.error('[SubscriptionController] An error occurred while creating a manage subscription link:', err);
             return {
                 success: false,
@@ -562,8 +734,296 @@ export class SubscriptionController {
             };
         }
     }
+    /**
+     * Creates a link that the user can be redirected to in order to manage their store account.
+     * @param request The request to create the manage store account link.
+     * @returns
+     */
+    async createManageStoreAccountLink(request) {
+        if (!this._stripe) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This method is not supported.',
+            });
+        }
+        let studio = await this._recordsStore.getStudioById(request.studioId);
+        if (!studio) {
+            return failure({
+                errorCode: 'studio_not_found',
+                errorMessage: 'The given studio was not found.',
+            });
+        }
+        const assignments = await this._recordsStore.listStudioAssignments(studio.id, {
+            userId: request.userId,
+            role: ADMIN_ROLE_NAME,
+        });
+        if (assignments.length <= 0) {
+            return failure({
+                errorCode: 'not_authorized',
+                errorMessage: 'You are not authorized to perform this action.',
+            });
+        }
+        const config = await this._config.getSubscriptionConfiguration();
+        const features = getPurchasableItemsFeatures(config, studio.subscriptionStatus, studio.subscriptionId, 'studio', studio.subscriptionPeriodStartMs, studio.subscriptionPeriodEndMs);
+        if (!features.allowed) {
+            return failure({
+                errorCode: 'not_authorized',
+                errorMessage: 'You are not authorized to perform this action.',
+            });
+        }
+        let type = 'account_update';
+        if (!studio.stripeAccountId) {
+            console.log('[SubscriptionController] [createManageStoreAccountLink] Studio does not have a stripe account. Creating one.');
+            type = 'account_onboarding';
+            const account = await this._stripe.createAccount({
+                controller: {
+                    fees: {
+                        payer: 'account',
+                    },
+                    losses: {
+                        payments: 'stripe',
+                    },
+                    requirement_collection: 'stripe',
+                    stripe_dashboard: {
+                        type: 'full',
+                    },
+                },
+                metadata: {
+                    studioId: studio.id,
+                },
+            });
+            console.log('[SubscriptionController] [createManageStoreAccountLink] Created account:', account.id);
+            studio = {
+                ...studio,
+                stripeAccountId: account.id,
+                stripeAccountStatus: getAccountStatus(account),
+                stripeAccountRequirementsStatus: getAccountRequirementsStatus(account),
+            };
+            await this._recordsStore.updateStudio(studio);
+        }
+        if (studio.stripeAccountRequirementsStatus === 'incomplete') {
+            type = 'account_onboarding';
+        }
+        const session = await this._stripe.createAccountLink({
+            account: studio.stripeAccountId,
+            refresh_url: config.returnUrl,
+            return_url: config.returnUrl,
+            type,
+        });
+        return success({
+            url: session.url,
+        });
+    }
+    /**
+     * Creates a link that the user can be redirected to in order to manage their stripe XP account.
+     * @param request The request to create the manage xp account link.
+     */
+    async createManageXpAccountLink(request) {
+        if (!this._stripe || !this._financialController) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This method is not supported.',
+            });
+        }
+        let user = await this._authStore.findUser(request.userId);
+        if (!user) {
+            console.log('[SubscriptionController] [createManageXpAccountLink] User not found.');
+            return failure({
+                errorCode: 'user_not_found',
+                errorMessage: 'The user was not found.',
+            });
+        }
+        let updatedUser = false;
+        const config = await this._config.getSubscriptionConfiguration();
+        const account = await this._financialController.getOrCreateFinancialAccount({
+            userId: user.id,
+            ledger: LEDGERS.usd,
+        });
+        if (isFailure(account)) {
+            logError(account.error, `[SubscriptionController] [createManageXpAccountLink] Failed to get USD financial account for user: ${user.id}`);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'Failed to get financial account.',
+            });
+        }
+        if (!user.stripeAccountId) {
+            console.log('[SubscriptionController] [createManageXpAccountLink] User does not have a stripe account. Creating one.');
+            const account = await this._stripe.createAccount({
+                controller: {
+                    fees: {
+                        payer: 'application',
+                    },
+                    losses: {
+                        payments: 'application',
+                    },
+                    requirement_collection: 'stripe',
+                    stripe_dashboard: {
+                        type: 'express',
+                    },
+                },
+                metadata: {
+                    userId: user.id,
+                },
+            });
+            console.log('[SubscriptionController] [createManageXpAccountLink] Created account:', account.id);
+            user = {
+                ...user,
+                stripeAccountId: account.id,
+                stripeAccountStatus: getAccountStatus(account),
+                stripeAccountRequirementsStatus: getAccountRequirementsStatus(account),
+            };
+            updatedUser = true;
+        }
+        if (updatedUser) {
+            await this._authStore.saveUser(user);
+        }
+        const session = await this._stripe.createAccountLink({
+            account: user.stripeAccountId,
+            refresh_url: config.returnUrl,
+            return_url: config.returnUrl,
+            // We have to always use onboarding because Stripe is responsible for collecting requirements
+            type: 'account_onboarding',
+        });
+        return success({
+            url: session.url,
+        });
+    }
+    /**
+     * Creates a link that the user can be redirected to in order to login to their stripe account.
+     * @param request The request to create the manage xp account link.
+     */
+    async createStripeLoginLink(request) {
+        if (!this._stripe || !this._financialController) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This method is not supported.',
+            });
+        }
+        let user = await this._authStore.findUser(request.userId);
+        if (!user) {
+            console.log('[SubscriptionController] [createStripeLoginLink] User not found.');
+            return failure({
+                errorCode: 'user_not_found',
+                errorMessage: 'The user was not found.',
+            });
+        }
+        let accountId;
+        if (request.studioId) {
+            let studio = await this._recordsStore.getStudioById(request.studioId);
+            if (!studio) {
+                return failure({
+                    errorCode: 'studio_not_found',
+                    errorMessage: 'The given studio was not found.',
+                });
+            }
+            const assignments = await this._recordsStore.listStudioAssignments(studio.id, {
+                userId: request.userId,
+                role: ADMIN_ROLE_NAME,
+            });
+            if (assignments.length <= 0) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to perform this action.',
+                });
+            }
+            const config = await this._config.getSubscriptionConfiguration();
+            const features = getPurchasableItemsFeatures(config, studio.subscriptionStatus, studio.subscriptionId, 'studio', studio.subscriptionPeriodStartMs, studio.subscriptionPeriodEndMs);
+            if (!features.allowed) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to perform this action.',
+                });
+            }
+            accountId = studio.stripeAccountId;
+        }
+        else {
+            accountId = user.stripeAccountId;
+        }
+        if (!accountId) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: 'No Stripe account found.',
+            });
+        }
+        const session = await this._stripe.createLoginLink({
+            account: accountId,
+        });
+        return success({
+            url: session.url,
+        });
+    }
+    /**
+     * Creates a session that can be used to display stripe embedded components for the user.
+     * @param request The request to create the account session.
+     */
+    async createStripeAccountSession(request) {
+        if (!this._stripe || !this._financialController) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This method is not supported.',
+            });
+        }
+        let user = await this._authStore.findUser(request.userId);
+        if (!user) {
+            console.log('[SubscriptionController] [createStripeAccountSession] User not found.');
+            return failure({
+                errorCode: 'user_not_found',
+                errorMessage: 'The user was not found.',
+            });
+        }
+        let accountId;
+        if (request.studioId) {
+            let studio = await this._recordsStore.getStudioById(request.studioId);
+            if (!studio) {
+                return failure({
+                    errorCode: 'studio_not_found',
+                    errorMessage: 'The given studio was not found.',
+                });
+            }
+            const assignments = await this._recordsStore.listStudioAssignments(studio.id, {
+                userId: request.userId,
+                role: ADMIN_ROLE_NAME,
+            });
+            if (assignments.length <= 0) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to perform this action.',
+                });
+            }
+            const config = await this._config.getSubscriptionConfiguration();
+            const features = getPurchasableItemsFeatures(config, studio.subscriptionStatus, studio.subscriptionId, 'studio', studio.subscriptionPeriodStartMs, studio.subscriptionPeriodEndMs);
+            if (!features.allowed) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to perform this action.',
+                });
+            }
+            accountId = studio.stripeAccountId;
+        }
+        else {
+            accountId = user.stripeAccountId;
+        }
+        if (!accountId) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: 'No Stripe account found for the user.',
+            });
+        }
+        const session = await this._stripe.createAccountSession({
+            account: user.stripeAccountId,
+            components: {
+                payouts: {
+                    enabled: true,
+                    features: {},
+                },
+            },
+        });
+        return success({
+            clientSecret: session.client_secret,
+            expiresAt: session.expires_at,
+        });
+    }
     async _createCheckoutSession(request, customerId, metadata, role, user, studio) {
-        var _a;
         const config = await this._getConfig();
         const purchasableSubscriptions = this._getPurchasableSubscriptionsForRole(role, config);
         let sub;
@@ -600,7 +1060,7 @@ export class SubscriptionController {
         }
         console.log(`[SubscriptionController] [createManageSubscriptionLink] Creating Checkout Session.`);
         const session = await this._stripe.createCheckoutSession({
-            ...((_a = config.checkoutConfig) !== null && _a !== void 0 ? _a : {}),
+            ...(config.checkoutConfig ?? {}),
             customer: customerId,
             success_url: returnRoute(config.successUrl, user, studio),
             cancel_url: returnRoute(config.cancelUrl, user, studio),
@@ -620,228 +1080,2312 @@ export class SubscriptionController {
         };
     }
     /**
-     * Handles the webhook from Stripe for updating the internal database.
+     * Creates a link that the user can be redirected to in order to purchase a purchasable item.
+     * @param request The request to create the purchase item link.
      */
-    async handleStripeWebhook(request) {
-        var _a;
-        if (!this._stripe) {
-            return {
-                success: false,
-                errorCode: 'not_supported',
-                errorMessage: 'This method is not supported.',
-            };
-        }
+    async createPurchaseItemLink(request) {
         try {
-            if (typeof request.requestBody !== 'string' ||
-                request.requestBody === '') {
+            const context = await this._policies.constructAuthorizationContext({
+                recordKeyOrRecordName: request.item.recordName,
+                userId: request.userId,
+            });
+            if (context.success === false) {
+                return context;
+            }
+            const item = await this._purchasableItems.getItemByAddress(request.item.recordName, request.item.address);
+            if (!item) {
                 return {
                     success: false,
-                    errorCode: 'invalid_request',
-                    errorMessage: 'The request was not valid.',
+                    errorCode: 'item_not_found',
+                    errorMessage: 'The item could not be found.',
                 };
             }
-            if (typeof request.signature !== 'string' ||
-                request.signature === '') {
+            if (item.currency !== request.item.currency ||
+                item.cost !== request.item.expectedCost) {
                 return {
                     success: false,
-                    errorCode: 'invalid_request',
-                    errorMessage: 'The request was not valid.',
+                    errorCode: 'price_does_not_match',
+                    errorMessage: 'The expected price does not match the actual price of the item.',
                 };
             }
+            const recordName = context.context.recordName;
+            const authorization = await this._policies.authorizeUserAndInstances(context.context, {
+                userId: request.userId,
+                resourceKind: 'purchasableItem',
+                resourceId: item.address,
+                markers: item.markers,
+                action: 'purchase',
+                instances: request.instances,
+            });
+            if (authorization.success === false) {
+                return authorization;
+            }
+            const metrics = await this._purchasableItems.getSubscriptionMetrics({
+                ownerId: context.context.recordOwnerId,
+                studioId: context.context.recordStudioId,
+            });
             const config = await this._getConfig();
-            const body = request.requestBody;
-            const signature = request.signature;
-            let event;
-            try {
-                event = this._stripe.constructWebhookEvent(body, signature, config.webhookSecret);
+            const features = getPurchasableItemsFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, 'studio', metrics.currentPeriodStartMs, metrics.currentPeriodEndMs);
+            if (!features.allowed) {
+                console.log(`[SubscriptionController] [createPurchaseItemLink studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} subscriptionStatus: ${metrics.subscriptionStatus}] Store features not allowed.`);
+                return {
+                    success: false,
+                    errorCode: 'store_disabled',
+                    errorMessage: 'The store you are trying to purchase from is disabled.',
+                };
             }
-            catch (err) {
-                console.log(`[SubscriptionController] [handleStripeWebhook] Unable to construct webhook event:`, err);
+            if (!metrics.stripeAccountId || !metrics.stripeAccountStatus) {
+                console.log(`[SubscriptionController] [createPurchaseItemLink studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} subscriptionStatus: ${metrics.subscriptionStatus} stripeAccountId: ${metrics.stripeAccountId} stripeAccountStatus: ${metrics.stripeAccountStatus}] Store has no stripe account.`);
                 return {
                     success: false,
-                    errorCode: 'invalid_request',
-                    errorMessage: 'The request was not valid.',
+                    errorCode: 'store_disabled',
+                    errorMessage: 'The store you are trying to purchase from is disabled.',
                 };
             }
-            console.log(`[SubscriptionController] [handleStripeWebhook] Got event: ${event.type}`);
-            if (event.type === 'customer.subscription.created' ||
-                event.type === 'customer.subscription.deleted' ||
-                event.type === 'customer.subscription.updated') {
-                const subscription = event.data.object;
-                const items = subscription.items.data;
-                let item;
-                let sub;
-                items_loop: for (let i of items) {
-                    for (let s of config.subscriptions) {
-                        if (s.eligibleProducts &&
-                            s.eligibleProducts.some((p) => p === i.price.product)) {
-                            sub = s;
-                            item = i;
-                            break items_loop;
-                        }
-                    }
-                }
-                if (!item || !sub) {
-                    console.log(`[SubscriptionController] [handleStripeWebhook] No item in the subscription matches an eligible product in the config.`);
-                    return {
-                        success: true,
-                    };
-                }
-                console.log(`[SubscriptionController] [handleStripeWebhook] Subscription (${sub.id}) found!`);
-                const status = subscription.status;
-                const active = isActiveSubscription(status);
-                const tier = (_a = sub.tier) !== null && _a !== void 0 ? _a : 'beta';
-                const customerId = subscription.customer;
-                const stripeSubscriptionId = subscription.id;
-                const periodStartMs = subscription.current_period_start * 1000;
-                const periodEndMs = subscription.current_period_end * 1000;
-                console.log(`[SubscriptionController] [handleStripeWebhook] Customer ID: ${customerId}. Subscription status: ${status}. Tier: ${tier}. Is Active: ${active}.`);
-                let user = await this._authStore.findUserByStripeCustomerId(customerId);
-                let studio;
-                if (user) {
-                    await this._authStore.updateSubscriptionInfo({
-                        userId: user.id,
-                        subscriptionStatus: status,
-                        subscriptionId: sub.id,
-                        stripeSubscriptionId,
-                        stripeCustomerId: customerId,
-                        currentPeriodEndMs: periodEndMs,
-                        currentPeriodStartMs: periodStartMs,
-                    });
+            if (metrics.stripeAccountStatus !== 'active') {
+                console.log(`[SubscriptionController] [createPurchaseItemLink studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} subscriptionStatus: ${metrics.subscriptionStatus} stripeAccountId: ${metrics.stripeAccountId} stripeAccountStatus: ${metrics.stripeAccountStatus}] Store stripe account is not active.`);
+                return {
+                    success: false,
+                    errorCode: 'store_disabled',
+                    errorMessage: 'The store you are trying to purchase from is disabled.',
+                };
+            }
+            const limits = features.currencyLimits[item.currency];
+            if (!limits) {
+                console.log(`[SubscriptionController] [createPurchaseItemLink studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} currency: ${request.item.currency}] Currency not supported.`);
+                return {
+                    success: false,
+                    errorCode: 'currency_not_supported',
+                    errorMessage: 'The currency is not supported.',
+                };
+            }
+            if (item.cost !== 0 &&
+                (item.cost < limits.minCost || item.cost > limits.maxCost)) {
+                console.log(`[SubscriptionController] [createPurchaseItemLink studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} currency: ${request.item.currency} minCost: ${limits.minCost} maxCost: ${limits.maxCost} cost: ${item.cost}] Cost not valid.`);
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: 'The item you are trying to purchase has a price that is not allowed.',
+                };
+            }
+            let applicationFee = 0;
+            if (item.cost !== 0 && limits.fee) {
+                if (limits.fee.type === 'percent') {
+                    // calculate percent when fee is between 1 - 100
+                    applicationFee = Math.ceil(item.cost * (limits.fee.percent / 100));
                 }
                 else {
-                    console.log(`[SubscriptionController] [handleStripeWebhook] No user found for Customer ID (${customerId})`);
-                    studio =
-                        await this._recordsStore.getStudioByStripeCustomerId(customerId);
-                    if (studio) {
-                        await this._authStore.updateSubscriptionInfo({
-                            studioId: studio.id,
-                            subscriptionStatus: status,
-                            subscriptionId: sub.id,
-                            stripeSubscriptionId,
-                            stripeCustomerId: customerId,
-                            currentPeriodEndMs: periodEndMs,
-                            currentPeriodStartMs: periodStartMs,
-                        });
-                    }
-                    else {
-                        console.log(`[SubscriptionController] [handleStripeWebhook] No studio found for Customer ID (${customerId})`);
+                    if (limits.fee.amount > item.cost) {
+                        console.warn(`[SubscriptionController] [createPurchaseItemLink studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} currency: ${request.item.currency} fee: ${limits.fee.amount} cost: ${item.cost}] Fee greater than cost.`);
+                        return {
+                            success: false,
+                            errorCode: 'server_error',
+                            errorMessage: 'The application fee is greater than the cost of the item.',
+                        };
                     }
+                    applicationFee = limits.fee.amount;
                 }
-                return {
-                    success: true,
-                };
             }
-            else if (event.type === 'invoice.paid') {
-                const parseResult = STRIPE_EVENT_INVOICE_PAID_SCHEMA.safeParse(event);
-                if (parseResult.success === false) {
-                    console.error(`[SubscriptionController] [handleStripeWebhook] Unable to parse stripe event!`, parseResult.error);
+            let customerEmail = null;
+            if (request.userId) {
+                const user = await this._authStore.findUser(request.userId);
+                if (!user) {
                     return {
-                        success: true,
+                        success: false,
+                        errorCode: 'invalid_request',
+                        errorMessage: 'The user could not be found.',
                     };
                 }
-                const invoice = parseResult.data.data.object;
-                const stripeSubscriptionId = invoice.subscription;
-                const subscription = await this._stripe.getSubscriptionById(stripeSubscriptionId);
-                const status = subscription.status;
-                const customerId = invoice.customer;
-                const lineItems = invoice.lines.data;
-                const periodStartMs = subscription.current_period_start * 1000;
-                const periodEndMs = subscription.current_period_end * 1000;
-                const { sub, item } = findMatchingSubscription(lineItems);
-                const authInvoice = {
-                    currency: invoice.currency,
-                    description: invoice.description,
-                    paid: invoice.paid,
-                    status: invoice.status,
-                    tax: invoice.tax,
-                    total: invoice.total,
-                    subtotal: invoice.subtotal,
-                    stripeInvoiceId: invoice.id,
-                    stripeHostedInvoiceUrl: invoice.hosted_invoice_url,
-                    stripeInvoicePdfUrl: invoice.invoice_pdf,
-                };
-                console.log(`[SubscriptionController] [handleStripeWebhook] New invoice paid for customer ID (${customerId}). Subscription ID: ${subscription.id}. Period start: ${periodStartMs}. Period end: ${periodEndMs}.`);
-                const user = await this._authStore.findUserByStripeCustomerId(customerId);
-                if (user) {
-                    console.log(`[SubscriptionController] [handleStripeWebhook] Found user (${user.id}) with customer ID (${customerId}).`);
-                    await this._authStore.updateSubscriptionPeriod({
-                        userId: user.id,
-                        subscriptionStatus: status,
-                        subscriptionId: sub.id,
-                        stripeSubscriptionId,
-                        stripeCustomerId: customerId,
-                        currentPeriodEndMs: periodEndMs,
+                const roles = await this._policyStore.listRolesForUser(recordName, user.id);
+                const hasRole = roles.some((r) => r.role === item.roleName &&
+                    (!r.expireTimeMs || r.expireTimeMs > Date.now()));
+                if (hasRole) {
+                    return {
+                        success: false,
+                        errorCode: 'item_already_purchased',
+                        errorMessage: 'You already have the role that the item would grant.',
+                    };
+                }
+                customerEmail = user.email ?? null;
+            }
+            const sessionId = uuid();
+            console.log(`[SubscriptionController] [createPurchaseItemLink studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} sessionId: ${sessionId} currency: ${request.item.currency} cost: ${item.cost} applicationFee: ${applicationFee}] Creating checkout session.`);
+            const expirationSeconds = 60 * 60; // 1 hour
+            const session = await this._stripe.createCheckoutSession({
+                mode: 'payment',
+                line_items: [
+                    {
+                        price_data: {
+                            currency: item.currency,
+                            unit_amount: item.cost,
+                            product_data: {
+                                name: item.name,
+                                description: item.description,
+                                images: item.imageUrls,
+                                metadata: {
+                                    recordName: recordName,
+                                    address: item.address,
+                                },
+                                tax_code: item.taxCode ?? undefined,
+                            },
+                        },
+                        quantity: 1,
+                    },
+                ],
+                expires_at: Math.floor(Date.now() / 1000) + expirationSeconds,
+                success_url: fulfillmentRoute(config.returnUrl, sessionId),
+                cancel_url: request.returnUrl,
+                client_reference_id: sessionId,
+                customer_email: customerEmail,
+                metadata: {
+                    userId: request.userId,
+                    checkoutSessionId: sessionId,
+                },
+                payment_intent_data: {
+                    application_fee_amount: applicationFee,
+                },
+                connect: {
+                    stripeAccount: metrics.stripeAccountId,
+                },
+            });
+            await this._authStore.updateCheckoutSessionInfo({
+                id: sessionId,
+                stripeCheckoutSessionId: session.id,
+                invoice: session.invoice
+                    ? {
+                        currency: session.invoice.currency,
+                        paid: session.invoice.paid,
+                        description: session.invoice.description,
+                        status: session.invoice.status,
+                        stripeInvoiceId: session.invoice.id,
+                        stripeHostedInvoiceUrl: session.invoice.hosted_invoice_url,
+                        stripeInvoicePdfUrl: session.invoice.invoice_pdf,
+                        tax: session.invoice.tax,
+                        total: session.invoice.total,
+                        subtotal: session.invoice.subtotal,
+                    }
+                    : null,
+                userId: request.userId,
+                status: session.status,
+                paymentStatus: session.payment_status,
+                paid: session.payment_status === 'paid' ||
+                    session.payment_status === 'no_payment_required',
+                fulfilledAtMs: null,
+                items: [
+                    {
+                        type: 'role',
+                        recordName: recordName,
+                        purchasableItemAddress: item.address,
+                        role: item.roleName,
+                        roleGrantTimeMs: item.roleGrantTimeMs,
+                    },
+                ],
+            });
+            return {
+                success: true,
+                url: session.url,
+                sessionId: sessionId,
+            };
+        }
+        catch (err) {
+            console.error('[SubscriptionController] An error occurred while creating a purchase item link:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    /**
+     * Gets the details required for purchasing a contract.
+     * @param request The request.
+     */
+    async _getContractPurchaseDetails(request) {
+        const context = await this._policies.constructAuthorizationContext({
+            recordKeyOrRecordName: request.contract.recordName,
+            userId: request.userId,
+        });
+        if (context.success === false) {
+            return failure(context);
+        }
+        const item = await this._contractRecords.getItemByAddress(request.contract.recordName, request.contract.address);
+        if (!item) {
+            return failure({
+                errorCode: 'item_not_found',
+                errorMessage: 'The item could not be found.',
+            });
+        }
+        if (item.status !== 'pending') {
+            return failure({
+                errorCode: 'item_already_purchased',
+                errorMessage: 'The contract has already been purchased.',
+            });
+        }
+        // TODO: Pull this from the contract.
+        const currency = 'usd';
+        const authorization = await this._policies.authorizeUserAndInstances(context.context, {
+            userId: request.userId,
+            resourceKind: 'contract',
+            resourceId: item.address,
+            markers: item.markers,
+            action: 'purchase',
+            instances: request.instances,
+        });
+        if (authorization.success === false) {
+            return failure(authorization);
+        }
+        const metrics = await this._contractRecords.getSubscriptionMetrics({
+            ownerId: context.context.recordOwnerId,
+            studioId: context.context.recordStudioId,
+        });
+        const config = await this._getConfig();
+        const features = getContractFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, metrics.subscriptionType, metrics.currentPeriodStartMs, metrics.currentPeriodEndMs);
+        if (!features.allowed) {
+            console.log(`[SubscriptionController] [_getContractPurchaseDetails studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} subscriptionStatus: ${metrics.subscriptionStatus}] Store features not allowed.`);
+            return failure({
+                errorCode: 'store_disabled',
+                errorMessage: "The account you are trying to purchase the contract for doesn't have access to contracting features.",
+            });
+        }
+        const limits = features.currencyLimits[currency];
+        if (!limits) {
+            console.log(`[SubscriptionController] [_getContractPurchaseDetails studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} currency: ${currency}] Currency not supported.`);
+            return failure({
+                errorCode: 'currency_not_supported',
+                errorMessage: 'The currency is not supported.',
+            });
+        }
+        if (item.initialValue !== 0 &&
+            (item.initialValue < limits.minCost ||
+                item.initialValue > limits.maxCost)) {
+            console.log(`[SubscriptionController] [_getContractPurchaseDetails studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} currency: ${currency} minCost: ${limits.minCost} maxCost: ${limits.maxCost} initialValue: ${item.initialValue}] Cost not valid.`);
+            return failure({
+                errorCode: 'subscription_limit_reached',
+                errorMessage: 'The contract you are trying to purchase has a price that is not allowed.',
+            });
+        }
+        let applicationFee = 0;
+        if (item.initialValue !== 0 && limits.fee) {
+            if (limits.fee.type === 'percent') {
+                // calculate percent when fee is between 1 - 100
+                applicationFee = Math.ceil(item.initialValue * (limits.fee.percent / 100));
+            }
+            else {
+                // if (limits.fee.amount > item.initialValue) {
+                //     console.warn(
+                //         `[SubscriptionController] [purchaseContract studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} currency: ${currency} fee: ${limits.fee.amount} initialValue: ${item.initialValue}] Fee greater than cost.`
+                //     );
+                //     return {
+                //         success: false,
+                //         errorCode: 'server_error',
+                //         errorMessage:
+                //             'The application fee is greater than the cost of the item.',
+                //     };
+                // }
+                applicationFee = limits.fee.amount;
+            }
+        }
+        const totalCost = item.initialValue + applicationFee;
+        return success({
+            totalCost,
+            applicationFee,
+            item,
+            features,
+            metrics,
+            limits,
+            currency,
+            context: context.context,
+            authorization,
+        });
+    }
+    /**
+     * Gets the pricing information for a contract.
+     * @param request The request.
+     */
+    async getContractPricing(request) {
+        const details = await this._getContractPurchaseDetails(request);
+        if (isFailure(details)) {
+            return details;
+        }
+        const lineItems = [];
+        lineItems.push({
+            name: 'Contract',
+            amount: details.value.item.initialValue,
+        });
+        if (details.value.applicationFee > 0) {
+            lineItems.push({
+                name: 'Application Fee',
+                amount: details.value.applicationFee,
+            });
+        }
+        return success({
+            total: details.value.totalCost,
+            currency: details.value.currency,
+            lineItems,
+            contract: details.value.item,
+        });
+    }
+    /**
+     * Creates a link that the user can be redirected to in order to purchase a contract.
+     * @param request The request to purchase the contract.
+     * @returns A promise that resolves to the result of the purchase contract operation.
+     */
+    async purchaseContract(request) {
+        try {
+            const details = await this._getContractPurchaseDetails(request);
+            if (isFailure(details)) {
+                return details;
+            }
+            const item = details.value.item;
+            const currency = details.value.currency;
+            if (currency !== request.contract.currency) {
+                return failure({
+                    errorCode: 'price_does_not_match',
+                    errorMessage: 'The expected price does not match the actual price of the contract.',
+                });
+            }
+            const recordName = details.value.context.recordName;
+            const metrics = details.value.metrics;
+            const config = await this._getConfig();
+            const features = details.value.features;
+            const limits = details.value.limits;
+            const totalCost = details.value.totalCost;
+            const applicationFee = details.value.applicationFee;
+            if (totalCost !== request.contract.expectedCost) {
+                return failure({
+                    errorCode: 'price_does_not_match',
+                    errorMessage: 'The expected price does not match the actual price of the contract.',
+                });
+            }
+            let customerEmail = null;
+            if (request.userId) {
+                const user = await this._authStore.findUser(request.userId);
+                if (!user) {
+                    return failure({
+                        success: false,
+                        errorCode: 'invalid_request',
+                        errorMessage: 'The user could not be found.',
+                    });
+                }
+                // const roles = await this._policyStore.listRolesForUser(
+                //     recordName,
+                //     user.id
+                // );
+                // const hasRole = roles.some(
+                //     (r) =>
+                //         r.role === item.roleName &&
+                //         (!r.expireTimeMs || r.expireTimeMs > Date.now())
+                // );
+                // if (hasRole) {
+                //     return {
+                //         success: false,
+                //         errorCode: 'item_already_purchased',
+                //         errorMessage:
+                //             'You already have the role that the item would grant.',
+                //     };
+                // }
+                customerEmail = user.email ?? null;
+            }
+            const contractAccount = await this._financialController.getOrCreateFinancialAccount({
+                contractId: item.id,
+                ledger: LEDGERS.usd,
+            });
+            if (isFailure(contractAccount)) {
+                logError(contractAccount.error, `[SubscriptionController] [purchaseContract] Failed to get USD financial account for contract: ${item.id}`);
+                return failure({
+                    success: false,
+                    errorCode: 'server_error',
+                    errorMessage: 'Failed to get a financial account for the contract.',
+                });
+            }
+            const sessionId = uuid();
+            console.log(`[SubscriptionController] [purchaseContract studioId: ${metrics.studioId} subscriptionId: ${metrics.subscriptionId} sessionId: ${sessionId} currency: ${request.contract.currency} initialValue: ${item.initialValue} applicationFee: ${applicationFee}] Creating checkout session.`);
+            const userUsdAccount = await this._financialController.getFinancialAccount({
+                userId: request.userId,
+                ledger: LEDGERS.usd,
+            });
+            let immediateFulfillment = false;
+            const checkoutSession = {
+                id: sessionId,
+                stripeCheckoutSessionId: null,
+                invoice: null,
+                userId: request.userId,
+                status: 'complete',
+                paymentStatus: 'no_payment_required',
+                paid: false,
+                fulfilledAtMs: null,
+                items: [
+                    {
+                        type: 'contract',
+                        recordName: recordName,
+                        contractAddress: item.address,
+                        contractId: item.id,
+                        value: item.initialValue,
+                    },
+                ],
+                transactionId: null,
+                transferIds: null,
+                shouldBeAutomaticallyFulfilled: true,
+            };
+            if (isFailure(userUsdAccount)) {
+                logError(userUsdAccount.error, `[SubscriptionController] [purchaseContract] Failed to get USD financial account for user: ${request.userId}`, console.warn);
+            }
+            else {
+                const balance = getAccountBalance(userUsdAccount.value.account);
+                if (balance >= totalCost) {
+                    // try to create a transfer from the user account
+                    console.log(`[SubscriptionController] [purchaseContract accountId: ${userUsdAccount.value.account.id}] Attempting to pay out of user USD account.`);
+                    const builder = new TransactionBuilder();
+                    builder.disablePendingTransfers();
+                    builder.addContract({
+                        recordName,
+                        item,
+                        contractAccountId: contractAccount.value.account.id,
+                        debitAccountId: userUsdAccount.value.account.id,
+                    });
+                    if (applicationFee > 0) {
+                        builder.addContractApplicationFee({
+                            recordName,
+                            item,
+                            fee: applicationFee,
+                            debitAccountId: userUsdAccount.value.account.id,
+                        });
+                    }
+                    const transferResult = await this._financialController.internalTransaction({
+                        transfers: builder.transfers,
+                    });
+                    if (isFailure(transferResult)) {
+                        logError(transferResult.error, `[SubscriptionController] [purchaseContract] Failed to pay for contract from user's USD account:`, console.warn);
+                    }
+                    else {
+                        console.log(`[SubscriptionController] [purchaseContract] Successfully paid for contract from user's USD account.`);
+                        checkoutSession.paid = true;
+                        checkoutSession.transferIds =
+                            transferResult.value.transferIds;
+                        checkoutSession.transactionId =
+                            transferResult.value.transactionId;
+                        immediateFulfillment = true;
+                    }
+                }
+            }
+            if (!checkoutSession.paid) {
+                const userCreditAccount = await this._financialController.getFinancialAccount({
+                    userId: request.userId,
+                    ledger: LEDGERS.credits,
+                });
+                if (isFailure(userCreditAccount)) {
+                    logError(userCreditAccount.error, `[SubscriptionController] [purchaseContract] Failed to get Credit financial account for user: ${request.userId}`, console.warn);
+                }
+                else {
+                    const balance = getAccountBalance(userCreditAccount.value.account);
+                    if (balance >= totalCost) {
+                        // try to create a transfer from the user account
+                        console.log(`[SubscriptionController] [purchaseContract accountId: ${userCreditAccount.value.account.id}] Attempting to pay out of user credits account.`);
+                        const totalCreditCost = convertBetweenLedgers(LEDGERS.usd, LEDGERS.credits, BigInt(totalCost));
+                        if (totalCreditCost === null) {
+                            console.error(`[SubscriptionController] [purchaseContract] Failed to convert cost from USD to Credits.`);
+                            return failure({
+                                errorCode: 'server_error',
+                                errorMessage: 'Failed to convert cost from USD to Credits.',
+                            });
+                        }
+                        const builder = new TransactionBuilder();
+                        builder.disablePendingTransfers();
+                        builder.addTransfer({
+                            debitAccountId: userCreditAccount.value.account.id,
+                            creditAccountId: getLiquidityAccountByLedger(userCreditAccount.value.account.ledger),
+                            currency: CURRENCIES.get(userCreditAccount.value.account.ledger),
+                            amount: totalCreditCost.value,
+                            code: TransferCodes.exchange,
+                        });
+                        builder.addContract({
+                            recordName,
+                            item,
+                            contractAccountId: contractAccount.value.account.id,
+                            debitAccountId: getLiquidityAccountByLedger(contractAccount.value.account.ledger),
+                        });
+                        if (applicationFee > 0) {
+                            builder.addContractApplicationFee({
+                                recordName,
+                                item,
+                                fee: applicationFee,
+                                debitAccountId: getLiquidityAccountByLedger(contractAccount.value.account.ledger),
+                            });
+                        }
+                        const transferResult = await this._financialController.internalTransaction({
+                            transfers: builder.transfers,
+                        });
+                        if (isFailure(transferResult)) {
+                            logError(transferResult.error, `[SubscriptionController] [purchaseContract] Failed to pay for contract from user's credit account:`, console.warn);
+                        }
+                        else {
+                            console.log(`[SubscriptionController] [purchaseContract] Successfully paid for contract from user's credit account.`);
+                            checkoutSession.paid = true;
+                            checkoutSession.transferIds =
+                                transferResult.value.transferIds;
+                            checkoutSession.transactionId =
+                                transferResult.value.transactionId;
+                            immediateFulfillment = true;
+                        }
+                    }
+                }
+            }
+            let url = undefined;
+            let voidTransfers = async () => { };
+            if (!checkoutSession.paid) {
+                console.log(`[SubscriptionController] [purchaseContract] Attempting to pay out of Stripe.`);
+                const expirationSeconds = 60 * 60; // 1 hour
+                const builder = new TransactionBuilder();
+                builder.usePendingTransfers(expirationSeconds);
+                builder.addContract({
+                    recordName,
+                    item,
+                    contractAccountId: contractAccount.value.account.id,
+                    debitAccountId: ACCOUNT_IDS.assets_stripe,
+                });
+                if (applicationFee > 0) {
+                    builder.addContractApplicationFee({
+                        recordName,
+                        item,
+                        fee: applicationFee,
+                        debitAccountId: ACCOUNT_IDS.assets_stripe,
+                    });
+                }
+                const transferResult = await this._financialController.internalTransaction({
+                    transfers: builder.transfers,
+                });
+                if (isFailure(transferResult)) {
+                    logError(transferResult.error, `[SubscriptionController] [purchaseContract] Failed to create internal transfer for contract: ${item.id}`);
+                    // TODO: Map out better error codes
+                    return failure({
+                        errorCode: 'server_error',
+                        errorMessage: 'Failed to create internal transfer for contract.',
+                    });
+                }
+                voidTransfers = async () => {
+                    console.log(`[SubscriptionController] [purchaseContract] Voiding pending transfers for failed purchase.`);
+                    const voidResult = await this._financialController.completePendingTransfers({
+                        transfers: transferResult.value.transferIds,
+                        transactionId: transferResult.value.transactionId,
+                        flags: TransferFlags.void_pending_transfer,
+                    });
+                    if (isFailure(voidResult)) {
+                        logError(voidResult.error, `[SubscriptionController] [purchaseContract] Failed to void pending transfers for purchase:`);
+                    }
+                };
+                const sessionResult = await wrap(() => this._stripe.createCheckoutSession({
+                    mode: 'payment',
+                    line_items: builder.lineItems,
+                    success_url: checkoutSession.shouldBeAutomaticallyFulfilled
+                        ? request.successUrl
+                        : fulfillmentRoute(config.returnUrl, sessionId),
+                    cancel_url: request.returnUrl,
+                    client_reference_id: sessionId,
+                    customer_email: customerEmail,
+                    expires_at: Math.floor(Date.now() / 1000) + expirationSeconds,
+                    metadata: {
+                        userId: request.userId,
+                        checkoutSessionId: sessionId,
+                        transactionId: transferResult.value.transactionId,
+                    },
+                    payment_intent_data: {
+                        // application_fee_amount: applicationFee,
+                        transfer_group: item.id,
+                    },
+                    // connect: {
+                    //     stripeAccount: metrics.,
+                    // },
+                }));
+                if (isFailure(sessionResult)) {
+                    logError(sessionResult.error, `[SubscriptionController] [purchaseContract] Failed to create checkout session for contract: ${item.id}`);
+                    await voidTransfers();
+                    return failure({
+                        errorCode: 'server_error',
+                        errorMessage: 'Failed to create checkout session for contract.',
+                    });
+                }
+                const session = sessionResult.value;
+                checkoutSession.stripeCheckoutSessionId = session.id;
+                if (session.invoice) {
+                    checkoutSession.invoice = {
+                        currency: session.invoice.currency,
+                        paid: session.invoice.paid,
+                        description: session.invoice.description,
+                        status: session.invoice.status,
+                        stripeInvoiceId: session.invoice.id,
+                        stripeHostedInvoiceUrl: session.invoice.hosted_invoice_url,
+                        stripeInvoicePdfUrl: session.invoice.invoice_pdf,
+                        tax: session.invoice.tax,
+                        total: session.invoice.total,
+                        subtotal: session.invoice.subtotal,
+                    };
+                }
+                checkoutSession.status = session.status;
+                checkoutSession.paymentStatus = session.payment_status;
+                checkoutSession.paid =
+                    session.payment_status === 'paid' ||
+                        session.payment_status === 'no_payment_required';
+                checkoutSession.transactionId =
+                    transferResult.value.transactionId;
+                checkoutSession.transferIds = transferResult.value.transferIds;
+                checkoutSession.transfersPending = true;
+                url = session.url;
+                // Do not immediately fulfill since we need to wait for Stripe webhook
+                immediateFulfillment = false;
+            }
+            await this._authStore.updateCheckoutSessionInfo(checkoutSession);
+            if (immediateFulfillment) {
+                const fulfillmentResult = await this.fulfillCheckoutSession({
+                    sessionId: checkoutSession.id,
+                    activation: 'now',
+                    userId: request.userId,
+                });
+                if (fulfillmentResult.success === false) {
+                    console.error(`[SubscriptionController] [purchaseContract] Failed to immediately fulfill checkout session for contract: ${item.id}:`, fulfillmentResult.errorMessage);
+                }
+            }
+            return success({
+                url,
+                sessionId: sessionId,
+            });
+        }
+        catch (err) {
+            console.error('[SubscriptionController] An error occurred while purchasing a contract:', err);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            });
+        }
+    }
+    /**
+     * Cancels a contract and issues a refund if applicable.
+     * @param request The request to cancel the contract.
+     * @returns A promise that resolves to the result of the cancel contract operation.
+     */
+    async cancelContract(request) {
+        const context = await this._policies.constructAuthorizationContext({
+            recordKeyOrRecordName: request.recordName,
+            userId: request.userId,
+        });
+        if (context.success === false) {
+            return failure(context);
+        }
+        const recordName = context.context.recordName;
+        const item = await this._contractRecords.getItemByAddress(recordName, request.address);
+        if (!item) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: 'The contract could not be found.',
+            });
+        }
+        const authorization = await this._policies.authorizeUserAndInstances(context.context, {
+            userId: request.userId,
+            instances: request.instances,
+            resourceKind: 'contract',
+            resourceId: item.address,
+            markers: item.markers,
+            action: 'cancel',
+        });
+        if (authorization.success === false) {
+            return failure(authorization);
+        }
+        if (item.status === 'closed') {
+            return success({
+                refundedAmount: 0,
+                refundCurrency: CurrencyCodes.usd,
+            });
+        }
+        const refundResult = await this._refundContract(request, item, context.context);
+        if (isSuccess(refundResult)) {
+            await this._contractRecords.markContractAsClosed(recordName, item.address);
+        }
+        return refundResult;
+    }
+    /**
+     * Issues a new invoice for a contract.
+     * @param request The request to invoice the contract.
+     */
+    async invoiceContract(request) {
+        if (!this._financialController) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This operation is not supported.',
+            });
+        }
+        if (request.amount <= 0) {
+            return failure({
+                errorCode: 'invalid_request',
+                errorMessage: 'The invoice amount must be greater than zero.',
+            });
+        }
+        const contract = await this._contractRecords.getItemById(request.contractId);
+        if (!contract?.contract) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: 'The contract could not be found.',
+            });
+        }
+        if (!isSuperUserRole(request.userRole)) {
+            if (contract.contract.holdingUserId !== request.userId) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to invoice for the contract.',
+                });
+            }
+        }
+        if (contract.contract.status !== 'open') {
+            return failure({
+                errorCode: 'invalid_request',
+                errorMessage: 'The contract is not open for invoicing.',
+            });
+        }
+        const balance = await this._financialController.getAccountBalance({
+            contractId: contract.contract.id,
+            ledger: LEDGERS.usd,
+        });
+        if (isFailure(balance)) {
+            logError(balance.error, `[SubscriptionController] [invoiceContract] Failed to get account balance for contract: ${contract.contract.id}`);
+            return balance;
+        }
+        if (balance.value.freeCreditBalance() < request.amount) {
+            return failure({
+                errorCode: 'insufficient_funds',
+                errorMessage: 'The contract does not have sufficient funds to cover the invoice amount.',
+            });
+        }
+        const now = Date.now();
+        const invoiceId = uuid();
+        await this._contractRecords.createInvoice({
+            id: invoiceId,
+            contractId: contract.contract.id,
+            amount: request.amount,
+            status: 'open',
+            payoutDestination: request.payoutDestination,
+            note: request.note,
+            openedAtMs: now,
+            createdAtMs: now,
+            updatedAtMs: now,
+        });
+        return success({
+            invoiceId,
+        });
+    }
+    /**
+     * Cancels an invoice for a contract.
+     * @param request The request to cancel the invoice.
+     */
+    async cancelInvoice(request) {
+        const invoice = await this._contractRecords.getInvoiceById(request.invoiceId);
+        if (!invoice?.invoice) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: 'The invoice could not be found.',
+            });
+        }
+        // TODO: Use the permissions system for viewing invoices
+        if (!isSuperUserRole(request.userRole)) {
+            if (invoice.contract.issuingUserId !== request.userId &&
+                invoice.contract.holdingUserId !== request.userId) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to perform this operation.',
+                });
+            }
+        }
+        if (invoice.invoice.status !== 'open') {
+            return failure({
+                errorCode: 'invalid_request',
+                errorMessage: 'Only open invoices can be cancelled.',
+            });
+        }
+        await this._contractRecords.markOpenInvoiceAs(request.invoiceId, 'void');
+        return success();
+    }
+    /**
+     * Lists all invoices for a contract.
+     * @param request The request to list the invoices.
+     */
+    async listContractInvoices(request) {
+        const contract = await this._contractRecords.getItemById(request.contractId);
+        if (!contract?.contract) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: 'The contract could not be found.',
+            });
+        }
+        // TODO: Use the permissions system for viewing invoices
+        if (!isSuperUserRole(request.userRole)) {
+            if (contract.contract.issuingUserId !== request.userId &&
+                contract.contract.holdingUserId !== request.userId) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to view invoices for the contract.',
+                });
+            }
+        }
+        const invoices = await this._contractRecords.listInvoicesForContract(request.contractId);
+        return success(invoices);
+    }
+    /**
+     * Pays an invoice for a contract.
+     * @param request The request to pay the invoice.
+     */
+    async payContractInvoice(request) {
+        if (!this._financialController) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This operation is not supported.',
+            });
+        }
+        const invoice = await this._contractRecords.getInvoiceById(request.invoiceId);
+        if (!invoice) {
+            return failure({
+                errorCode: 'not_found',
+                errorMessage: 'The invoice could not be found.',
+            });
+        }
+        if (!isSuperUserRole(request.userRole)) {
+            if (invoice.contract.issuingUserId !== request.userId) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to pay invoices for the contract.',
+                });
+            }
+        }
+        // transfer from contract account to payout destination
+        if (invoice.invoice.status !== 'open') {
+            return failure({
+                errorCode: 'invalid_request',
+                errorMessage: 'The invoice is not open and cannot be paid.',
+            });
+        }
+        const holdingUser = await this._authStore.findUser(invoice.contract.holdingUserId);
+        if (!holdingUser) {
+            console.error(`[SubscriptionController] [payInvoice] Failed to find holding user for contract: ${invoice.contract.id}`);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'The server encountered an error.',
+            });
+        }
+        const [userAccount, contractAccount] = await Promise.all([
+            this._financialController.getOrCreateFinancialAccount({
+                userId: holdingUser.id,
+                ledger: LEDGERS.usd,
+            }),
+            this._financialController.getFinancialAccount({
+                contractId: invoice.contract.id,
+                ledger: LEDGERS.usd,
+            }),
+        ]);
+        if (isFailure(userAccount)) {
+            logError(userAccount.error, `[SubscriptionController] [payInvoice] Failed to get or create financial account for user: ${holdingUser.id}`);
+            return userAccount;
+        }
+        else if (isFailure(contractAccount)) {
+            logError(contractAccount.error, `[SubscriptionController] [payInvoice] Failed to get financial account for contract: ${invoice.contract.id}`);
+            return contractAccount;
+        }
+        if (invoice.invoice.payoutDestination === 'stripe') {
+            if (!holdingUser.stripeAccountId) {
+                return failure({
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The user to be paid does not have a Stripe account connected.',
+                });
+            }
+            if (holdingUser.stripeAccountStatus !== 'active') {
+                return failure({
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The user to be paid does not have an active Stripe account.',
+                });
+            }
+        }
+        const transactionResult = await this._financialController.internalTransaction({
+            transfers: [
+                {
+                    amount: invoice.invoice.amount,
+                    creditAccountId: userAccount.value.account.id,
+                    debitAccountId: contractAccount.value.account.id,
+                    code: TransferCodes.contract_payment,
+                    currency: CurrencyCodes.usd,
+                },
+            ],
+        });
+        if (isFailure(transactionResult)) {
+            if (transactionResult.error.errorCode === 'debits_exceed_credits') {
+                return failure({
+                    errorCode: 'insufficient_funds',
+                    errorMessage: 'The contract does not have sufficient funds to pay the invoice.',
+                });
+            }
+            logError(transactionResult.error, `[SubscriptionController] [payInvoice] Failed to pay invoice: ${invoice.invoice.id}`);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'The server encountered an error.',
+            });
+        }
+        await this._contractRecords.markOpenInvoiceAs(request.invoiceId, 'paid');
+        if (invoice.invoice.payoutDestination === 'stripe') {
+            const result = await this.payoutAccount({
+                userId: null,
+                userRole: 'system',
+                payoutUserId: holdingUser.id,
+                payoutDestination: 'stripe',
+                payoutAmount: invoice.invoice.amount,
+                contractId: invoice.contract.id,
+                invoiceId: invoice.invoice.id,
+            });
+            if (isFailure(result)) {
+                return result;
+            }
+        }
+        else if (invoice.invoice.payoutDestination === 'account') {
+            // Nothing to do since we already transferred to the user's account
+        }
+        else {
+            return failure({
+                errorCode: 'invalid_request',
+                errorMessage: 'The invoice has an invalid payout destination.',
+            });
+        }
+        return success();
+    }
+    /**
+     * Attempts to payout an account.
+     * @param request The request.
+     */
+    async payoutAccount(request) {
+        if (!this._financialController) {
+            return failure({
+                errorCode: 'not_supported',
+                errorMessage: 'This operation is not supported.',
+            });
+        }
+        if (typeof request.payoutAmount === 'number' &&
+            request.payoutAmount <= 0) {
+            return failure({
+                errorCode: 'invalid_request',
+                errorMessage: 'The payout amount must be greater than zero.',
+            });
+        }
+        if (!isSuperUserRole(request.userRole)) {
+            if (request.payoutUserId &&
+                request.userId !== request.payoutUserId) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to payout this account.',
+                });
+            }
+            else if (request.payoutStudioId) {
+                // TODO: Check studio permissions
+                return failure({
+                    errorCode: 'not_supported',
+                    errorMessage: 'Studio payouts are not supported yet.',
+                });
+            }
+        }
+        if (request.payoutDestination === 'stripe') {
+            return this._payoutToStripe(request);
+        }
+        else if (request.payoutDestination === 'cash') {
+            if (!isSuperUserRole(request.userRole)) {
+                return failure({
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to payout to cash.',
+                });
+            }
+            return this._payoutToCash(request);
+        }
+    }
+    async _payoutToStripe(request) {
+        if (request.payoutStudioId && request.payoutUserId) {
+            return failure({
+                errorCode: 'invalid_request',
+                errorMessage: 'Cannot payout to both a user and a studio at the same time.',
+            });
+        }
+        let destinationStripeAccount;
+        if (request.payoutUserId) {
+            const user = await this._authStore.findUser(request.payoutUserId);
+            if (!user) {
+                return failure({
+                    errorCode: 'not_found',
+                    errorMessage: 'The user could not be found.',
+                });
+            }
+            if (!user.stripeAccountId) {
+                return failure({
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The user does not have a Stripe account connected.',
+                });
+            }
+            if (user.stripeAccountStatus !== 'active') {
+                return failure({
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The user does not have an active Stripe account.',
+                });
+            }
+            destinationStripeAccount = user.stripeAccountId;
+        }
+        else if (request.payoutStudioId) {
+            const studio = await this._recordsStore.getStudioById(request.payoutStudioId);
+            if (!studio) {
+                return failure({
+                    errorCode: 'not_found',
+                    errorMessage: 'The studio could not be found.',
+                });
+            }
+            if (!studio.stripeAccountId) {
+                return failure({
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The studio does not have a Stripe account connected.',
+                });
+            }
+            if (studio.stripeAccountStatus !== 'active') {
+                return failure({
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The studio does not have an active Stripe account.',
+                });
+            }
+            destinationStripeAccount = studio.stripeAccountId;
+        }
+        const [debitAccount] = await Promise.all([
+            this._financialController.getOrCreateFinancialAccount({
+                userId: request.payoutUserId,
+                studioId: request.payoutStudioId,
+                ledger: LEDGERS.usd,
+            }),
+        ]);
+        if (isFailure(debitAccount)) {
+            logError(debitAccount.error, `[SubscriptionController] [payoutAccount] Failed to get or create financial account:`);
+            return debitAccount;
+        }
+        let amount;
+        let balancingDebit = false;
+        if (request.payoutAmount) {
+            amount = request.payoutAmount;
+        }
+        else {
+            amount = AMOUNT_MAX;
+            balancingDebit = true;
+        }
+        const transactionResult = await this._financialController.internalTransaction({
+            transfers: [
+                {
+                    amount: amount,
+                    creditAccountId: ACCOUNT_IDS.assets_stripe,
+                    debitAccountId: debitAccount.value.account.id,
+                    code: TransferCodes.user_payout,
+                    currency: CurrencyCodes.usd,
+                    pending: true,
+                    timeoutSeconds: STRIPE_PAYOUT_TIMEOUT_SECONDS,
+                    balancingDebit: balancingDebit,
+                },
+            ],
+        });
+        if (isFailure(transactionResult)) {
+            if (transactionResult.error.errorCode === 'debits_exceed_credits') {
+                return failure({
+                    errorCode: 'insufficient_funds',
+                    errorMessage: 'The account does not have sufficient funds to complete the payout.',
+                });
+            }
+            else if (transactionResult.error.errorCode === 'credits_exceed_debits') {
+                logError(transactionResult.error, `[SubscriptionController] [payoutAccount] Unable to payout to Stripe due to insufficient funds:`);
+                return failure({
+                    errorCode: 'server_error',
+                    errorMessage: 'The server encountered an error.',
+                });
+            }
+            logError(transactionResult.error, `[SubscriptionController] [payoutAccount] Failed to create payout transaction:`);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'The server encountered an error.',
+            });
+        }
+        const voidTransfers = async (payoutId) => {
+            console.log(`[SubscriptionController] [payoutAccount] Voiding pending transfers for failed payout.`);
+            const voidResult = await this._financialController.completePendingTransfers({
+                transfers: transactionResult.value.transferIds,
+                transactionId: transactionResult.value.transactionId,
+                flags: TransferFlags.void_pending_transfer,
+            });
+            if (isFailure(voidResult)) {
+                logError(voidResult.error, `[SubscriptionController] [payoutAccount] Failed to void pending transfers for payout:`);
+            }
+            else if (payoutId) {
+                await this._financialStore.markPayoutAsVoided(payoutId, voidResult.value.transferIds[0], Date.now());
+            }
+        };
+        const transfer = await this._financialController.getTransfer(transactionResult.value.transferIds[0]);
+        if (isFailure(transfer)) {
+            logError(transfer.error, `[SubscriptionController] [payoutAccount] Failed to get transfer for payout:`);
+            await voidTransfers();
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'The server encountered an error.',
+            });
+        }
+        else if (transfer.value.amount <= 0) {
+            return failure({
+                errorCode: 'invalid_request',
+                errorMessage: 'There are no funds to transfer.',
+            });
+        }
+        const payoutId = uuid();
+        try {
+            await this._financialStore.createExternalPayout({
+                id: payoutId,
+                amount: Number(transfer.value.amount),
+                externalDestination: 'stripe',
+                destinationStripeAccountId: destinationStripeAccount,
+                initatedAtMs: Date.now(),
+                transferId: transfer.value.id.toString(),
+                transactionId: transactionResult.value.transactionId,
+                invoiceId: request.invoiceId,
+                userId: request.payoutUserId,
+                studioId: request.payoutStudioId,
+            });
+            let sourceTransaction = undefined;
+            if (request.contractId) {
+                const contract = await this._contractRecords.getItemById(request.contractId);
+                if (contract?.contract.stripePaymentIntentId) {
+                    const paymentIntent = await this._stripe.getPaymentIntentById(contract.contract.stripePaymentIntentId);
+                    sourceTransaction = paymentIntent.latest_charge;
+                }
+            }
+            const result = await this._stripe.createTransfer({
+                currency: 'usd',
+                destination: destinationStripeAccount,
+                amount: Number(transfer.value.amount),
+                description: 'Account Payout',
+                transferGroup: request.contractId,
+                sourceTransaction,
+                metadata: {
+                    transactionId: transactionResult.value.transactionId,
+                    payoutId: payoutId,
+                    payoutUserId: request.payoutUserId,
+                    payoutStudioId: request.payoutStudioId,
+                },
+            });
+            // TODO: update external payout with stripe transfer id
+            await this._financialStore.updateExternalPayout({
+                id: payoutId,
+                stripeTransferId: result.id,
+            });
+            const postResult = await this._financialController.completePendingTransfers({
+                transfers: transactionResult.value.transferIds,
+                transactionId: transactionResult.value.transactionId,
+            });
+            if (isFailure(postResult)) {
+                logError(postResult.error, `[SubscriptionController] [payoutAccount] Failed to complete pending transfers for payout:`);
+                await voidTransfers(payoutId);
+                return failure({
+                    errorCode: 'server_error',
+                    errorMessage: 'The server encountered an error.',
+                });
+            }
+            await this._financialStore.markPayoutAsPosted(payoutId, postResult.value.transferIds[0], Date.now());
+            return success({
+                payoutId,
+            });
+        }
+        catch (err) {
+            console.error(`[SubscriptionController] [payoutAccount] Failed to create Stripe transfer for payout:`, err);
+            await voidTransfers(payoutId);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'The server encountered an error.',
+            });
+        }
+    }
+    async _payoutToCash(request) {
+        if (request.payoutStudioId && request.payoutUserId) {
+            return failure({
+                errorCode: 'invalid_request',
+                errorMessage: 'Cannot payout to both a user and a studio at the same time.',
+            });
+        }
+        const [debitAccount] = await Promise.all([
+            this._financialController.getOrCreateFinancialAccount({
+                userId: request.payoutUserId,
+                studioId: request.payoutStudioId,
+                ledger: LEDGERS.usd,
+            }),
+        ]);
+        if (isFailure(debitAccount)) {
+            logError(debitAccount.error, `[SubscriptionController] [payoutAccount] Failed to get or create financial account:`);
+            return debitAccount;
+        }
+        let amount;
+        let balancingDebit = false;
+        if (request.payoutAmount) {
+            amount = request.payoutAmount;
+        }
+        else {
+            amount = AMOUNT_MAX;
+            balancingDebit = true;
+        }
+        const transactionResult = await this._financialController.internalTransaction({
+            transfers: [
+                {
+                    amount: amount,
+                    creditAccountId: ACCOUNT_IDS.assets_cash,
+                    debitAccountId: debitAccount.value.account.id,
+                    code: TransferCodes.user_payout,
+                    currency: CurrencyCodes.usd,
+                    balancingDebit: balancingDebit,
+                },
+            ],
+        });
+        if (isFailure(transactionResult)) {
+            if (transactionResult.error.errorCode === 'debits_exceed_credits') {
+                return failure({
+                    errorCode: 'insufficient_funds',
+                    errorMessage: 'The account does not have sufficient funds to complete the payout.',
+                });
+            }
+            else if (transactionResult.error.errorCode === 'credits_exceed_debits') {
+                logError(transactionResult.error, `[SubscriptionController] [payoutAccount] Unable to payout to Stripe due to insufficient funds:`);
+                return failure({
+                    errorCode: 'server_error',
+                    errorMessage: 'The server encountered an error.',
+                });
+            }
+            logError(transactionResult.error, `[SubscriptionController] [payoutAccount] Failed to create payout transaction:`);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'The server encountered an error.',
+            });
+        }
+        const transfer = await this._financialController.getTransfer(transactionResult.value.transferIds[0]);
+        if (isFailure(transfer)) {
+            logError(transfer.error, `[SubscriptionController] [payoutAccount] Failed to get transfer for payout:`);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'The server encountered an error.',
+            });
+        }
+        const payoutId = uuid();
+        await this._financialStore.createExternalPayout({
+            id: payoutId,
+            amount: Number(transfer.value.amount),
+            externalDestination: 'cash',
+            initatedAtMs: Date.now(),
+            transferId: transfer.value.id.toString(),
+            transactionId: transactionResult.value.transactionId,
+            invoiceId: request.invoiceId,
+            userId: request.payoutUserId,
+            studioId: request.payoutStudioId,
+            postedAtMs: Date.now(),
+            postedTransferId: transfer.value.id.toString(),
+        });
+        return success({
+            payoutId,
+        });
+    }
+    /**
+     * Initiates a refund for a canceled contract.
+     * @param request The request to cancel the contract.
+     * @param item The contract record to refund.
+     * @param context The authorization context for the operation.
+     * @returns A promise that resolves to the result of the refund operation.
+     */
+    async _refundContract(request, item, context) {
+        const contractAccount = await this._financialController.getFinancialAccount({
+            contractId: item.id,
+            ledger: LEDGERS.usd,
+        });
+        if (isFailure(contractAccount)) {
+            if (contractAccount.error.errorCode === 'not_found') {
+                return success({
+                    refundedAmount: 0,
+                    refundCurrency: CurrencyCodes.usd,
+                });
+            }
+            logError(contractAccount.error, `[SubscriptionController] [cancelContract] Failed to get USD financial account for contract:`);
+            return contractAccount;
+        }
+        let refundAccount;
+        if (request.refundAccountId) {
+            const account = await this._financialController.getAccount(request.refundAccountId);
+            if (isFailure(account)) {
+                logError(account.error, `[SubscriptionController] [cancelContract] Failed to get refund account:`);
+                return account;
+            }
+            refundAccount = account.value;
+        }
+        if (!refundAccount) {
+            const account = await this._financialController.getOrCreateFinancialAccount({
+                userId: context.recordOwnerId,
+                studioId: context.recordStudioId,
+                ledger: contractAccount.value.account.ledger,
+            });
+            if (isFailure(account)) {
+                logError(account.error, `[SubscriptionController] [cancelContract] Failed to get or create refund account:`);
+                return account;
+            }
+            refundAccount = account.value.account;
+        }
+        console.log(`[SubscriptionController] [cancelContract contractId: ${item.id} contractAccountId: ${contractAccount.value.account.id} refundAccountId: ${refundAccount.id}] Attempting to cancel contract.`);
+        const refundId = this._financialController.generateId();
+        const cancelId = this._financialController.generateId();
+        const transferResult = await this._financialController.internalTransaction({
+            transfers: [
+                {
+                    transferId: refundId,
+                    amount: AMOUNT_MAX,
+                    debitAccountId: contractAccount.value.account.id,
+                    creditAccountId: refundAccount.id,
+                    code: TransferCodes.contract_refund,
+                    currency: CurrencyCodes.usd,
+                    balancingDebit: true,
+                },
+                {
+                    transferId: cancelId,
+                    amount: 0,
+                    debitAccountId: contractAccount.value.account.id,
+                    creditAccountId: refundAccount.id,
+                    code: TransferCodes.account_closing,
+                    currency: CurrencyCodes.usd,
+                    closingDebit: true,
+                },
+            ],
+        });
+        if (isFailure(transferResult)) {
+            logError(transferResult.error, `[SubscriptionController] [cancelContract] Failed to refund contract:`);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'Failed to refund the contract.',
+            });
+        }
+        const transfer = await this._financialController.getTransfer(refundId);
+        if (isFailure(transfer)) {
+            logError(transfer.error, `[SubscriptionController] [cancelContract] Failed to get transfer for contract refund:`);
+            return failure({
+                errorCode: 'server_error',
+                errorMessage: 'The server encountered an error.',
+            });
+        }
+        return success({
+            refundedAmount: Number(transfer.value.amount),
+            refundCurrency: CURRENCIES.get(transfer.value.ledger),
+        });
+    }
+    /**
+     * Completes a checkout session. Grants the user access to the purchased items or completes a contract purchase.
+     * @param request The request for the checkout session fulfillment.
+     * @returns A promise that resolves to the result of the checkout session fulfillment.
+     */
+    async fulfillCheckoutSession(request) {
+        try {
+            const session = await this._authStore.getCheckoutSessionById(request.sessionId);
+            if (!session) {
+                return {
+                    success: false,
+                    errorCode: 'not_found',
+                    errorMessage: 'The checkout session does not exist.',
+                };
+            }
+            if (!!session.userId && session.userId !== request.userId) {
+                return {
+                    success: false,
+                    errorCode: 'not_authorized',
+                    errorMessage: 'You are not authorized to accept fulfillment of this checkout session.',
+                };
+            }
+            if (session.stripeStatus === 'expired') {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The checkout session has expired.',
+                };
+            }
+            else if (session.stripeStatus === 'open') {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The checkout session has not been completed.',
+                };
+            }
+            else if (session.stripePaymentStatus === 'unpaid') {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The checkout session has not been paid for.',
+                };
+            }
+            else if (!session.paid) {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The checkout session has not been paid for.',
+                };
+            }
+            else if (session.fulfilledAtMs > 0) {
+                return {
+                    success: true,
+                };
+            }
+            console.log(`[SubscriptionController] [fulfillCheckoutSession sessionId: ${session.id} userId: ${session.userId}] Fulfilling checkout session.`);
+            if (session.transferIds && session.transfersPending) {
+                console.log(`[SubscriptionController] [fulfillCheckoutSession sessionId: ${session.id} userId: ${session.userId} transactionId: ${session.transactionId}] Posting pending transfers.`);
+                const transferResult = await this._financialController.completePendingTransfers({
+                    transfers: session.transferIds,
+                    transactionId: session.transactionId,
+                });
+                if (isFailure(transferResult)) {
+                    if (transferResult.error.errorCode !==
+                        'transfer_already_completed') {
+                        logError(transferResult.error, `[SubscriptionController] [fulfillCheckoutSession sessionId: ${session.id} userId: ${session.userId}] Failed to complete pending transfers for checkout session:`);
+                        return {
+                            success: false,
+                            errorCode: 'server_error',
+                            errorMessage: 'A server error occurred.',
+                        };
+                    }
+                }
+            }
+            if (request.activation === 'now') {
+                if (!request.userId) {
+                    return {
+                        success: false,
+                        errorCode: 'invalid_request',
+                        errorMessage: 'Guests cannot accept immediate fulfillment of a checkout session.',
+                    };
+                }
+                console.log(`[SubscriptionController] [fulfillCheckoutSession sessionId: ${session.id} userId: ${session.userId}] Activating checkout session.`);
+                // grant user access to the items
+                for (let item of session.items) {
+                    if (item.type === 'role') {
+                        const result = await this._policyStore.assignSubjectRole(item.recordName, session.userId, 'user', {
+                            role: item.role,
+                            expireTimeMs: item.roleGrantTimeMs
+                                ? Date.now() + item.roleGrantTimeMs
+                                : null,
+                        });
+                        if (result.success === false) {
+                            console.error(`[SubscriptionController] [fulfillCheckoutSession sessionId: ${session.id} userId: ${session.userId}] Unable to grant role to user:`, result);
+                            return {
+                                success: false,
+                                errorCode: 'server_error',
+                                errorMessage: 'A server error occurred.',
+                            };
+                        }
+                        await this._authStore.savePurchasedItem({
+                            id: uuid(),
+                            activatedTimeMs: Date.now(),
+                            recordName: item.recordName,
+                            purchasableItemAddress: item.purchasableItemAddress,
+                            roleName: item.role,
+                            roleGrantTimeMs: item.roleGrantTimeMs,
+                            userId: session.userId,
+                            activationKeyId: null,
+                            checkoutSessionId: session.id,
+                        });
+                    }
+                    else if (item.type === 'contract') {
+                        // open contract
+                        await this._contractRecords.markPendingContractAsOpen(item.recordName, item.contractAddress);
+                    }
+                    else {
+                        // console.warn(
+                        //     `[SubscriptionController] [fulfillCheckoutSession sessionId: ${session.id} userId: ${session.userId}] Unknown item type: ${item.type}`
+                        // );
+                    }
+                }
+                await this._authStore.markCheckoutSessionFulfilled(session.id, Date.now());
+                return {
+                    success: true,
+                };
+            }
+            else {
+                if (session.items.some((i) => i.type === 'contract')) {
+                    console.log(`[SubscriptionController] [fulfillCheckoutSession sessionId: ${session.id} userId: ${session.userId}] Cannot defer fulfillment of checkout session with contracts.`);
+                    return {
+                        success: false,
+                        errorCode: 'invalid_request',
+                        errorMessage: 'You cannot defer fulfillment of a checkout session with contracts.',
+                    };
+                }
+                console.log(`[SubscriptionController] [fulfillCheckoutSession sessionId: ${session.id} userId: ${session.userId}] Deferring activation for checkout session.`);
+                const secret = fromByteArray(randomBytes(ACCESS_KEY_SECRET_BYTE_LENGTH));
+                const keyId = fromByteArray(randomBytes(ACCESS_KEY_SECRET_BYTE_LENGTH));
+                const hash = hashHighEntropyPasswordWithSalt(secret, keyId);
+                await this._authStore.createActivationKey({
+                    id: keyId,
+                    secretHash: hash,
+                });
+                const key = formatV1ActivationKey(keyId, secret);
+                // grant user access to the items
+                for (let item of session.items) {
+                    if (item.type === 'role') {
+                        await this._authStore.savePurchasedItem({
+                            id: uuid(),
+                            activatedTimeMs: null,
+                            recordName: item.recordName,
+                            purchasableItemAddress: item.purchasableItemAddress,
+                            roleName: item.role,
+                            roleGrantTimeMs: item.roleGrantTimeMs,
+                            userId: null,
+                            activationKeyId: keyId,
+                            checkoutSessionId: session.id,
+                        });
+                    }
+                    else {
+                        console.warn(`[SubscriptionController] [fulfillCheckoutSession sessionId: ${session.id} userId: ${session.userId}] Unknown item type: ${item.type}`);
+                    }
+                }
+                await this._authStore.markCheckoutSessionFulfilled(session.id, Date.now());
+                const config = await this._getConfig();
+                return {
+                    success: true,
+                    activationKey: key,
+                    activationUrl: activationRoute(config.returnUrl, key),
+                };
+            }
+        }
+        catch (err) {
+            console.error('[SubscriptionController] An error occurred while fulfilling a checkout session:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async claimActivationKey(request) {
+        try {
+            if (!request.userId && request.target === 'self') {
+                return {
+                    success: false,
+                    errorCode: 'not_logged_in',
+                    errorMessage: 'You need to be logged in to use target = self.',
+                };
+            }
+            const key = parseActivationKey(request.activationKey);
+            if (!key) {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The activation key is invalid.',
+                };
+            }
+            const [keyId, secret] = key;
+            const activationKey = await this._authStore.getActivationKeyById(keyId);
+            if (!activationKey) {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The activation key is invalid.',
+                };
+            }
+            const hash = hashHighEntropyPasswordWithSalt(secret, keyId);
+            if (activationKey.secretHash !== hash) {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The activation key is invalid.',
+                };
+            }
+            let userId;
+            let sessionKey;
+            let connectionKey;
+            let expireTimeMs;
+            if (request.target === 'self') {
+                userId = request.userId;
+            }
+            else if (request.target === 'guest') {
+                console.log('[SubscriptionController] [claimActivationKey] Creating user for guest activation key.');
+                const accountResult = await this._auth.createAccount({
+                    userRole: 'superUser',
+                    ipAddress: request.ipAddress,
+                });
+                if (accountResult.success === false) {
+                    console.error(`[SubscriptionController] [claimActivationKey keyId: ${keyId}] Unable to create user for guest activation key:`, accountResult);
+                    return {
+                        success: false,
+                        errorCode: 'server_error',
+                        errorMessage: 'A server error occurred.',
+                    };
+                }
+                userId = accountResult.userId;
+                sessionKey = accountResult.sessionKey;
+                connectionKey = accountResult.connectionKey;
+                expireTimeMs = accountResult.expireTimeMs;
+            }
+            console.log(`[SubscriptionController] [claimActivationKey keyId: ${keyId} userId: ${request.userId}] Claiming activation key.`);
+            if (!userId) {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The activation key is invalid.',
+                };
+            }
+            const items = await this._authStore.listPurchasedItemsByActivationKeyId(keyId);
+            for (let item of items) {
+                if (item.activatedTimeMs || item.userId) {
+                    continue;
+                }
+                const result = await this._policyStore.assignSubjectRole(item.recordName, userId, 'user', {
+                    role: item.roleName,
+                    expireTimeMs: item.roleGrantTimeMs
+                        ? Date.now() + item.roleGrantTimeMs
+                        : null,
+                });
+                if (result.success === false) {
+                    console.error(`[SubscriptionController] [claimActivationKey keyId: ${keyId} userId: ${userId}] Unable to grant role to user:`, result);
+                    return {
+                        success: false,
+                        errorCode: 'server_error',
+                        errorMessage: 'A server error occurred.',
+                    };
+                }
+                await this._authStore.savePurchasedItem({
+                    ...item,
+                    activatedTimeMs: Date.now(),
+                    userId,
+                });
+            }
+            return {
+                success: true,
+                userId,
+                sessionKey,
+                connectionKey,
+                expireTimeMs,
+            };
+        }
+        catch (err) {
+            console.error('[SubscriptionController] An error occurred while claiming an activation key:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    /**
+     * Handles the webhook from Stripe for updating the internal database.
+     */
+    async handleStripeWebhook(request) {
+        if (!this._stripe) {
+            return {
+                success: false,
+                errorCode: 'not_supported',
+                errorMessage: 'This method is not supported.',
+            };
+        }
+        try {
+            if (typeof request.requestBody !== 'string' ||
+                request.requestBody === '') {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The request was not valid.',
+                };
+            }
+            if (typeof request.signature !== 'string' ||
+                request.signature === '') {
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The request was not valid.',
+                };
+            }
+            const config = await this._getConfig();
+            const body = request.requestBody;
+            const signature = request.signature;
+            let event;
+            try {
+                event = this._stripe.constructWebhookEvent(body, signature, config.webhookSecret);
+            }
+            catch (err) {
+                console.log(`[SubscriptionController] [handleStripeWebhook] Unable to construct webhook event:`, err);
+                return {
+                    success: false,
+                    errorCode: 'invalid_request',
+                    errorMessage: 'The request was not valid.',
+                };
+            }
+            console.log(`[SubscriptionController] [handleStripeWebhook] Got event: ${event.type}`);
+            if (event.type === 'customer.subscription.created' ||
+                event.type === 'customer.subscription.deleted' ||
+                event.type === 'customer.subscription.updated') {
+                const subscription = event.data.object;
+                return await this._handleStripeSubscriptionEvent(config, event, subscription);
+            }
+            else if (event.type === 'invoice.paid') {
+                const parseResult = STRIPE_EVENT_INVOICE_PAID_SCHEMA.safeParse(event);
+                if (parseResult.success === false) {
+                    console.error(`[SubscriptionController] [handleStripeWebhook] Unable to parse stripe event!`, parseResult.error);
+                    return {
+                        success: true,
+                    };
+                }
+                return await this._handleStripeInvoicePaidEvent(config, event, parseResult.data.data.object);
+            }
+            else if (event.type === 'account.updated') {
+                const parseResult = STRIPE_EVENT_ACCOUNT_UPDATED_SCHEMA.safeParse(event);
+                if (parseResult.success === false) {
+                    console.error(`[SubscriptionController] [handleStripeWebhook] Unable to parse stripe event!`, parseResult.error);
+                    return {
+                        success: false,
+                        errorCode: 'invalid_request',
+                        errorMessage: 'The request was not able to be parsed.',
+                    };
+                }
+                return await this._handleStripeAccountUpdatedEvent(config, parseResult.data);
+            }
+            else if (event.type === 'checkout.session.completed' ||
+                event.type === 'checkout.session.expired' ||
+                event.type === 'checkout.session.async_payment_failed' ||
+                event.type === 'checkout.session.async_payment_succeeded') {
+                const parseResult = STRIPE_EVENT_CHECKOUT_SESSION_SCHEMA.safeParse(event);
+                if (parseResult.success === false) {
+                    console.error(`[SubscriptionController] [handleStripeWebhook] Unable to parse stripe event!`, parseResult.error);
+                    return {
+                        success: false,
+                        errorCode: 'invalid_request',
+                        errorMessage: 'The request was not able to be parsed.',
+                    };
+                }
+                return await this._handleStripeCheckoutSessionEvent(config, event, parseResult.data);
+            }
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            span?.recordException(err);
+            console.error('[SubscriptionController] An error occurred while handling a stripe webhook:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async _handleStripeCheckoutSessionEvent(config, event, sessionEvent) {
+        const stripeSession = sessionEvent.data.object;
+        const sessionId = stripeSession.client_reference_id;
+        if (!sessionId) {
+            console.log(`[SubscriptionController] [handleStripeWebhook] No client_reference_id found in the event.`);
+            return {
+                success: true,
+            };
+        }
+        const session = await this._authStore.getCheckoutSessionById(sessionId);
+        if (!session) {
+            console.log(`[SubscriptionController] [handleStripeWebhook] Could not find session with ID (${sessionId}).`);
+            return {
+                success: false,
+                errorCode: 'invalid_request',
+                errorMessage: 'The session could not be found.',
+            };
+        }
+        if (session.stripeCheckoutSessionId !== stripeSession.id) {
+            console.log(`[SubscriptionController] [handleStripeWebhook] Stripe checkout session ID (${stripeSession.id}) does not match stored ID (${session.stripeCheckoutSessionId}).`);
+            return {
+                success: false,
+                errorCode: 'invalid_request',
+                errorMessage: 'The session ID does not match the expected session ID.',
+            };
+        }
+        console.log(`[SubscriptionController] [handleStripeWebhook] [sessionId: ${sessionId} stripeCheckoutSessionId: ${stripeSession.id} status: ${stripeSession.status} paymentStatus: ${stripeSession.payment_status}] Checkout session updated for session ID.`);
+        const paid = stripeSession.payment_status === 'no_payment_required' ||
+            stripeSession.payment_status === 'paid';
+        await this._authStore.updateCheckoutSessionInfo({
+            ...session,
+            paid,
+            paymentStatus: stripeSession.payment_status,
+            status: stripeSession.status,
+            invoice: null,
+        });
+        if (event.type === 'checkout.session.expired') {
+            if (session.transferIds && session.transfersPending) {
+                console.log(`[SubscriptionController] [handleStripeWebhook] [sessionId: ${sessionId} stripeCheckoutSessionId: ${stripeSession.id} transferIds: [${session.transferIds.join(',')}]] Voiding pending transfers.`);
+                const result = await this._financialController.completePendingTransfers({
+                    transfers: session.transferIds,
+                    transactionId: session.transactionId,
+                    flags: TransferFlags.void_pending_transfer,
+                });
+                if (isFailure(result)) {
+                    logError(result.error, `[SubscriptionController] [handleStripeWebhook] Failed to void pending transfers for session ID: ${sessionId}`);
+                    return {
+                        success: false,
+                        errorCode: 'server_error',
+                        errorMessage: 'Failed to void pending transfers for session ID.',
+                    };
+                }
+                else {
+                    await this._authStore.updateCheckoutSessionInfo({
+                        ...session,
+                        paid,
+                        paymentStatus: stripeSession.payment_status,
+                        status: stripeSession.status,
+                        invoice: null,
+                        transfersPending: false,
+                    });
+                }
+            }
+        }
+        if (paid &&
+            !session.fulfilledAtMs &&
+            session.shouldBeAutomaticallyFulfilled) {
+            console.log(`[SubscriptionController] [handleStripeWebhook] [sessionId: ${sessionId} stripeCheckoutSessionId: ${stripeSession.id}] Automatically fulfilling checkout session.`);
+            const result = await this.fulfillCheckoutSession({
+                userId: session.userId,
+                activation: 'now',
+                sessionId,
+            });
+            if (result.success === false) {
+                console.error(`[SubscriptionController] [handleStripeWebhook] Failed to fulfill checkout session:`, result);
+                return {
+                    success: false,
+                    errorCode: 'server_error',
+                    errorMessage: 'Failed to fulfill checkout session for session ID.',
+                };
+            }
+        }
+        return {
+            success: true,
+        };
+    }
+    async _handleStripeAccountUpdatedEvent(config, event) {
+        const accountId = event.data.object.id;
+        const account = await this._stripe.getAccountById(accountId);
+        let studio = await this._recordsStore.getStudioByStripeAccountId(accountId);
+        if (studio) {
+            return await this._handleStudioStripeAccountUpdatedEvent(account, studio);
+        }
+        const user = await this._authStore.findUserByStripeAccountId(accountId);
+        if (user) {
+            return await this._handleUserStripeAccountUpdatedEvent(account, user);
+        }
+        console.warn(`[SubscriptionController] [handleStripeWebhook] No user or studio found for account ID (${accountId}).`);
+        return {
+            success: true,
+        };
+    }
+    async _handleStudioStripeAccountUpdatedEvent(account, studio) {
+        if (!studio) {
+            console.log(`[SubscriptionController] [handleStripeWebhook] No studio found for account ID (${account.id}).`);
+            return {
+                success: true,
+            };
+        }
+        const newStatus = getAccountStatus(account);
+        const newRequirementsStatus = getAccountRequirementsStatus(account);
+        if (studio.stripeAccountStatus !== newStatus ||
+            studio.stripeAccountRequirementsStatus !== newRequirementsStatus) {
+            console.log(`[SubscriptionController] [handleStripeWebhook] Updating studio (${studio.id}) account status to ${newStatus} and requirements status to ${newRequirementsStatus}.`);
+            studio = {
+                ...studio,
+                stripeAccountStatus: newStatus,
+                stripeAccountRequirementsStatus: newRequirementsStatus,
+            };
+            await this._recordsStore.updateStudio(studio);
+        }
+        return {
+            success: true,
+        };
+    }
+    async _handleUserStripeAccountUpdatedEvent(account, user) {
+        if (!user) {
+            console.log(`[SubscriptionController] [handleStripeWebhook] No user found for account ID (${account.id}).`);
+            return {
+                success: true,
+            };
+        }
+        const newStatus = getAccountStatus(account);
+        const newRequirementsStatus = getAccountRequirementsStatus(account);
+        if (user.stripeAccountStatus !== newStatus ||
+            user.stripeAccountRequirementsStatus !== newRequirementsStatus) {
+            console.log(`[SubscriptionController] [handleStripeWebhook] Updating user (${user.id}) account status to ${newStatus} and requirements status to ${newRequirementsStatus}.`);
+            user = {
+                ...user,
+                stripeAccountStatus: newStatus,
+                stripeAccountRequirementsStatus: newRequirementsStatus,
+            };
+            await this._authStore.saveUser(user);
+        }
+        return {
+            success: true,
+        };
+    }
+    async _handleStripeInvoicePaidEvent(config, event, invoice) {
+        const stripeSubscriptionId = invoice.subscription;
+        if (stripeSubscriptionId) {
+            const subscription = await this._stripe.getSubscriptionById(stripeSubscriptionId);
+            const status = subscription.status;
+            const customerId = invoice.customer;
+            const lineItems = invoice.lines.data;
+            const periodStartMs = subscription.current_period_start * 1000;
+            const periodEndMs = subscription.current_period_end * 1000;
+            const { sub, item } = findMatchingSubscription(lineItems);
+            const authInvoice = {
+                currency: invoice.currency,
+                description: invoice.description,
+                paid: invoice.paid,
+                status: invoice.status,
+                tax: invoice.tax,
+                total: invoice.total,
+                subtotal: invoice.subtotal,
+                stripeInvoiceId: invoice.id,
+                stripeHostedInvoiceUrl: invoice.hosted_invoice_url,
+                stripeInvoicePdfUrl: invoice.invoice_pdf,
+            };
+            console.log(`[SubscriptionController] [handleStripeWebhook] New invoice paid for customer ID (${customerId}). Subscription ID: ${subscription.id}. Period start: ${periodStartMs}. Period end: ${periodEndMs}.`);
+            if (!sub) {
+                console.error(`[SubscriptionController] [handleStripeWebhook] No matching subscription found for invoice (${invoice.id}).`);
+                return {
+                    success: false,
+                    errorCode: 'server_error',
+                    errorMessage: 'No matching subscription found.',
+                };
+            }
+            const user = await this._authStore.findUserByStripeCustomerId(customerId);
+            if (user) {
+                console.log(`[SubscriptionController] [handleStripeWebhook] Found user (${user.id}) with customer ID (${customerId}).`);
+                await this._authStore.updateSubscriptionPeriod({
+                    userId: user.id,
+                    subscriptionStatus: status,
+                    subscriptionId: sub.id,
+                    stripeSubscriptionId,
+                    stripeCustomerId: customerId,
+                    currentPeriodEndMs: periodEndMs,
+                    currentPeriodStartMs: periodStartMs,
+                    invoice: authInvoice,
+                });
+                const creditResult = await this._internalTransactionPurchaseCreditsStripe(sub, invoice, {
+                    userId: user.id,
+                });
+                if (isFailure(creditResult)) {
+                    return genericResult(creditResult);
+                }
+            }
+            else {
+                console.log(`[SubscriptionController] [handleStripeWebhook] No user found for customer ID (${customerId}).`);
+                const studio = await this._recordsStore.getStudioByStripeCustomerId(customerId);
+                if (studio) {
+                    await this._authStore.updateSubscriptionPeriod({
+                        studioId: studio.id,
+                        subscriptionStatus: status,
+                        subscriptionId: sub.id,
+                        stripeSubscriptionId,
+                        stripeCustomerId: customerId,
+                        currentPeriodEndMs: periodEndMs,
                         currentPeriodStartMs: periodStartMs,
                         invoice: authInvoice,
                     });
+                    const creditResult = await this._internalTransactionPurchaseCreditsStripe(sub, invoice, {
+                        studioId: studio.id,
+                    });
+                    if (isFailure(creditResult)) {
+                        return genericResult(creditResult);
+                    }
                 }
                 else {
-                    console.log(`[SubscriptionController] [handleStripeWebhook] No user found for customer ID (${customerId}).`);
-                    const studio = await this._recordsStore.getStudioByStripeCustomerId(customerId);
-                    if (studio) {
-                        await this._authStore.updateSubscriptionPeriod({
-                            studioId: studio.id,
-                            subscriptionStatus: status,
-                            subscriptionId: sub.id,
-                            stripeSubscriptionId,
-                            stripeCustomerId: customerId,
-                            currentPeriodEndMs: periodEndMs,
-                            currentPeriodStartMs: periodStartMs,
-                            invoice: authInvoice,
-                        });
-                    }
-                    else {
-                        console.log(`[SubscriptionController] [handleStripeWebhook] No studio found for customer ID (${customerId}).`);
-                    }
+                    console.log(`[SubscriptionController] [handleStripeWebhook] No studio found for customer ID (${customerId}).`);
                 }
-                function findMatchingSubscription(lineItems) {
-                    let item;
-                    let sub;
-                    items_loop: for (let i of lineItems) {
-                        for (let s of config.subscriptions) {
-                            if (s.eligibleProducts &&
-                                s.eligibleProducts.some((p) => p === i.price.product)) {
-                                sub = s;
-                                item = i;
-                                break items_loop;
-                            }
+            }
+            function findMatchingSubscription(lineItems) {
+                let item;
+                let sub;
+                items_loop: for (let i of lineItems) {
+                    for (let s of config.subscriptions) {
+                        if ((s.eligibleProducts &&
+                            s.eligibleProducts.some((p) => p === i.price.product)) ||
+                            s.product === i.price.product) {
+                            sub = s;
+                            item = i;
+                            break items_loop;
                         }
                     }
-                    return { item, sub };
                 }
+                return { item, sub };
             }
-            return {
-                success: true,
-            };
         }
-        catch (err) {
-            const span = trace.getActiveSpan();
-            span.recordException(err);
-            console.error('[SubscriptionController] An error occurred while handling a stripe webhook:', err);
-            return {
-                success: false,
+        else {
+            console.log(`[SubscriptionController] [handleStripeWebhook] No subscription ID found in invoice.`);
+            const authInvoice = await this._authStore.getInvoiceByStripeId(invoice.id);
+            if (!authInvoice) {
+                console.log(`[SubscriptionController] [handleStripeWebhook] No invoice found for stripe ID (${invoice.id}).`);
+                return {
+                    success: true,
+                };
+            }
+            await this._authStore.saveInvoice({
+                ...authInvoice,
+                currency: invoice.currency,
+                description: invoice.description,
+                paid: invoice.paid,
+                status: invoice.status,
+                tax: invoice.tax,
+                total: invoice.total,
+                subtotal: invoice.subtotal,
+            });
+        }
+        return {
+            success: true,
+        };
+    }
+    async _internalTransactionPurchaseCreditsStripe(sub, invoice, accountFilter) {
+        const creditGrant = sub.creditGrant ?? 0;
+        if (creditGrant === 0 || !this._financialController) {
+            return success();
+        }
+        const account = await this._financialController.getOrCreateFinancialAccount({
+            ...accountFilter,
+            ledger: LEDGERS.credits,
+        });
+        if (isFailure(account)) {
+            logError(account.error, `[SubscriptionController] [_internalTransactionPurchaseCreditsStripe invoice: ${invoice.id}] Unable to get or create credit account!`);
+            return failure({
                 errorCode: 'server_error',
                 errorMessage: 'A server error occurred.',
+            });
+        }
+        const accountId = account.value.account.id;
+        let creditAmount;
+        if (creditGrant === 'match-invoice') {
+            const converted = convertBetweenLedgers(LEDGERS.usd, LEDGERS.credits, BigInt(invoice.total));
+            if (converted.remainder > 0n) {
+                console.warn(`[SubscriptionController] [_internalTransactionPurchaseCreditsStripe invoice: ${invoice.id} account: ${accountId}] Rounding down remainder when converting invoice amount to credits.`);
+            }
+            creditAmount = converted.value;
+        }
+        else {
+            creditAmount = BigInt(creditGrant);
+        }
+        if (creditAmount > 0) {
+            const transactionResult = await this._financialController.internalTransaction({
+                transfers: [
+                    {
+                        amount: invoice.total,
+                        code: TransferCodes.purchase_credits,
+                        debitAccountId: ACCOUNT_IDS.assets_stripe,
+                        creditAccountId: ACCOUNT_IDS.liquidity_usd,
+                        currency: 'usd',
+                    },
+                    {
+                        amount: creditAmount,
+                        code: TransferCodes.purchase_credits,
+                        debitAccountId: ACCOUNT_IDS.liquidity_credits,
+                        creditAccountId: accountId,
+                        currency: 'credits',
+                    },
+                ],
+            });
+            if (isFailure(transactionResult)) {
+                logError(transactionResult.error, `[SubscriptionController] [_internalTransactionPurchaseCreditsStripe invoice: ${invoice.id} account: ${accountId}] Unable to record credit grant for invoice!`);
+                return failure({
+                    errorCode: 'server_error',
+                    errorMessage: 'Unable to record credit grant for invoice.',
+                });
+            }
+            console.log(`[SubscriptionController] [_internalTransactionPurchaseCreditsStripe invoice: ${invoice.id} account: ${accountId}] Granted ${creditAmount} credits for invoice (${invoice.id}).`);
+        }
+        else {
+            console.warn(`[SubscriptionController] [_internalTransactionPurchaseCreditsStripe invoice: ${invoice.id} account: ${accountId}] No credits granted for invoice (${invoice.id}).`);
+        }
+        return success();
+    }
+    async _handleStripeSubscriptionEvent(config, event, subscription) {
+        const items = subscription.items.data;
+        let item;
+        let sub;
+        items_loop: for (let i of items) {
+            for (let s of config.subscriptions) {
+                if (s.eligibleProducts &&
+                    s.eligibleProducts.some((p) => p === i.price.product)) {
+                    sub = s;
+                    item = i;
+                    break items_loop;
+                }
+            }
+        }
+        if (!item || !sub) {
+            console.log(`[SubscriptionController] [handleStripeWebhook] No item in the subscription matches an eligible product in the config.`);
+            return {
+                success: true,
             };
         }
+        console.log(`[SubscriptionController] [handleStripeWebhook] Subscription (${sub.id}) found!`);
+        const status = subscription.status;
+        const active = isActiveSubscription(status);
+        const tier = sub.tier ?? 'beta';
+        const customerId = subscription.customer;
+        const stripeSubscriptionId = subscription.id;
+        const periodStartMs = subscription.current_period_start * 1000;
+        const periodEndMs = subscription.current_period_end * 1000;
+        console.log(`[SubscriptionController] [handleStripeWebhook] Customer ID: ${customerId}. Subscription status: ${status}. Tier: ${tier}. Is Active: ${active}.`);
+        let user = await this._authStore.findUserByStripeCustomerId(customerId);
+        let studio;
+        if (user) {
+            await this._authStore.updateSubscriptionInfo({
+                userId: user.id,
+                subscriptionStatus: status,
+                subscriptionId: sub.id,
+                stripeSubscriptionId,
+                stripeCustomerId: customerId,
+                currentPeriodEndMs: periodEndMs,
+                currentPeriodStartMs: periodStartMs,
+            });
+        }
+        else {
+            console.log(`[SubscriptionController] [handleStripeWebhook] No user found for Customer ID (${customerId})`);
+            studio = await this._recordsStore.getStudioByStripeCustomerId(customerId);
+            if (studio) {
+                await this._authStore.updateSubscriptionInfo({
+                    studioId: studio.id,
+                    subscriptionStatus: status,
+                    subscriptionId: sub.id,
+                    stripeSubscriptionId,
+                    stripeCustomerId: customerId,
+                    currentPeriodEndMs: periodEndMs,
+                    currentPeriodStartMs: periodStartMs,
+                });
+            }
+            else {
+                console.log(`[SubscriptionController] [handleStripeWebhook] No studio found for Customer ID (${customerId})`);
+            }
+        }
+        return {
+            success: true,
+        };
     }
 }
 __decorate([
     traced(TRACE_NAME)
 ], SubscriptionController.prototype, "getSubscriptionStatus", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "getBalances", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "listAccountTransfers", null);
 __decorate([
     traced(TRACE_NAME)
 ], SubscriptionController.prototype, "updateSubscription", null);
 __decorate([
     traced(TRACE_NAME)
 ], SubscriptionController.prototype, "createManageSubscriptionLink", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "createManageStoreAccountLink", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "createManageXpAccountLink", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "createStripeLoginLink", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "createStripeAccountSession", null);
 __decorate([
     traced(TRACE_NAME)
 ], SubscriptionController.prototype, "_createCheckoutSession", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "createPurchaseItemLink", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "_getContractPurchaseDetails", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "purchaseContract", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "cancelContract", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "invoiceContract", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "cancelInvoice", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "listContractInvoices", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "payContractInvoice", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "payoutAccount", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "_payoutToStripe", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "_payoutToCash", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "fulfillCheckoutSession", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "claimActivationKey", null);
 __decorate([
     traced(TRACE_NAME)
 ], SubscriptionController.prototype, "handleStripeWebhook", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "_handleStripeCheckoutSessionEvent", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "_handleStripeAccountUpdatedEvent", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "_handleStudioStripeAccountUpdatedEvent", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "_handleUserStripeAccountUpdatedEvent", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "_handleStripeInvoicePaidEvent", null);
+__decorate([
+    traced(TRACE_NAME)
+], SubscriptionController.prototype, "_handleStripeSubscriptionEvent", null);
+/**
+ * Gets the account status for the given stripe account.
+ * @param account The account that the status should be retrieved for.
+ */
+export function getAccountStatus(account) {
+    const disabledReason = account?.requirements?.disabled_reason;
+    if (disabledReason === 'under_review' ||
+        disabledReason === 'requirements.pending_verification') {
+        return 'pending';
+    }
+    else if (disabledReason === 'rejected.fraud' ||
+        disabledReason === 'rejected.incomplete_verification' ||
+        disabledReason === 'rejected.listed' ||
+        disabledReason === 'rejected.other' ||
+        disabledReason === 'rejected.terms_of_service') {
+        return 'rejected';
+    }
+    else if (disabledReason) {
+        return 'disabled';
+    }
+    else if (account.charges_enabled) {
+        return 'active';
+    }
+    return 'pending';
+}
+/**
+ * Gets the requirements status for the given stripe account.
+ * @param account The account.
+ */
+export function getAccountRequirementsStatus(account) {
+    const requirements = account?.requirements;
+    if (!requirements) {
+        return 'incomplete';
+    }
+    if (requirements.currently_due?.length > 0 ||
+        requirements.past_due?.length > 0) {
+        return 'incomplete';
+    }
+    return 'complete';
+}
 function returnRoute(basePath, user, studio) {
     if (user) {
         return basePath;
@@ -853,4 +3397,267 @@ function returnRoute(basePath, user, studio) {
 function studiosRoute(basePath, studioId, studioName) {
     return new URL(`/studios/${encodeURIComponent(studioId)}/${encodeURIComponent(studioName)}`, basePath).href;
 }
+function fulfillmentRoute(basePath, sessionId) {
+    return new URL(`/store/fulfillment/${sessionId}`, basePath).href;
+}
+function activationRoute(basePath, key) {
+    const url = new URL(`/store/activate`, basePath);
+    url.searchParams.set('key', key);
+    return url.href;
+}
+/**
+ * Formats a V1 access key.
+ * @param itemId The ID of the purchased item.
+ * @param secret The secret that should be used to access the purchased item.
+ */
+export function formatV1ActivationKey(itemId, secret) {
+    return `vAK1.${toBase64String(itemId)}.${toBase64String(secret)}`;
+}
+/**
+ * Parses the given access key.
+ * Returns null if the access key is invalid.
+ * @param key The key to parse.
+ */
+export function parseActivationKey(key) {
+    if (!key) {
+        return null;
+    }
+    if (!key.startsWith('vAK1.')) {
+        return null;
+    }
+    const withoutVersion = key.slice('vAK1.'.length);
+    let periodAfterId = withoutVersion.indexOf('.');
+    if (periodAfterId < 0) {
+        return null;
+    }
+    const idBase64 = withoutVersion.slice(0, periodAfterId);
+    const secretBase64 = withoutVersion.slice(periodAfterId + 1);
+    if (idBase64.length <= 0 || secretBase64.length <= 0) {
+        return null;
+    }
+    try {
+        const name = fromBase64String(idBase64);
+        const secret = fromBase64String(secretBase64);
+        return [name, secret];
+    }
+    catch (err) {
+        return null;
+    }
+}
+const TRANSFER_CODE_ACTIONS = new Map([
+    [TransferCodes.admin_credit, 'Admin credit'],
+    [TransferCodes.admin_debit, 'Admin debit'],
+    [TransferCodes.account_closing, 'Account closing'],
+    [TransferCodes.purchase_credits, 'Purchase credits'],
+    [TransferCodes.contract_payment, 'Contract payment'],
+    [TransferCodes.contract_refund, 'Contract refund'],
+    [TransferCodes.exchange, 'Exchange'],
+    [TransferCodes.invoice_payment, 'Invoice payment'],
+    [TransferCodes.item_payment, 'Item payment'],
+    [TransferCodes.purchase_credits, 'Credit purchase'],
+    [TransferCodes.reverse_transfer, 'Transfer reversal'],
+    [TransferCodes.store_platform_fee, 'Platform fee'],
+    [TransferCodes.xp_platform_fee, 'Platform fee'],
+    [TransferCodes.user_payout, 'Payout'],
+    [TransferCodes.control, 'Controlling transfer'],
+    [TransferCodes.exchange, 'Exchange'],
+]);
+/**
+ * Generates a human readable note for the given transfer.
+ * @param transfer The transfer that should be characterized.
+ */
+export function charactarizeTransfer(transfer) {
+    let action;
+    let source;
+    let destination;
+    action = TRANSFER_CODE_ACTIONS.get(transfer.code);
+    if (!action) {
+        return null;
+    }
+    if (transfer.code === TransferCodes.admin_credit) {
+        source = ACCOUNT_NAMES.get(transfer.debit_account_id);
+        destination = ACCOUNT_NAMES.get(transfer.credit_account_id);
+    }
+    else if (transfer.code === TransferCodes.admin_debit) {
+        destination = ACCOUNT_NAMES.get(transfer.credit_account_id);
+        source = ACCOUNT_NAMES.get(transfer.debit_account_id);
+    }
+    else if (transfer.code === TransferCodes.user_payout) {
+        destination = ACCOUNT_NAMES.get(transfer.credit_account_id);
+    }
+    else if (transfer.code === TransferCodes.exchange) {
+        if (transfer.debit_account_id === ACCOUNT_IDS.liquidity_usd ||
+            transfer.credit_account_id === ACCOUNT_IDS.liquidity_credits) {
+            // Exchanging from Credits to USD
+            source = 'Credits';
+            destination = 'USD';
+        }
+        else if (transfer.debit_account_id === ACCOUNT_IDS.liquidity_credits ||
+            transfer.credit_account_id === ACCOUNT_IDS.liquidity_usd) {
+            // Exchanging from USD to Credits
+            source = 'USD';
+            destination = 'Credits';
+        }
+    }
+    else if (transfer.code === TransferCodes.purchase_credits) {
+        source = ACCOUNT_NAMES.get(transfer.debit_account_id);
+    }
+    else if (transfer.code === TransferCodes.account_closing) {
+        source = ACCOUNT_NAMES.get(transfer.debit_account_id);
+        destination = ACCOUNT_NAMES.get(transfer.credit_account_id);
+    }
+    else if (transfer.code === TransferCodes.contract_payment ||
+        transfer.code === TransferCodes.invoice_payment ||
+        transfer.code === TransferCodes.item_payment) {
+        source = ACCOUNT_NAMES.get(transfer.debit_account_id);
+        destination = ACCOUNT_NAMES.get(transfer.credit_account_id);
+    }
+    else if (transfer.code === TransferCodes.contract_refund) {
+        destination = ACCOUNT_NAMES.get(transfer.credit_account_id);
+    }
+    if (source && destination) {
+        return `${action} from ${source} to ${destination}`;
+    }
+    else if (source) {
+        return `${action} from ${source}`;
+    }
+    else if (destination) {
+        return `${action} to ${destination}`;
+    }
+    else {
+        return action;
+    }
+}
+class TransactionBuilder {
+    constructor() {
+        this.transfers = [];
+        this.lineItems = [];
+        this._pending = false;
+        this._timeoutSeconds = 60 * 60; // 1 hour
+    }
+    usePendingTransfers(timeoutSeconds) {
+        this._pending = true;
+        this._timeoutSeconds = timeoutSeconds;
+        return this;
+    }
+    disablePendingTransfers() {
+        this._pending = false;
+        return this;
+    }
+    addTransfer(tansfer) {
+        this.transfers.push(tansfer);
+        return this;
+    }
+    addItem(item) {
+        if (item.pending ?? this._pending) {
+            this.transfers.push({
+                transferId: item.transferId,
+                amount: item.amount,
+                currency: item.currency,
+                code: item.code,
+                creditAccountId: item.creditAccountId,
+                debitAccountId: item.debitAccountId,
+                pending: true,
+                timeoutSeconds: item.timeoutSeconds ?? this._timeoutSeconds,
+            });
+        }
+        else {
+            this.transfers.push({
+                transferId: item.transferId,
+                amount: item.amount,
+                currency: item.currency,
+                code: item.code,
+                creditAccountId: item.creditAccountId,
+                debitAccountId: item.debitAccountId,
+            });
+        }
+        this.lineItems.push({
+            price_data: {
+                currency: item.currency,
+                unit_amount: item.amount,
+                product_data: {
+                    name: item.name,
+                    description: item.description,
+                    images: [],
+                    metadata: item.metadata,
+                },
+            },
+            quantity: 1,
+        });
+        return this;
+    }
+    // addTransfer(transfer: InternalTransfer): this {
+    //     this.transfers.push(transfer);
+    //     return this;
+    // }
+    // addExchange(info: {
+    //     debitAccountId: bigint,
+    //     debitCurrency: string,
+    //     credits: {
+    //         accountId: bigint,
+    //         amount: number,
+    //     }[],
+    //     creditCurrency: string,
+    //     pending?: boolean,
+    // }): this {
+    //     const total = info.credits.reduce((acc, credit) => acc + credit.amount, 0);
+    //     this.transfers.push({
+    //         amount: total,
+    //         code: TransferCodes.exchange,
+    //         debitAccountId: info.debitAccountId,
+    //         currency: info.debitCurrency,
+    //         creditAccountId: getLiquidityAccount(info.debitCurrency),
+    //         pending: info.pending ?? this._pending,
+    //     });
+    //     for (let credit of info.credits) {
+    //         this.transfers.push({
+    //             amount: credit.amount,
+    //             code: TransferCodes.exchange,
+    //             debitAccountId: getLiquidityAccount(info.creditCurrency),
+    //             creditAccountId: credit.accountId,
+    //             currency: info.creditCurrency,
+    //             pending: info.pending ?? this._pending,
+    //         });
+    //     }
+    //     return this;
+    // }
+    addContract(info) {
+        return this.addItem({
+            amount: info.item.initialValue,
+            code: TransferCodes.contract_payment,
+            creditAccountId: info.contractAccountId,
+            debitAccountId: info.debitAccountId,
+            currency: CurrencyCodes.usd,
+            pending: this._pending,
+            name: 'Contract',
+            description: info.item.description,
+            metadata: {
+                resourceKind: 'contract',
+                recordName: info.recordName,
+                address: info.item.address,
+            },
+        });
+    }
+    addContractApplicationFee(info) {
+        if (info.fee > 0) {
+            this.addItem({
+                amount: info.fee,
+                code: TransferCodes.xp_platform_fee,
+                debitAccountId: info.debitAccountId,
+                creditAccountId: ACCOUNT_IDS.revenue_xp_platform_fees,
+                currency: CurrencyCodes.usd,
+                pending: this._pending,
+                name: 'Application Fee',
+                // description: 'XP Platform Fee',
+                metadata: {
+                    fee: true,
+                    resourceKind: 'contract',
+                    recordName: info.recordName,
+                    address: info.item.address,
+                },
+            });
+        }
+        return this;
+    }
+}
 //# sourceMappingURL=SubscriptionController.js.map