@umituz/react-native-subscription 2.27.111 → 2.27.113

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.111",
+  "version": "2.27.113",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/credits/application/CreditsInitializer.ts

@@ -1,5 +1,3 @@
-import { Platform } from "react-native";
-import Constants from "expo-constants";
 import {
   getFirestore,
 } from "@umituz/react-native-firebase";
@@ -14,7 +12,8 @@ import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
 import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionStatus";
 import { CreditLimitCalculator } from "./CreditLimitCalculator";
 import { PurchaseMetadataGenerator } from "./PurchaseMetadataGenerator";
-import { creditAllocationContext } from "./credit-strategies/CreditAllocationContext";
+import { creditAllocationOrchestrator } from "./credit-strategies/CreditAllocationOrchestrator";
+import { getAppVersion, validatePlatform, isPast } from "../../../utils";
 import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
 
 export async function initializeCreditsTransaction(
@@ -40,7 +39,7 @@ export async function initializeCreditsTransaction(
                 status: "none",
                 processedPurchases: [],
                 purchaseHistory: [],
-                platform: Platform.OS as any,
+                platform: validatePlatform() as any,
                 lastUpdatedAt: now,
                 purchasedAt: now,
                 expirationDate: null,
@@ -68,15 +67,8 @@ export async function initializeCreditsTransaction(
 
         const creditLimit = CreditLimitCalculator.calculate(metadata.productId, config);
 
-        const platform = Platform.OS;
-        if (platform !== "ios" && platform !== "android") {
-            throw new Error(`Invalid platform: ${platform}`);
-        }
-
-        const appVersion = Constants.expoConfig?.version;
-        if (!appVersion) {
-            throw new Error("appVersion is required in expoConfig");
-        }
+        const platform = validatePlatform();
+        const appVersion = getAppVersion();
 
         const { purchaseHistory } = PurchaseMetadataGenerator.generate({
             productId: metadata.productId,
@@ -91,7 +83,7 @@ export async function initializeCreditsTransaction(
 
         let isExpired = false;
         if (metadata.expirationDate) {
-            isExpired = new Date(metadata.expirationDate).getTime() < Date.now();
+            isExpired = isPast(metadata.expirationDate);
         }
 
         const status = resolveSubscriptionStatus({
@@ -104,7 +96,7 @@ export async function initializeCreditsTransaction(
         const isStatusSync = purchaseId.startsWith("status_sync_");
         const isSubscriptionActive = isPremium && !isExpired;
 
-        const newCredits = creditAllocationContext.allocate({
+        const newCredits = creditAllocationOrchestrator.allocate({
             status,
             isStatusSync,
             existingData,
@@ -150,6 +142,24 @@ export async function initializeCreditsTransaction(
         creditsData.productId = metadata.productId;
         creditsData.platform = platform;
 
+        // Skip write if it's a status sync and data hasn't changed to save costs
+        if (isStatusSync && existingData) {
+            const hasChanged = 
+                existingData.isPremium !== creditsData.isPremium ||
+                existingData.status !== creditsData.status ||
+                existingData.credits !== creditsData.credits ||
+                existingData.creditLimit !== creditsData.creditLimit ||
+                existingData.productId !== creditsData.productId;
+
+            if (!hasChanged) {
+                return {
+                    credits: existingData.credits,
+                    alreadyProcessed: true,
+                    finalData: existingData
+                };
+            }
+        }
+
         transaction.set(creditsRef, creditsData, { merge: true });
 
         const finalData: UserCreditsDocumentRead = {

package/src/domains/credits/application/credit-strategies/{CreditAllocationContext.ts → CreditAllocationOrchestrator.ts}

@@ -4,9 +4,9 @@ import { TrialCreditStrategy } from "./TrialCreditStrategy";
 import { StandardPurchaseCreditStrategy } from "./StandardPurchaseCreditStrategy";
 
 /**
- * Strategy Context to coordinate credit allocation logic using the Strategy Pattern.
+ * Orchestrator to coordinate credit allocation logic using the Strategy Pattern.
  */
-export class CreditAllocationContext {
+export class CreditAllocationOrchestrator {
     private strategies: ICreditStrategy[] = [
         new SyncCreditStrategy(),
         new TrialCreditStrategy(),
@@ -25,11 +25,11 @@ export class CreditAllocationContext {
         }
 
         if (__DEV__) {
-            console.log(`[CreditAllocationContext] Using strategy: ${strategy.constructor.name}`);
+            console.log(`[CreditAllocationOrchestrator] Using strategy: ${strategy.constructor.name}`);
         }
 
         return strategy.execute(params);
     }
 }
 
-export const creditAllocationContext = new CreditAllocationContext();
+export const creditAllocationOrchestrator = new CreditAllocationOrchestrator();

package/src/domains/credits/application/credit-strategies/SyncCreditStrategy.ts

@@ -6,7 +6,7 @@ import { ICreditStrategy, type CreditAllocationParams } from "./ICreditStrategy"
  */
 export class SyncCreditStrategy implements ICreditStrategy {
     canHandle(params: CreditAllocationParams): boolean {
-        return params.isStatusSync && params.existingData?.isPremium === true && params.isSubscriptionActive;
+        return params.isStatusSync;
     }
 
     execute(params: CreditAllocationParams): number {

package/src/domains/credits/core/CreditsMapper.ts

@@ -3,17 +3,12 @@ import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionS
 import type { PeriodType, SubscriptionStatusType } from "../../subscription/core/SubscriptionConstants";
 import type { UserCreditsDocumentRead } from "./UserCreditsDocument";
 
+import { toSafeDate } from "../../../utils/dateUtils";
+
 /** Maps Firestore document to domain entity with expiration validation */
 export class CreditsMapper {
   static toEntity(doc: UserCreditsDocumentRead): UserCredits {
-    const safeDate = (ts: any): Date | null => {
-        if (!ts) return null;
-        if (typeof ts.toDate === "function") return ts.toDate();
-        if (ts instanceof Date) return ts;
-        return null;
-    };
-
-    const expirationDate = safeDate(doc.expirationDate);
+    const expirationDate = toSafeDate(doc.expirationDate);
     const periodType = doc.periodType;
 
     // Validate isPremium against expirationDate (real-time check)
@@ -25,10 +20,10 @@ export class CreditsMapper {
       status,
 
       // Dates
-      purchasedAt: safeDate(doc.purchasedAt) ?? new Date(),
+      purchasedAt: toSafeDate(doc.purchasedAt) ?? new Date(),
       expirationDate,
-      lastUpdatedAt: safeDate(doc.lastUpdatedAt) ?? new Date(),
-      lastPurchaseAt: safeDate(doc.lastPurchaseAt),
+      lastUpdatedAt: toSafeDate(doc.lastUpdatedAt) ?? new Date(),
+      lastPurchaseAt: toSafeDate(doc.lastPurchaseAt),
 
       // RevenueCat details
       willRenew: doc.willRenew,
@@ -39,8 +34,8 @@ export class CreditsMapper {
       // Trial fields
       periodType,
       isTrialing: doc.isTrialing,
-      trialStartDate: safeDate(doc.trialStartDate),
-      trialEndDate: safeDate(doc.trialEndDate),
+      trialStartDate: toSafeDate(doc.trialStartDate),
+      trialEndDate: toSafeDate(doc.trialEndDate),
       trialCredits: doc.trialCredits,
       convertedFromTrial: doc.convertedFromTrial,
 

package/src/domains/credits/infrastructure/{CreditsRepositoryProvider.ts → CreditsRepositoryManager.ts}

@@ -1,7 +1,7 @@
 /**
- * Credits Repository Provider
+ * Credits Repository Manager
  * Module-level singleton for credits repository configuration
- * Replaces Context API with a simpler, testable approach
+ * Provides a clean, testable approach for repository access
  */
 
 import type { CreditsConfig } from "../core/Credits";

package/src/domains/credits/presentation/useCredits.ts

@@ -14,7 +14,7 @@ import {
   getCreditsRepository,
   getCreditsConfig,
   isCreditsRepositoryConfigured,
-} from "../infrastructure/CreditsRepositoryProvider";
+} from "../infrastructure/CreditsRepositoryManager";
 import { calculateCreditPercentage, canAffordCost } from "../utils/creditCalculations";
 
 export const creditsQueryKeys = {

package/src/domains/credits/presentation/useDeductCredit.ts

@@ -6,7 +6,7 @@
 import { useCallback } from "react";
 import { useMutation, useQueryClient } from "@umituz/react-native-design-system";
 import type { UserCredits } from "../core/Credits";
-import { getCreditsRepository } from "../infrastructure/CreditsRepositoryProvider";
+import { getCreditsRepository } from "../infrastructure/CreditsRepositoryManager";
 import { creditsQueryKeys } from "./useCredits";
 import { calculateRemainingCredits } from "../utils/creditCalculations";
 
@@ -65,11 +65,11 @@ export const useDeductCredit = ({
         wasInsufficient: previousCredits.credits < cost
       };
     },
-    onError: (_err, _cost, context) => {
+    onError: (_err, _cost, mutationData) => {
       // Always restore previous credits on error to prevent UI desync
       // Use optional chaining to be safe
-      if (userId && context?.previousCredits && !context.skippedOptimistic) {
-         queryClient.setQueryData(creditsQueryKeys.user(userId), context.previousCredits);
+      if (userId && mutationData?.previousCredits && !mutationData.skippedOptimistic) {
+         queryClient.setQueryData(creditsQueryKeys.user(userId), mutationData.previousCredits);
       }
     },
     onSuccess: () => {

package/src/domains/paywall/components/PaywallContainer.types.ts

@@ -45,7 +45,7 @@ export interface PaywallContainerProps {
   /** Callback when purchase succeeds */
   readonly onPurchaseSuccess?: () => void;
   /** Callback when purchase fails */
-  readonly onPurchaseError?: (error: string) => void;
+  readonly onPurchaseError?: (error: Error | string) => void;
   /** Callback when auth is required (for anonymous users) */
   readonly onAuthRequired?: () => void;
   /** Visibility override */

package/src/domains/paywall/components/PaywallModal.tsx

@@ -2,9 +2,10 @@
  * Paywall Modal
  */
 
-import React, { useState, useCallback, useEffect } from "react";
-import { View, ScrollView, TouchableOpacity, Linking, type ImageSourcePropType } from "react-native";
-import { BaseModal, useAppDesignTokens, AtomicText, AtomicIcon, AtomicSpinner } from "@umituz/react-native-design-system";
+import React, { useCallback, useEffect } from "react";
+import { View, TouchableOpacity, Linking, type ImageSourcePropType } from "react-native";
+import { BaseModal, useAppDesignTokens, AtomicText, AtomicIcon, AtomicSpinner, useSafeAreaInsets } from "@umituz/react-native-design-system";
+import { ScreenLayout } from "../../../shared/presentation";
 import { Image } from "expo-image";
 import type { PurchasesPackage } from "react-native-purchases";
 import { PlanCard } from "./PlanCard";
@@ -12,7 +13,7 @@ import type { SubscriptionFeature, PaywallTranslations, PaywallLegalUrls } from
 import { paywallModalStyles as styles } from "./PaywallModal.styles";
 import { PaywallFeatures } from "./PaywallFeatures";
 import { PaywallFooter } from "./PaywallFooter";
-import { usePurchaseLoadingStore, selectIsPurchasing } from "../../subscription/presentation/stores";
+import { usePaywallActions } from "../hooks/usePaywallActions";
 
 /** Trial eligibility info per product */
 export interface TrialEligibilityInfo {
@@ -47,60 +48,28 @@ export interface PaywallModalProps {
 export const PaywallModal: React.FC<PaywallModalProps> = React.memo((props) => {
   const { visible, onClose, translations, packages = [], features = [], isLoading = false, legalUrls = {}, bestValueIdentifier, creditAmounts, creditsLabel, heroImage, onPurchase, onRestore, trialEligibility = {}, trialSubtitleText } = props;
   const tokens = useAppDesignTokens();
-  const [selectedPlanId, setSelectedPlanId] = useState<string | null>(null);
-  const [isLocalProcessing, setIsLocalProcessing] = useState(false);
-
-  // Global purchase loading state (for auto-execution after auth)
-  const isGlobalPurchasing = usePurchaseLoadingStore(selectIsPurchasing);
-  const { startPurchase, endPurchase } = usePurchaseLoadingStore();
+  const insets = useSafeAreaInsets();
+  
+  const {
+    selectedPlanId,
+    setSelectedPlanId,
+    isProcessing,
+    handlePurchase,
+    handleRestore,
+    resetState,
+  } = usePaywallActions({ packages, onPurchase, onRestore });
 
   // Reset selected plan when packages change
   useEffect(() => {
     setSelectedPlanId(null);
-  }, [packages]);
+  }, [packages, setSelectedPlanId]);
 
   // Cleanup state when modal closes to prevent stale state
   useEffect(() => {
     if (!visible) {
-      setSelectedPlanId(null);
-      setIsLocalProcessing(false);
-    }
-  }, [visible]);
-
-  // Combined processing state
-  const isProcessing = isLocalProcessing || isGlobalPurchasing;
-
-  const handlePurchase = useCallback(async () => {
-    if (!selectedPlanId || !onPurchase) return;
-
-    setIsLocalProcessing(true);
-    startPurchase(selectedPlanId, "manual");
-
-    try {
-      const pkg = packages.find((p) => p.product.identifier === selectedPlanId);
-      if (pkg) {
-        await onPurchase(pkg);
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error("[PaywallModal] Purchase failed:", error);
-      }
-    } finally {
-      setIsLocalProcessing(false);
-      endPurchase();
-    }
-  }, [selectedPlanId, packages, onPurchase, startPurchase, endPurchase]);
-
-  const handleRestore = useCallback(async () => {
-    if (!onRestore || isProcessing) return;
-
-    setIsLocalProcessing(true);
-    try {
-      await onRestore();
-    } finally {
-      setIsLocalProcessing(false);
+      resetState();
     }
-  }, [onRestore, isProcessing]);
+  }, [visible, resetState]);
 
   const handleLegalUrl = useCallback(async (url: string | undefined) => {
     if (!url) return;
@@ -110,11 +79,18 @@ export const PaywallModal: React.FC<PaywallModalProps> = React.memo((props) => {
   return (
     <BaseModal visible={visible} onClose={onClose} contentStyle={styles.modalContent}>
       <View style={[styles.container, { backgroundColor: tokens.colors.surface }]}>
-        <TouchableOpacity onPress={onClose} style={[styles.closeBtn, { backgroundColor: tokens.colors.surfaceSecondary }]} hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}>
+        <TouchableOpacity 
+          onPress={onClose} 
+          style={[
+            styles.closeBtn, 
+            { backgroundColor: tokens.colors.surfaceSecondary, top: Math.max(insets.top, 12) }
+          ]} 
+          hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
+        >
           <AtomicIcon name="close-outline" size="md" customColor={tokens.colors.textPrimary} />
         </TouchableOpacity>
 
-        <ScrollView showsVerticalScrollIndicator={false} contentContainerStyle={styles.scroll}>
+        <ScreenLayout scrollable={true} edges={["bottom"]} backgroundColor="transparent" contentContainerStyle={styles.scroll}>
           {heroImage && (
             <View style={styles.heroContainer}>
               <Image source={heroImage} style={styles.heroImage} contentFit="cover" transition={0} />
@@ -171,7 +147,7 @@ export const PaywallModal: React.FC<PaywallModalProps> = React.memo((props) => {
           </TouchableOpacity>
 
           <PaywallFooter translations={translations} legalUrls={legalUrls} isProcessing={isProcessing} onRestore={onRestore ? handleRestore : undefined} onLegalClick={handleLegalUrl} />
-        </ScrollView>
+        </ScreenLayout>
       </View>
     </BaseModal>
   );

package/src/domains/paywall/hooks/usePaywallActions.ts

@@ -1,55 +1,102 @@
-import { useCallback } from "react";
+/**
+ * usePaywallActions Hook
+ * Encapsulates purchase and restore flow for the paywall.
+ */
+import { useState, useCallback } from "react";
 import type { PurchasesPackage } from "react-native-purchases";
-import { useRestorePurchase } from "../../subscription/infrastructure/hooks/useRestorePurchase";
-import { useAuthAwarePurchase } from "../../subscription/presentation/useAuthAwarePurchase";
+import { usePurchaseLoadingStore } from "../../subscription/presentation/stores";
 import type { PurchaseSource } from "../../subscription/core/SubscriptionConstants";
 
-interface UsePaywallActionsProps {
+export interface UsePaywallActionsParams {
+  packages?: PurchasesPackage[];
+  onPurchase?: (pkg: PurchasesPackage) => Promise<void | boolean>;
+  onRestore?: () => Promise<void | boolean>;
   source?: PurchaseSource;
   onPurchaseSuccess?: () => void;
-  onPurchaseError?: (error: string) => void;
+  onPurchaseError?: (error: Error | string) => void;
   onAuthRequired?: () => void;
-  onClose: () => void;
+  onClose?: () => void;
 }
 
-export const usePaywallActions = ({
-  source,
+export function usePaywallActions({
+  packages = [],
+  onPurchase,
+  onRestore,
   onPurchaseSuccess,
   onPurchaseError,
-  onAuthRequired: _onAuthRequired,
+  onAuthRequired,
   onClose,
-}: UsePaywallActionsProps) => {
-  const { handlePurchase: authAwarePurchase } = useAuthAwarePurchase({ source });
-  const { mutateAsync: restorePurchases } = useRestorePurchase();
+}: UsePaywallActionsParams) {
+  const [selectedPlanId, setSelectedPlanId] = useState<string | null>(null);
+  const [isLocalProcessing, setIsLocalProcessing] = useState(false);
+
+  const { startPurchase, endPurchase } = usePurchaseLoadingStore();
+  const isGlobalPurchasing = usePurchaseLoadingStore((state) => state.isPurchasing);
+
+  const isProcessing = isLocalProcessing || isGlobalPurchasing;
+
+  const handlePurchase = useCallback(async () => {
+    // If no plan selected, use the first available one as fallback or return
+    const planId = selectedPlanId || (packages.length > 0 ? packages[0]?.product.identifier : null);
+    
+    if (!planId || !onPurchase || isProcessing) {
+        if (!planId && onAuthRequired) onAuthRequired();
+        return;
+    }
+
+    setIsLocalProcessing(true);
+    // Map PurchaseSource to store's expected "manual" | "auto-execution"
+    startPurchase(planId, "manual");
 
-  const handlePurchase = useCallback(async (pkg: PurchasesPackage) => {
     try {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[PaywallActions] Purchase started:", pkg.product.identifier);
+      const pkg = packages.find((p) => p.product.identifier === planId);
+      if (pkg) {
+        const success = await onPurchase(pkg);
+        if (success !== false) {
+          onPurchaseSuccess?.();
+          onClose?.(); // Close on success if provided
+        }
       }
-      const res = await authAwarePurchase(pkg, source);
-      if (res) {
-        onPurchaseSuccess?.();
-        onClose();
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      onPurchaseError?.(err);
+      if (__DEV__) {
+        console.error("[usePaywallActions] Purchase failed:", err);
       }
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      onPurchaseError?.(message);
+    } finally {
+      setIsLocalProcessing(false);
+      endPurchase();
     }
-  }, [authAwarePurchase, source, onClose, onPurchaseSuccess, onPurchaseError]);
+  }, [selectedPlanId, packages, onPurchase, isProcessing, startPurchase, endPurchase, onPurchaseSuccess, onPurchaseError, onAuthRequired, onClose]);
 
   const handleRestore = useCallback(async () => {
+    if (!onRestore || isProcessing) return;
+
+    setIsLocalProcessing(true);
     try {
-      const res = await restorePurchases();
-      if (res.success) {
+      const success = await onRestore();
+      if (success !== false) {
         onPurchaseSuccess?.();
-        onClose();
       }
-    } catch (err: unknown) {
-      const message = err instanceof Error ? err.message : String(err);
-      onPurchaseError?.(message);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      onPurchaseError?.(err);
+    } finally {
+      setIsLocalProcessing(false);
     }
-  }, [restorePurchases, onClose, onPurchaseSuccess, onPurchaseError]);
+  }, [onRestore, isProcessing, onPurchaseSuccess, onPurchaseError]);
 
-  return { handlePurchase, handleRestore };
-};
+  const resetState = useCallback(() => {
+    setSelectedPlanId(null);
+    setIsLocalProcessing(false);
+  }, []);
+
+  return {
+    selectedPlanId,
+    setSelectedPlanId,
+    isProcessing,
+    handlePurchase,
+    handleRestore,
+    resetState,
+  };
+}

package/src/domains/subscription/application/SubscriptionInitializer.ts

@@ -7,7 +7,7 @@
  */
 
 import { Platform } from "react-native";
-import { configureCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryProvider";
+import { configureCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
 import { SubscriptionManager } from "../infrastructure/managers/SubscriptionManager";
 import { configureAuthProvider } from "../presentation/useAuthAwarePurchase";
 import { SubscriptionSyncService } from "./SubscriptionSyncService";

package/src/domains/subscription/application/SubscriptionSyncService.ts

@@ -1,7 +1,7 @@
 import type { CustomerInfo } from "react-native-purchases";
 import type { RevenueCatData } from "../core/RevenueCatData";
 import { type PeriodType, type PurchaseSource, PURCHASE_SOURCE, PURCHASE_TYPE } from "../core/SubscriptionConstants";
-import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryProvider";
+import { getCreditsRepository } from "../../credits/infrastructure/CreditsRepositoryManager";
 import { extractRevenueCatData } from "./SubscriptionSyncUtils";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 
@@ -69,32 +69,56 @@ export class SubscriptionSyncService {
     periodType?: PeriodType
   ) {
     try {
+      // Handle subscription expiration explicitly
       if (!isPremium && productId) {
         await getCreditsRepository().syncExpiredStatus(userId);
         subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
         return;
       }
 
-      // If productId is missing, we can't initialize credits fully, 
-      // but if isPremium is true, we should have it.
-      // Fallback to 'unknown' if missing, but this might throw in CreditLimitCalculator.
-      const validProductId = productId ?? 'unknown_product';
+      // If not premium and no product, this is a freemium user.
+      // We only want to run initializeCredits for them if it's their first time,
+      // which initializeCredits handles, but we should avoid doing it on every sync.
+      if (!isPremium && !productId) {
+        // Option 1: Just skip if they are already known non-premium (handled by repository check)
+        // For now, let's just use a more stable sync ID to allow the repository to skip if possible
+        const stableSyncId = `init_sync_${userId}`;
+        
+        await getCreditsRepository().initializeCredits(
+          userId, 
+          stableSyncId, 
+          'no_subscription', 
+          PURCHASE_SOURCE.SETTINGS, 
+          { 
+            isPremium: false, 
+            expirationDate: null, 
+            willRenew: false, 
+            periodType: null, 
+            originalTransactionId: null 
+          },
+          PURCHASE_TYPE.INITIAL
+        );
+        
+        subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
+        return;
+      }
 
+      // Standard status sync for premium users
       const revenueCatData: RevenueCatData = { 
         expirationDate: expiresAt ?? null, 
         willRenew: willRenew ?? false, 
         isPremium, 
-        periodType: periodType ?? null, // Fix undefined vs null
-        originalTransactionId: null // Initialize with null as we might not have it here
+        periodType: periodType ?? null,
+        originalTransactionId: null 
       };
       
       await getCreditsRepository().initializeCredits(
         userId, 
         `status_sync_${Date.now()}`, 
-        validProductId, 
+        productId ?? 'no_subscription', 
         PURCHASE_SOURCE.SETTINGS, 
         revenueCatData,
-        PURCHASE_TYPE.INITIAL // Status sync treated as Initial or Update
+        PURCHASE_TYPE.INITIAL
       );
       
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);

package/src/domains/subscription/infrastructure/handlers/PackageHandler.ts

@@ -44,7 +44,7 @@ export class PackageHandler {
 
       return packages;
     } catch (error) {
-      // Re-throw with more context
+      // Re-throw with more detail
       throw new Error(
         `Failed to fetch subscription packages. ${
           error instanceof Error ? error.message : "Unknown error"

package/src/domains/subscription/presentation/screens/SubscriptionDetailScreen.tsx

@@ -8,8 +8,8 @@ import React, { useMemo } from "react";
 import { StyleSheet, View } from "react-native";
 import {
     useAppDesignTokens,
-    ScreenLayout,
 } from "@umituz/react-native-design-system";
+import { ScreenLayout } from "../../../../shared/presentation";
 import { SubscriptionHeader } from "./components/SubscriptionHeader";
 import { CreditsList, type CreditItem } from "./components/CreditsList";
 import { UpgradePrompt, type Benefit } from "./components/UpgradePrompt";

package/src/domains/subscription/presentation/usePaywallVisibility.ts

@@ -30,7 +30,7 @@ const setPaywallState = (visible: boolean, source?: PurchaseSource): void => {
 };
 
 /**
- * Direct paywall control for non-React contexts (e.g., appInitializer)
+ * Direct paywall control for non-React services (e.g., appInitializer)
  */
 export const paywallControl = {
   open: (source?: PurchaseSource) => setPaywallState(true, source),

package/src/domains/wallet/index.ts

@@ -119,11 +119,5 @@ export {
 export {
   WalletScreen,
   type WalletScreenProps,
-  type WalletScreenConfig,
   type WalletScreenTranslations,
 } from "./presentation/screens/WalletScreen";
-
-export {
-  WalletScreenContainer,
-  type WalletScreenContainerProps,
-} from "./presentation/screens/WalletScreenContainer";

package/src/domains/wallet/presentation/screens/WalletScreen.tsx

@@ -9,13 +9,15 @@
 import React from "react";
 import { View, StyleSheet, TouchableOpacity } from "react-native";
 import {
-    useSafeAreaInsets,
     useAppDesignTokens,
     AtomicText,
     AtomicIcon,
     AtomicSpinner,
-    ScreenLayout,
 } from "@umituz/react-native-design-system";
+import { ScreenLayout } from "../../../../shared/presentation";
+import { useNavigation } from "@react-navigation/native";
+import { useWallet } from "../hooks/useWallet";
+import { getWalletConfig } from "../../infrastructure/config/walletConfig";
 import {
     BalanceCard,
     type BalanceCardTranslations,
@@ -24,7 +26,6 @@ import {
     TransactionList,
     type TransactionListTranslations,
 } from "../components/TransactionList";
-import type { CreditLog } from "../../domain/types/transaction.types";
 
 export interface WalletScreenTranslations
   extends BalanceCardTranslations,
@@ -32,58 +33,72 @@ export interface WalletScreenTranslations
   screenTitle: string;
 }
 
-export interface WalletScreenConfig {
-  balance: number;
-  balanceLoading: boolean;
-  transactions: CreditLog[];
-  transactionsLoading: boolean;
-  translations: WalletScreenTranslations;
+export interface WalletScreenProps {
+  /** Translations (overrides global config) */
+  translations?: WalletScreenTranslations;
+  /** Override onBack handler (default: navigation.goBack) */
   onBack?: () => void;
+  /** Custom date formatter */
   dateFormatter?: (timestamp: number) => string;
-  maxTransactionHeight?: number;
-  balanceIconName?: string;
+  /** Footer component */
   footer?: React.ReactNode;
 }
 
-export interface WalletScreenProps {
-  config: WalletScreenConfig;
-}
-
-export const WalletScreen: React.FC<WalletScreenProps> = ({ config }) => {
+export const WalletScreen: React.FC<WalletScreenProps> = ({ 
+  translations,
+  onBack,
+  dateFormatter,
+  footer,
+}) => {
   const tokens = useAppDesignTokens();
-  const insets = useSafeAreaInsets();
+  const navigation = useNavigation();
+  const config = getWalletConfig();
+
+  const {
+    balance,
+    balanceLoading,
+    transactions,
+    transactionsLoading,
+  } = useWallet({
+    transactionConfig: {
+      collectionName: config.transactionCollection,
+      useUserSubcollection: config.useUserSubcollection,
+    },
+    transactionLimit: config.transactionLimit,
+  });
+
+  const activeTranslations = translations ?? config.translations;
+  const handleBack = onBack ?? (() => navigation.goBack());
 
   const renderHeader = () => (
-    <View style={[styles.header, { paddingTop: insets.top + 12 }]}>
-      {config.onBack && (
-        <TouchableOpacity
-          onPress={config.onBack}
-          style={styles.backButton}
-          hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
-        >
-          <AtomicIcon
-            name="arrow-left"
-            size="lg"
-            customColor={tokens.colors.textPrimary}
-          />
-        </TouchableOpacity>
-      )}
+    <View style={[styles.header, { paddingTop: 12 }]}>
+      <TouchableOpacity
+        onPress={handleBack}
+        style={styles.backButton}
+        hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
+      >
+        <AtomicIcon
+          name="arrow-left"
+          size="lg"
+          customColor={tokens.colors.textPrimary}
+        />
+      </TouchableOpacity>
       <AtomicText
         type="titleLarge"
         style={{ color: tokens.colors.textPrimary, fontWeight: "700" }}
       >
-        {config.translations.screenTitle}
+        {activeTranslations.screenTitle}
       </AtomicText>
     </View>
   );
 
   const renderBalance = () => {
-    if (config.balanceLoading) {
+    if (balanceLoading) {
       return (
         <AtomicSpinner
           size="xl"
           color="primary"
-          text={config.translations.loading}
+          text={activeTranslations.loading}
           fullContainer
           style={styles.loadingContainer}
         />
@@ -92,8 +107,8 @@ export const WalletScreen: React.FC<WalletScreenProps> = ({ config }) => {
 
     return (
       <BalanceCard
-        balance={config.balance}
-        translations={config.translations}
+        balance={balance}
+        translations={activeTranslations}
         iconName={config.balanceIconName}
       />
     );
@@ -102,19 +117,18 @@ export const WalletScreen: React.FC<WalletScreenProps> = ({ config }) => {
   return (
     <ScreenLayout
       scrollable={true}
-      edges={["bottom"]}
+      edges={["top", "bottom"]}
       backgroundColor={tokens.colors.backgroundPrimary}
       contentContainerStyle={styles.content}
-      footer={config.footer}
+      footer={footer}
     >
       {renderHeader()}
       {renderBalance()}
       <TransactionList
-        transactions={config.transactions}
-        loading={config.transactionsLoading}
-        translations={config.translations}
-        maxHeight={config.maxTransactionHeight}
-        dateFormatter={config.dateFormatter}
+        transactions={transactions}
+        loading={transactionsLoading}
+        translations={activeTranslations}
+        dateFormatter={dateFormatter}
       />
     </ScreenLayout>
   );

package/src/index.ts

@@ -48,7 +48,7 @@ export {
   getCreditsRepository, 
   getCreditsConfig, 
   isCreditsRepositoryConfigured 
-} from "./domains/credits/infrastructure/CreditsRepositoryProvider";
+} from "./domains/credits/infrastructure/CreditsRepositoryManager";
 
 // Presentation Layer - Hooks (Point to the bridge)
 export * from "./presentation/hooks";

package/src/shared/application/ActivationHandler.ts

@@ -9,7 +9,7 @@ export interface ActivationHandlerConfig {
     userId: string,
     status: SubscriptionStatus
   ) => Promise<void> | void;
-  onError?: (error: Error, context: string) => Promise<void> | void;
+  onError?: (error: Error, operation: string) => Promise<void> | void;
 }
 
 /**
@@ -85,15 +85,15 @@ async function notifyStatusChange(
  * Safe error handler - wraps error callbacks to prevent secondary failures
  */
 export async function safeHandleError(
-  onError: ((error: Error, context: string) => Promise<void> | void) | undefined,
+  onError: ((error: Error, operation: string) => Promise<void> | void) | undefined,
   error: unknown,
-  context: string
+  operation: string
 ): Promise<void> {
   if (!onError) return;
 
   try {
     const err = error instanceof Error ? error : new Error("Unknown error");
-    await onError(err, context);
+    await onError(err, operation);
   } catch {
     // Ignore callback errors
   }
@@ -102,7 +102,7 @@ export async function safeHandleError(
 async function handleError(
   config: ActivationHandlerConfig,
   error: unknown,
-  context: string
+  operation: string
 ): Promise<void> {
-  await safeHandleError(config.onError, error, `ActivationHandler.${context}`);
+  await safeHandleError(config.onError, error, `ActivationHandler.${operation}`);
 }

package/src/shared/presentation/index.ts

@@ -0,0 +1 @@
+export * from "./layouts/ScreenLayout";

package/src/shared/presentation/layouts/ScreenLayout.tsx

@@ -0,0 +1,79 @@
+/**
+ * Screen Layout Component
+ * Centralized layout with safe area handling and consistent styling.
+ */
+import React from "react";
+import { StyleSheet, View, ScrollView, type ViewStyle, type ColorValue } from "react-native";
+import { useSafeAreaInsets, type Edge } from "react-native-safe-area-context";
+import { useAppDesignTokens } from "@umituz/react-native-design-system";
+
+export interface ScreenLayoutProps {
+  children: React.ReactNode;
+  scrollable?: boolean;
+  edges?: Edge[];
+  backgroundColor?: ColorValue;
+  contentContainerStyle?: ViewStyle;
+  footer?: React.ReactNode;
+}
+
+export const ScreenLayout: React.FC<ScreenLayoutProps> = ({
+  children,
+  scrollable = false,
+  edges = ["top", "bottom", "left", "right"],
+  backgroundColor,
+  contentContainerStyle,
+  footer,
+}) => {
+  const tokens = useAppDesignTokens();
+  const insets = useSafeAreaInsets();
+
+  const containerStyle = [
+    styles.container,
+    {
+      backgroundColor: backgroundColor ?? tokens.colors.backgroundPrimary,
+      paddingTop: edges.includes("top") ? insets.top : 0,
+      paddingBottom: edges.includes("bottom") ? insets.bottom : 0,
+      paddingLeft: edges.includes("left") ? insets.left : 0,
+      paddingRight: edges.includes("right") ? insets.right : 0,
+    },
+  ];
+
+  const content = (
+    <>
+      <View style={[styles.flex, contentContainerStyle]}>
+        {children}
+      </View>
+      {footer}
+    </>
+  );
+
+  if (scrollable) {
+    return (
+      <ScrollView
+        style={containerStyle}
+        contentContainerStyle={[styles.scrollContent]}
+        showsVerticalScrollIndicator={false}
+      >
+        {content}
+      </ScrollView>
+    );
+  }
+
+  return (
+    <View style={containerStyle}>
+      {content}
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  scrollContent: {
+    flexGrow: 1,
+  },
+  flex: {
+    flex: 1,
+  },
+});

package/src/shared/utils/Logger.ts

@@ -6,7 +6,7 @@
 
 export type LogLevel = "debug" | "info" | "warn" | "error";
 
-export interface LogContext {
+export interface LogMetadata {
   [key: string]: unknown;
 }
 
@@ -57,54 +57,54 @@ class SubscriptionLogger {
     return `[${category}] ${message}`;
   }
 
-  debug(category: LogCategory, message: string, context?: LogContext): void {
+  debug(category: LogCategory, message: string, metadata?: LogMetadata): void {
     if (!this.shouldLog(category)) return;
-    console.log(this.formatMessage(category, message), context ?? "");
+    console.log(this.formatMessage(category, message), metadata ?? "");
   }
 
-  info(category: LogCategory, message: string, context?: LogContext): void {
+  info(category: LogCategory, message: string, metadata?: LogMetadata): void {
     if (!this.shouldLog(category)) return;
-    console.log(this.formatMessage(category, message), context ?? "");
+    console.log(this.formatMessage(category, message), metadata ?? "");
   }
 
-  warn(category: LogCategory, message: string, context?: LogContext): void {
+  warn(category: LogCategory, message: string, metadata?: LogMetadata): void {
     if (!this.shouldLog(category)) return;
-    console.warn(this.formatMessage(category, message), context ?? "");
+    console.warn(this.formatMessage(category, message), metadata ?? "");
   }
 
-  error(category: LogCategory, message: string, error?: unknown, context?: LogContext): void {
+  error(category: LogCategory, message: string, error?: unknown, metadata?: LogMetadata): void {
     if (!this.shouldLog(category)) return;
-    console.error(this.formatMessage(category, message), { error, ...context });
+    console.error(this.formatMessage(category, message), { error, ...metadata });
   }
 
   /** Log purchase flow events */
-  purchase(message: string, context?: LogContext): void {
-    this.debug(LOG_CATEGORY.PURCHASE, message, context);
+  purchase(message: string, metadata?: LogMetadata): void {
+    this.debug(LOG_CATEGORY.PURCHASE, message, metadata);
   }
 
   /** Log credits-related events */
-  credits(message: string, context?: LogContext): void {
-    this.debug(LOG_CATEGORY.CREDITS, message, context);
+  credits(message: string, metadata?: LogMetadata): void {
+    this.debug(LOG_CATEGORY.CREDITS, message, metadata);
   }
 
   /** Log trial-related events */
-  trial(message: string, context?: LogContext): void {
-    this.debug(LOG_CATEGORY.TRIAL, message, context);
+  trial(message: string, metadata?: LogMetadata): void {
+    this.debug(LOG_CATEGORY.TRIAL, message, metadata);
   }
 
   /** Log RevenueCat SDK events */
-  revenueCat(message: string, context?: LogContext): void {
-    this.debug(LOG_CATEGORY.REVENUECAT, message, context);
+  revenueCat(message: string, metadata?: LogMetadata): void {
+    this.debug(LOG_CATEGORY.REVENUECAT, message, metadata);
   }
 
   /** Log feature gate events */
-  featureGate(message: string, context?: LogContext): void {
-    this.debug(LOG_CATEGORY.FEATURE_GATE, message, context);
+  featureGate(message: string, metadata?: LogMetadata): void {
+    this.debug(LOG_CATEGORY.FEATURE_GATE, message, metadata);
   }
 
   /** Log sync operations */
-  sync(message: string, context?: LogContext): void {
-    this.debug(LOG_CATEGORY.SYNC, message, context);
+  sync(message: string, metadata?: LogMetadata): void {
+    this.debug(LOG_CATEGORY.SYNC, message, metadata);
   }
 }
 

package/src/shared/utils/SubscriptionConfig.ts

@@ -11,5 +11,5 @@ export interface SubscriptionConfig {
     entitlements?: string[];
     debugMode?: boolean;
     onStatusChanged?: (userId: string, status: SubscriptionStatus) => Promise<void> | void;
-    onError?: (error: Error, context: string) => Promise<void> | void;
+    onError?: (error: Error, operation: string) => Promise<void> | void;
 }

package/src/utils/appUtils.ts

@@ -0,0 +1,34 @@
+/**
+ * App and Platform Utilities
+ */
+import { Platform } from "react-native";
+import Constants from "expo-constants";
+
+/**
+ * Gets the current app version from Expo constants
+ */
+export function getAppVersion(): string {
+  const version = Constants.expoConfig?.version ?? Constants.manifest2?.extra?.expoClient?.version;
+  if (!version) {
+    throw new Error("appVersion is required in expoConfig");
+  }
+  return version;
+}
+
+/**
+ * Validates if the current platform is supported
+ */
+export function validatePlatform(): "ios" | "android" {
+  const platform = Platform.OS;
+  if (platform !== "ios" && platform !== "android") {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+  return platform;
+}
+
+/**
+ * Checks if the app is currently in development mode
+ */
+export function isDev(): boolean {
+  return __DEV__;
+}

package/src/utils/dateUtils.ts

@@ -0,0 +1,32 @@
+/**
+ * Date Utilities
+ */
+
+/**
+ * Checks if a date is in the past
+ */
+export function isPast(date: Date | string | number): boolean {
+  const d = new Date(date);
+  return d.getTime() < Date.now();
+}
+
+/**
+ * Converts various timestamp formats to a safe Date object
+ */
+export function toSafeDate(ts: any): Date | null {
+  if (!ts) return null;
+  if (typeof ts.toDate === "function") return ts.toDate();
+  if (ts instanceof Date) return ts;
+  if (typeof ts === "string" || typeof ts === "number") {
+    const d = new Date(ts);
+    return isNaN(d.getTime()) ? null : d;
+  }
+  return null;
+}
+
+/**
+ * Formats a date to ISO string safely
+ */
+export function formatISO(date: Date | null): string | null {
+  return date ? date.toISOString() : null;
+}

package/src/utils/index.ts

@@ -7,3 +7,5 @@ export * from "./priceUtils";
 export * from "./tierUtils";
 export * from "./types";
 export * from "./validation";
+export * from "./dateUtils";
+export * from "./appUtils";

package/src/utils/packageTypeDetector.ts

@@ -54,7 +54,7 @@ export function detectPackageType(productIdentifier: string): SubscriptionPackag
       return PACKAGE_TYPE.LIFETIME;
   }
 
-  if (__DEV__ && productIdentifier !== 'unknown_product') {
+  if (__DEV__ && productIdentifier !== 'no_subscription') {
     console.warn("[PackageTypeDetector] Unknown package type for:", productIdentifier);
   }
 

package/src/domains/wallet/presentation/screens/WalletScreenContainer.tsx

@@ -1,88 +0,0 @@
-/**
- * Wallet Screen Container
- *
- * Self-contained wallet screen.
- * Uses global config from configureWallet() - no props needed!
- *
- * Usage:
- * 1. Call configureWallet() during app init
- * 2. Use WalletScreenContainer directly in navigation
- *
- * ```tsx
- * // In init
- * configureWallet({ translations: myTranslations });
- *
- * // In navigation
- * <Stack.Screen name="Wallet" component={WalletScreenContainer} />
- * ```
- */
-
-import React, { useMemo } from "react";
-import { useNavigation } from "@react-navigation/native";
-import { WalletScreen, type WalletScreenTranslations } from "./WalletScreen";
-import { useWallet } from "../hooks/useWallet";
-import { getWalletConfig } from "../../infrastructure/config/walletConfig";
-
-export interface WalletScreenContainerProps {
-  /** Translations (overrides global config) */
-  translations?: WalletScreenTranslations;
-  /** Override onBack handler (default: navigation.goBack) */
-  onBack?: () => void;
-  /** Custom date formatter */
-  dateFormatter?: (timestamp: number) => string;
-  /** Footer component */
-  footer?: React.ReactNode;
-}
-
-export const WalletScreenContainer: React.FC<WalletScreenContainerProps> = ({
-  translations,
-  onBack,
-  dateFormatter,
-  footer,
-}) => {
-  const navigation = useNavigation();
-  const config = getWalletConfig();
-
-  const {
-    balance,
-    balanceLoading,
-    transactions,
-    transactionsLoading,
-  } = useWallet({
-    transactionConfig: {
-      collectionName: config.transactionCollection,
-      useUserSubcollection: config.useUserSubcollection,
-    },
-    transactionLimit: config.transactionLimit,
-  });
-
-  const screenConfig = useMemo(
-    () => ({
-      balance,
-      balanceLoading,
-      transactions,
-      transactionsLoading,
-      translations: translations ?? config.translations,
-      onBack: onBack ?? (() => navigation.goBack()),
-      dateFormatter,
-      balanceIconName: config.balanceIconName,
-      footer,
-    }),
-    [
-      balance,
-      balanceLoading,
-      transactions,
-      transactionsLoading,
-      translations,
-      config,
-      onBack,
-      navigation,
-      dateFormatter,
-      footer,
-    ],
-  );
-
-  return <WalletScreen config={screenConfig} />;
-};
-
-export default WalletScreenContainer;