@finspringinnovations/fdsdk 0.0.1

package/src/types/env.d.ts

@@ -0,0 +1,93 @@
+declare module '@env' {
+    // Environment Configuration
+    export const REACT_APP_ENV: string;
+    export const NODE_ENV: string;
+
+    // API Configuration
+    export const REACT_APP_DEV_API_URL: string;
+    export const REACT_APP_STAGING_API_URL: string;
+    export const REACT_APP_PROD_API_URL: string;
+    export const SHRIRAM_DEV_API_KEY: string;
+    export const SHRIRAM_STAGING_API_KEY: string;
+    export const SHRIRAM_PROD_API_KEY: string;
+    export const SHRIRAM_API_TIMEOUT: string;
+    export const SHRIRAM_DEV_RETRY_ATTEMPTS: string;
+    export const SHRIRAM_STAGING_RETRY_ATTEMPTS: string;
+    export const SHRIRAM_PROD_RETRY_ATTEMPTS: string;
+
+    // Encryption Configuration
+    export const SHRIRAM_DEV_ENCRYPTION_KEY: string;
+    export const SHRIRAM_STAGING_ENCRYPTION_KEY: string;
+    export const SHRIRAM_ENCRYPTION_KEY: string;
+    export const REACT_APP_DEV_ENCRYPTION_KEY: string;
+    export const REACT_APP_STAGING_ENCRYPTION_KEY: string;
+    export const REACT_APP_ENCRYPTION_KEY: string;
+    export const DECRYPTION_TOKEN: string;
+
+    // SDK Configuration
+    export const SHRIRAM_SDK_VERSION: string;
+    export const SHRIRAM_CLIENT_VERSION: string;
+
+    // Financial Limits Configuration
+    export const SHRIRAM_MIN_DEPOSIT: string;
+    export const SHRIRAM_MAX_DEPOSIT: string;
+    export const SHRIRAM_MIN_TENURE: string;
+    export const SHRIRAM_DEPOSIT_MULTIPLE: string;
+    export const SHRIRAM_DEFAULT_INTEREST_RATE: string;
+
+    // UI Configuration
+    export const SHRIRAM_HEADER_HEIGHT: string;
+    export const SHRIRAM_CHECKBOX_SIZE: string;
+    export const SHRIRAM_STATUS_BAR_COLOR: string;
+    export const SHRIRAM_STATUS_BAR_STYLE: string;
+
+    // Security Configuration
+    export const SHRIRAM_ENABLE_ENCRYPTION_DEV: string;
+    export const SHRIRAM_ENABLE_ENCRYPTION_STAGING: string;
+    export const SHRIRAM_ENABLE_ENCRYPTION_PROD: string;
+    export const SHRIRAM_ALLOW_ENCRYPTION_TOGGLE_DEV: string;
+    export const SHRIRAM_ALLOW_ENCRYPTION_TOGGLE_STAGING: string;
+    export const SHRIRAM_ALLOW_ENCRYPTION_TOGGLE_PROD: string;
+    export const SHRIRAM_ENABLE_LOGGING_DEV: string;
+    export const SHRIRAM_ENABLE_LOGGING_STAGING: string;
+    export const SHRIRAM_ENABLE_LOGGING_PROD: string;
+
+    // Payment Configuration
+    export const SHRIRAM_PAYMENT_SUCCESS_URL: string;
+    export const SHRIRAM_PAYMENT_FAILURE_URL: string;
+    export const SHRIRAM_PAYMENT_STATUS_URL: string;
+
+    // Development Configuration
+    export const SHRIRAM_DEBUG_MODE: string;
+    export const SHRIRAM_VERBOSE_LOGGING: string;
+    export const SHRIRAM_ENABLE_HOT_RELOAD: string;
+
+    // Feature Flags
+    export const SHRIRAM_ENABLE_FD_CALCULATOR: string;
+    export const SHRIRAM_ENABLE_PAYMENT_GATEWAY: string;
+    export const SHRIRAM_ENABLE_KYC_VERIFICATION: string;
+    export const SHRIRAM_ENABLE_AADHAAR_VERIFICATION: string;
+
+    // Validation Configuration
+    export const SHRIRAM_PHONE_NUMBER_LENGTH: string;
+    export const SHRIRAM_PAN_NUMBER_LENGTH: string;
+    export const SHRIRAM_AADHAAR_NUMBER_LENGTH: string;
+
+    // Theme Configuration
+    export const SHRIRAM_DEFAULT_THEME: string;
+    export const SHRIRAM_PRIMARY_COLOR: string;
+    export const SHRIRAM_SECONDARY_COLOR: string;
+    export const SHRIRAM_SUCCESS_COLOR: string;
+    export const SHRIRAM_ERROR_COLOR: string;
+    export const SHRIRAM_WARNING_COLOR: string;
+
+    // Monitoring Configuration
+    export const SHRIRAM_PERFORMANCE_MONITORING: string;
+    export const SHRIRAM_ERROR_TRACKING: string;
+    export const SHRIRAM_ANALYTICS_TRACKING: string;
+
+    // Compliance Configuration
+    export const SHRIRAM_GDPR_COMPLIANCE: string;
+    export const SHRIRAM_DATA_RETENTION_DAYS: string;
+    export const SHRIRAM_AUDIT_LOGGING: string;
+}

package/src/types/workflowTypes.ts

@@ -0,0 +1,12 @@
+import { WORKFLOW_STATES } from '../config/workflowConstants';
+
+export type WorkflowStateSriram =
+    | typeof WORKFLOW_STATES.START
+    | typeof WORKFLOW_STATES.INITIATION
+    | typeof WORKFLOW_STATES.CREATE_FD
+    | typeof WORKFLOW_STATES.OCCUPATION
+    | typeof WORKFLOW_STATES.NOMINEE
+    | typeof WORKFLOW_STATES.BANK_DETAILS
+    | typeof WORKFLOW_STATES.KYC
+    | typeof WORKFLOW_STATES.PAYMENT
+    | typeof WORKFLOW_STATES.END;

package/src/utils/apiLogger.ts

@@ -0,0 +1,166 @@
+// API Logging Utility for Shriram SDK
+// Provides comprehensive logging for API requests, responses, and debugging
+
+export interface LogConfig {
+    enableLogging: boolean;
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    logRequest: boolean;
+    logResponse: boolean;
+    logHeaders: boolean;
+    logBody: boolean;
+    logTiming: boolean;
+    maxBodyLength: number;
+}
+
+export interface RequestLogData {
+    method: string;
+    url: string;
+    baseUrl: string;
+    headers: Record<string, string>;
+    body?: any;
+    timestamp: number;
+    requestId: string;
+    isEncrypted: boolean;
+}
+
+export interface ResponseLogData {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    data?: any;
+    timestamp: number;
+    requestId: string;
+    duration: number;
+    isEncrypted: boolean;
+    error?: any;
+}
+
+// Default logging configuration
+const DEFAULT_LOG_CONFIG: LogConfig = {
+    enableLogging: true,
+    logLevel: 'info',
+    logRequest: true,
+    logResponse: true,
+    logHeaders: true,
+    logBody: true,
+    logTiming: true,
+    maxBodyLength: 1000,
+};
+
+class ApiLogger {
+    private config: LogConfig;
+    private requestStartTimes: Map<string, number> = new Map();
+
+    constructor(config: Partial<LogConfig> = {}) {
+        this.config = { ...DEFAULT_LOG_CONFIG, ...config };
+    }
+
+    // Update logging configuration
+    updateConfig(newConfig: Partial<LogConfig>): void {
+        this.config = { ...this.config, ...newConfig };
+    }
+
+    // Log API request
+    logRequest(data: RequestLogData): void {
+        if (!this.config.enableLogging || !this.config.logRequest) {
+            return;
+        }
+
+        const { method, url, baseUrl, headers, body, timestamp, requestId, isEncrypted } = data;
+
+        // Store start time for duration calculation
+        this.requestStartTimes.set(requestId, timestamp);
+
+        // API request logging removed for security
+    }
+
+    // Log API response
+    logResponse(data: ResponseLogData): void {
+        if (!this.config.enableLogging || !this.config.logResponse) {
+            return;
+        }
+
+        const { status, statusText, headers, data: responseData, timestamp, requestId, duration, isEncrypted, error } = data;
+
+        // Remove start time
+        this.requestStartTimes.delete(requestId);
+
+        const isSuccess = status >= 200 && status < 300;
+        const logMethod = isSuccess ? 'log' : 'error';
+
+        // API response logging removed for security
+    }
+
+    // Log API error
+    logError(error: any, requestId: string, url: string): void {
+        if (!this.config.enableLogging) {
+            return;
+        }
+
+        const startTime = this.requestStartTimes.get(requestId);
+        const duration = startTime ? Date.now() - startTime : 0;
+
+        // Remove start time
+        this.requestStartTimes.delete(requestId);
+
+        // API error logging removed for security
+    }
+
+    // Calculate request duration
+    getRequestDuration(requestId: string): number {
+        const startTime = this.requestStartTimes.get(requestId);
+        return startTime ? Date.now() - startTime : 0;
+    }
+
+    // Sanitize headers for logging (remove sensitive data)
+    private sanitizeHeaders(headers: Record<string, string>): Record<string, string> {
+        const sensitiveHeaders = ['authorization', 'x-api-key', 'x-auth-token', 'cookie'];
+        const sanitized = { ...headers };
+
+        sensitiveHeaders.forEach(header => {
+            if (sanitized[header]) {
+                sanitized[header] = '***REDACTED***';
+            }
+        });
+
+        return sanitized;
+    }
+
+    // Sanitize body for logging (truncate if too long)
+    private sanitizeBody(body: any): any {
+        if (!body) return body;
+
+        try {
+            const bodyStr = typeof body === 'string' ? body : JSON.stringify(body, null, 2);
+
+            if (bodyStr.length > this.config.maxBodyLength) {
+                return bodyStr.substring(0, this.config.maxBodyLength) + '... [TRUNCATED]';
+            }
+
+            return typeof body === 'string' ? JSON.parse(bodyStr) : body;
+        } catch {
+            return '[UNPARSEABLE BODY]';
+        }
+    }
+
+    // Log configuration summary
+    logConfig(): void {
+        if (!this.config.enableLogging) {
+            return;
+        }
+
+        // Configuration logging removed for security
+    }
+
+    // Clear all stored request times
+    clearRequestTimes(): void {
+        this.requestStartTimes.clear();
+    }
+}
+
+// Create singleton instance
+export const apiLogger = new ApiLogger();
+
+// Export types and utilities
+export { ApiLogger };
+export default apiLogger;

package/src/utils/encryption.ts

@@ -0,0 +1,159 @@
+// encryption.ts
+import { Buffer } from 'buffer';
+
+// Polyfill for react-native-quick-crypto
+const g = global as any;
+if (typeof g.Buffer === 'undefined') {
+    g.Buffer = Buffer;
+}
+
+if (typeof g.base64FromArrayBuffer === 'undefined') {
+    g.base64FromArrayBuffer = (data: ArrayBuffer) => {
+        return Buffer.from(data).toString('base64');
+    };
+}
+
+const crypto = require('react-native-quick-crypto');
+
+export default class CryptoUtils {
+    private static readonly SALT_LEN = 16;
+    private static readonly IV_LEN = 12;
+    private static readonly AUTH_TAG_LEN = 16;
+    private static readonly ITERATIONS = 100000;
+    private static readonly KEY_LEN = 32;
+    private static readonly MAX_CACHE = 10;
+
+    private static keyCache = new Map<string, Buffer>();
+
+    static async encryptJSONCompact(
+        json: Record<string, any>,
+        password: string,
+    ): Promise<string> {
+        try {
+            const jsonString = JSON.stringify(json);
+            const plaintext = Buffer.from(jsonString, 'utf8');
+
+            const salt = this.generateSalt();
+            const iv = this.generateIV();
+            const key = this.deriveKey(password, salt);
+
+            const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+            const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+            const authTag = cipher.getAuthTag();
+
+            const packed = Buffer.concat([salt, iv, authTag, encrypted]);
+            return packed.toString('base64');
+        } catch (e) {
+            throw e;
+        }
+    }
+
+    static async decryptJSONCompact(
+        compactBase64: string,
+        password: string,
+    ): Promise<Record<string, any>> {
+        try {
+            const all = Buffer.from(compactBase64, 'base64');
+
+            if (all.length < this.SALT_LEN + this.IV_LEN + this.AUTH_TAG_LEN) {
+                throw new Error('Invalid compact payload');
+            }
+
+            const salt = all.slice(0, this.SALT_LEN);
+            const iv = all.slice(this.SALT_LEN, this.SALT_LEN + this.IV_LEN);
+            const authTag = all.slice(
+                this.SALT_LEN + this.IV_LEN,
+                this.SALT_LEN + this.IV_LEN + this.AUTH_TAG_LEN,
+            );
+            const cipherBytes = all.slice(this.SALT_LEN + this.IV_LEN + this.AUTH_TAG_LEN);
+
+            const key = this.deriveKey(password, salt);
+
+            const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+            decipher.setAuthTag(authTag);
+
+            const decrypted = Buffer.concat([
+                decipher.update(cipherBytes),
+                decipher.final(),
+            ]);
+
+            const jsonString = decrypted.toString('utf8');
+            return JSON.parse(jsonString);
+        } catch (e) {
+            throw e;
+        }
+    }
+
+    private static deriveKey(password: string, salt: Buffer): Buffer {
+        const cacheKey = `${password}_${salt.toString('base64')}`;
+
+        const cached = this.keyCache.get(cacheKey);
+        if (cached) return cached;
+
+        const key = crypto.pbkdf2Sync(
+            password,
+            salt,
+            this.ITERATIONS,
+            this.KEY_LEN,
+            'sha256',
+        );
+
+        if (this.keyCache.size >= this.MAX_CACHE) this.keyCache.clear();
+        this.keyCache.set(cacheKey, key);
+
+        return key;
+    }
+
+    private static generateSalt(): Buffer {
+        return crypto.randomBytes(this.SALT_LEN);
+    }
+
+    private static generateIV(): Buffer {
+        return crypto.randomBytes(this.IV_LEN);
+    }
+
+    static async encrypt(
+        data: Record<string, any>,
+        passphrase: string,
+    ): Promise<string> {
+        return this.encryptJSONCompact(data, passphrase);
+    }
+
+    static async decrypt(
+        encryptedBase64: string,
+        passphrase: string,
+    ): Promise<string> {
+        const result = await this.decryptJSONCompact(encryptedBase64, passphrase);
+        return JSON.stringify(result);
+    }
+}
+
+// Legacy named exports for backward compatibility
+export const ENCRYPTION_KEY = '60913a3b628a29ac9fdd2147e69d013135ce8be5b26d2ee5ec5e905838fcfa78';
+
+export interface EncryptionConfig {
+    secretKey: string;
+    algorithm?: string;
+    ivLength?: number;
+}
+
+export const encryptJSONCompact = (data: Record<string, any>, password: string = ENCRYPTION_KEY) =>
+    CryptoUtils.encryptJSONCompact(data, password);
+
+export const decryptJSONCompact = (compactBase64: string, password: string = ENCRYPTION_KEY) =>
+    CryptoUtils.decryptJSONCompact(compactBase64, password);
+
+export const encryptRequest = async (payload: any, config?: EncryptionConfig) => ({
+    encryptedRequest: await CryptoUtils.encryptJSONCompact(payload, config?.secretKey || ENCRYPTION_KEY),
+});
+
+export const decryptResponse = async (response: any, config?: EncryptionConfig) => {
+    if (response?.encryptedResponse) {
+        try {
+            return await CryptoUtils.decryptJSONCompact(response.encryptedResponse, config?.secretKey || ENCRYPTION_KEY);
+        } catch (error) {
+            return response;
+        }
+    }
+    return response;
+};

package/src/utils/getFDData.ts

@@ -0,0 +1,175 @@
+/**
+ * Get FD Data Utility
+ * 
+ * This function can be called from the main app to retrieve currently booked FD details
+ * by calling the customer webhook applications API with completed status filter.
+ */
+
+import { getUserInfoForAPI } from '../config/appDataConfig';
+import { store } from '../store';
+import { customerApi } from '../api/customerApi';
+
+/**
+ * Response structure returned to main app
+ */
+export interface FDDataResponse {
+
+    // All applications from API
+    allApplications: any[];
+    // Currently booked FD (matched by applicationId or most recent)
+    success: boolean;
+    // Error message if any
+    error?: string
+}
+
+/**
+ * Get FD data by calling customer webhook applications API and return response to main app
+ * Only returns applications with wfStatus='Completed'
+ * 
+ * @param userReferenceId - User reference ID from main app. If not provided, will try to get from SDK's internal state.
+ * @param applicationId - Optional application ID to find specific FD. If not provided, returns most recent FD.
+ * @returns Promise that resolves to FDDataResponse containing completed applications only
+ * 
+ * @example
+ * ```typescript
+ * import { getFDData } from '@finspringinnovations/shriramsdk';
+ * 
+ * // Get FD data with user reference ID from main app
+ * const result = await getFDData('USER123');
+ * if (result.success) {
+ *   // Access full API response
+ *   const apiResponse = result.apiResponse;
+ *   const allApplications = result.allApplications;
+ *   const bookedFD = result.bookedFD;
+ *   const fdAmount = result.bookedFD?.amount;
+ *   const applicationId = result.bookedFD?.applicationId;
+ * } else {
+ *   // Handle error
+ *   const errorMessage = result.error;
+ * }
+ * 
+ * // Get specific FD by application ID
+ * const specificFD = await getFDData('USER123', 'APP123456');
+ * 
+ * // Without userReferenceId (will use SDK's internal state)
+ * const resultWithoutUserRef = await getFDData();
+ * ```
+ */
+export const getFDData = async (userReferenceId?: string, applicationId?: string): Promise<FDDataResponse> => {
+    try {
+        // Get user reference ID - use provided parameter or fallback to SDK's internal state
+        let finalUserReferenceId: string;
+
+        if (userReferenceId) {
+            // Use userReferenceId provided by main app
+            finalUserReferenceId = userReferenceId;
+        } else {
+            // Fallback to getting from SDK's internal state
+            try {
+                const userInfo = getUserInfoForAPI();
+                finalUserReferenceId = userInfo.id;
+            } catch (error) {
+                return {
+                    allApplications: [],
+                    success: false,
+                    error: 'User reference ID is required. Please provide userReferenceId parameter or initialize SDK first.',
+                };
+            }
+        }
+
+        // ✅ CRITICAL: Use SDK store directly to ensure we always use SDK's store
+        // This prevents conflicts with parent app's store
+        if (!store) {
+            return {
+                allApplications: [],
+                success: false,
+                error: 'SDK store is not initialized. Please ensure SDK is properly set up.',
+            };
+        }
+
+        // Call webhook API to get customer applications with completed status
+        const apiResponse = await store.dispatch(
+            customerApi.endpoints.getCustomerWebhookApplications.initiate({
+                userReferenceId: finalUserReferenceId,
+                wfStatus: 'Completed'
+            })
+        ).unwrap();
+
+        // Extract applications from response (handle different response structures)
+        // Note: API already filters by wfStatus='Completed'
+        let applications: any[] = [];
+        if (Array.isArray(apiResponse)) {
+            applications = apiResponse;
+        } else if (apiResponse?.data && Array.isArray(apiResponse.data)) {
+            applications = apiResponse.data;
+        } else if (apiResponse?.applications && Array.isArray(apiResponse.applications)) {
+            applications = apiResponse.applications;
+        }
+
+        // Map to only include specified fields
+        applications = applications.map((app: any) => ({
+            application_id: app?.application_id || app?.applicationId,
+            investment_amount: app?.investment_amount || app?.investmentAmount,
+            interest_rate: app?.interest_rate || app?.interestRate,
+            maturity_date: app?.maturity_date || app?.maturityDate,
+            maturity_amount: app?.maturity_amount || app?.maturityAmount,
+            interest_payout_term: app?.interest_payout_term || app?.interestPayoutTerm,
+            tenure_in_months: app?.tenure_in_months || app?.tenureInMonths,
+            transaction_id: app?.transaction_id || app?.transactionId,
+            fd_provider_id: app?.fd_provider_id || app?.fdProviderId,
+            fd_provider_name: app?.fd_provider_name || app?.fdProviderName,
+            transaction_status: app?.transaction_status || app?.transactionStatus,
+            transaction_description: app?.transaction_description || app?.transactionDescription,
+            wf_status: app?.wf_status || app?.wfStatus,
+            created_date: app?.created_date || app?.createdDate,
+            certificate_status: app?.certificate_status || app?.certificateStatus,
+        }));
+
+        // Find the FD - match by applicationId or get the most recent one
+        let bookedFD: any = null;
+
+        if (applicationId) {
+            // Try to find FD matching the provided applicationId
+            bookedFD = applications.find((app: any) =>
+                app?.application_id === applicationId
+            );
+        } else {
+            // Get applicationId from Redux store if available
+            const state = store.getState() as any;
+            const storeApplicationId = state?.onboarding?.applicationId;
+
+            if (storeApplicationId) {
+                // Try to find FD matching the current applicationId from store
+                bookedFD = applications.find((app: any) =>
+                    app?.application_id === storeApplicationId
+                );
+            }
+        }
+
+        // If not found by applicationId, get the most recent one (assuming it's the latest booking)
+        if (!bookedFD && applications.length > 0) {
+            // Sort by date if available, otherwise take the last one
+            const sortedApps = [...applications].sort((a: any, b: any) => {
+                const dateA = a?.created_date || 0;
+                const dateB = b?.created_date || 0;
+                return new Date(dateB).getTime() - new Date(dateA).getTime();
+            });
+            bookedFD = sortedApps[0];
+        }
+
+        // Return full API response data to main app
+        return {
+            // Full API response
+            allApplications: applications,  // All applications array
+            success: true,
+        };
+    } catch (error: any) {
+        // If API call fails, return error information
+        return {
+            allApplications: [],
+            success: false,
+            error: error?.message || 'Failed to fetch FD data',
+        };
+    }
+};
+

package/src/utils/globalData.ts

@@ -0,0 +1,7 @@
+let globalData: any = {};
+
+export const setGlobalData = (data: any) => {
+    globalData = { ...globalData, ...data };
+};
+
+export const getGlobalData = () => globalData;