@finos_sdk/sdk-ekyc 1.2.2 → 1.2.8

package/src/modules/FinosEKYCModule.ts

@@ -6,6 +6,8 @@ import { C06Config } from '../types/ekycC06Type';
 import { OcrConfig } from '../types/ekycOCRType';
 import { LivenessConfig } from '../types/ekycLivenessType';
 import { FaceServiceConfig } from '../types/ekycFaceType';
+import { SmsOtpConfig, SmsOtpResult, SmsOtpError } from '../types/ekycSmsOtpType';
+import { UserEsignModel, ESignInitResult, ESignOpenSessionResult, ESignCertificate, ESignSignRequest, ESignError, ESignAuthenticateResult } from '../types/ekycESignType';
 
 /**
  * Finos eKYC SDK Module
@@ -330,6 +332,400 @@ export class FinosEKYCModule {
         console.log('🧹 All event listeners removed');
     }
 
+    // ==================== SMS OTP Methods ====================
+
+    /**
+     * Send SMS OTP
+     * @param config SMS OTP configuration
+     */
+    public async sendOtp(config: SmsOtpConfig): Promise<SmsOtpResult> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('📱 Sending SMS OTP...');
+            const result = await this.sdk.sendOtp(config);
+            console.log('✅ SMS OTP sent successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ SMS OTP send failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Verify SMS OTP
+     * @param config SMS OTP configuration (must include requestId)
+     * @param otpCode OTP code from SMS
+     */
+    public async verifyOtp(config: SmsOtpConfig, otpCode: string): Promise<SmsOtpResult> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('🔐 Verifying SMS OTP...');
+            const result = await this.sdk.verifyOtp(config, otpCode);
+            console.log('✅ SMS OTP verified successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ SMS OTP verification failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Resend SMS OTP
+     * @param config SMS OTP configuration (must include requestId)
+     */
+    public async resendOtp(config: SmsOtpConfig): Promise<SmsOtpResult> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('📱 Resending SMS OTP...');
+            const result = await this.sdk.resendOtp(config);
+            console.log('✅ SMS OTP resent successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ SMS OTP resend failed:', error);
+            throw error;
+        }
+    }
+
+    // SMS OTP Event Listeners
+    public onSmsOtpSendSuccess(callback: (data: SmsOtpResult) => void) {
+        const listener = this.sdk.onSmsOtpSendSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpSendSuccess: Event emitter not ready. Make sure SDK is initialized.');
+        }
+        return listener;
+    }
+
+    public onSmsOtpVerifySuccess(callback: (data: SmsOtpResult) => void) {
+        const listener = this.sdk.onSmsOtpVerifySuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpVerifySuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onSmsOtpResendSuccess(callback: (data: SmsOtpResult) => void) {
+        const listener = this.sdk.onSmsOtpResendSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpResendSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    public onSmsOtpError(callback: (error: SmsOtpError) => void) {
+        const listener = this.sdk.onSmsOtpError(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpError: Event emitter not ready.');
+        }
+        return listener;
+    }
+
+    // ==================== eSign Methods ====================
+
+    /**
+     * Initialize eSign SDK
+     */
+    public async initializeESign(): Promise<ESignInitResult> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('🔐 Initializing eSign SDK...');
+            const result = await this.sdk.initializeESign();
+            console.log('✅ eSign SDK initialized successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ eSign initialization failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Open eSign session
+     * @param accessToken JWT access token (optional if using userEsignModel)
+     * @param username Optional username
+     * @param rememberMe Remember session
+     * @param userEsignModel User info for auto token creation (optional if using accessToken)
+     * @param privateKeyFilePath Path to private key file in assets (required if using userEsignModel)
+     */
+    public async openSessionId(
+        accessToken?: string,
+        username?: string,
+        rememberMe?: boolean,
+        userEsignModel?: UserEsignModel,
+        privateKeyFilePath?: string
+    ): Promise<ESignOpenSessionResult> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('🔓 Opening eSign session...');
+            const result = await this.sdk.openSessionId(
+                accessToken,
+                username,
+                rememberMe,
+                userEsignModel,
+                privateKeyFilePath
+            );
+            console.log('✅ eSign session opened successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ eSign session open failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Register device for eSign
+     * @param recoverCode 8-digit recovery code
+     * @param pinCode 6-digit PIN code
+     * @param fcmToken Optional FCM token
+     */
+    public async registerDevice(
+        recoverCode: string,
+        pinCode: string,
+        fcmToken?: string
+    ): Promise<{ code: string; message: string }> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('📱 Registering eSign device...');
+            const result = await this.sdk.registerDevice(recoverCode, pinCode, fcmToken);
+            console.log('✅ eSign device registered successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ eSign device registration failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * List eSign certificates
+     * @param pageNumber Page number (default: 1)
+     * @param pageSize Page size (default: 10)
+     */
+    public async listCerts(
+        pageNumber: number = 1,
+        pageSize: number = 10
+    ): Promise<{ certs: ESignCertificate[] }> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('📋 Listing eSign certificates...');
+            const result = await this.sdk.listCerts(pageNumber, pageSize);
+            console.log(`✅ Found ${result.certs.length} certificates`);
+            return result;
+        } catch (error) {
+            console.error('❌ eSign list certificates failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Verify eSign certificate
+     * @param serial Certificate serial number
+     */
+    public async verifyCert(serial: string): Promise<{ code: string; message: string }> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('✅ Verifying eSign certificate...');
+            const result = await this.sdk.verifyCert(serial);
+            console.log('✅ eSign certificate verified successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ eSign certificate verification failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * List eSign sign requests
+     * @param pageNumber Page number (default: 1)
+     * @param pageSize Page size (default: 10)
+     */
+    public async listSignRequest(
+        pageNumber: number = 1,
+        pageSize: number = 10
+    ): Promise<{ requests: ESignSignRequest[] }> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('📋 Listing eSign sign requests...');
+            const result = await this.sdk.listSignRequest(pageNumber, pageSize);
+            console.log(`✅ Found ${result.requests.length} sign requests`);
+            return result;
+        } catch (error) {
+            console.error('❌ eSign list sign requests failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Confirm eSign signature
+     * @param signRequestId Sign request ID
+     * @param pinCode 6-digit PIN code
+     * @param authId Optional auth ID
+     * @param authData Optional auth data
+     * @param confirm Confirm the signature (default: true)
+     */
+    public async confirmSign(
+        signRequestId: string,
+        pinCode: string,
+        authId?: string,
+        authData?: string,
+        confirm: boolean = true
+    ): Promise<{ code: string; message: string }> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('✍️ Confirming eSign signature...');
+            const result = await this.sdk.confirmSign(signRequestId, pinCode, authId, authData, confirm);
+            console.log('✅ eSign signature confirmed successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ eSign signature confirmation failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Authenticate with eSign
+     * @param username eSign username
+     * @param password eSign password
+     */
+    public async authenticate(
+        username: string,
+        password: string
+    ): Promise<ESignAuthenticateResult> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('🔐 Authenticating with eSign...');
+            const result = await this.sdk.authenticate(username, password);
+            console.log('✅ eSign authentication successful');
+            return result;
+        } catch (error) {
+            console.error('❌ eSign authentication failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Register remote signing certificate
+     * @param accessToken JWT access token
+     * @param requestJson JSON request body
+     */
+    public async registerRemoteSigning(
+        accessToken: string,
+        requestJson: string
+    ): Promise<{ response: string }> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('📝 Registering remote signing certificate...');
+            const result = await this.sdk.registerRemoteSigning(accessToken, requestJson);
+            console.log('✅ Remote signing certificate registered successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ Remote signing certificate registration failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Sign PDF document
+     * @param accessToken JWT access token
+     * @param requestJson JSON request body
+     */
+    public async signPdf(
+        accessToken: string,
+        requestJson: string
+    ): Promise<{ response: string }> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('📄 Signing PDF document...');
+            const result = await this.sdk.signPdf(accessToken, requestJson);
+            console.log('✅ PDF document signed successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ PDF document signing failed:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Send confirmation document
+     * @param accessToken JWT access token
+     * @param requestJson JSON string containing request data
+     */
+    public async sendConfirmationDocument(
+        accessToken: string,
+        requestJson: string
+    ): Promise<{ response: string }> {
+        this.validateSDKReady();
+        
+        try {
+            console.log('📧 Sending confirmation document...');
+            const result = await this.sdk.sendConfirmationDocument(accessToken, requestJson);
+            console.log('✅ Confirmation document sent successfully');
+            return result;
+        } catch (error) {
+            console.error('❌ Confirmation document sending failed:', error);
+            throw error;
+        }
+    }
+
+    // eSign Event Listeners
+    public onESignInitSuccess(callback: (data: ESignInitResult) => void) {
+        return this.sdk.onESignInitSuccess(callback);
+    }
+
+    public onESignOpenSessionSuccess(callback: (data: ESignOpenSessionResult) => void) {
+        return this.sdk.onESignOpenSessionSuccess(callback);
+    }
+
+    public onESignRegisterDeviceSuccess(callback: (data: { code: string; message: string }) => void) {
+        return this.sdk.onESignRegisterDeviceSuccess(callback);
+    }
+
+    public onESignListCertsSuccess(callback: (data: { certs: ESignCertificate[] }) => void) {
+        return this.sdk.onESignListCertsSuccess(callback);
+    }
+
+    public onESignVerifyCertSuccess(callback: (data: { code: string; message: string }) => void) {
+        return this.sdk.onESignVerifyCertSuccess(callback);
+    }
+
+    public onESignListSignRequestSuccess(callback: (data: { requests: ESignSignRequest[] }) => void) {
+        return this.sdk.onESignListSignRequestSuccess(callback);
+    }
+
+    public onESignConfirmSignSuccess(callback: (data: { code: string; message: string }) => void) {
+        return this.sdk.onESignConfirmSignSuccess(callback);
+    }
+
+    public onESignAuthenticateSuccess(callback: (data: ESignAuthenticateResult) => void) {
+        return this.sdk.onESignAuthenticateSuccess(callback);
+    }
+
+    public onESignRegisterRemoteSigningSuccess(callback: (data: { response: string }) => void) {
+        return this.sdk.onESignRegisterRemoteSigningSuccess(callback);
+    }
+
+    public onESignSignPdfSuccess(callback: (data: { response: string }) => void) {
+        return this.sdk.onESignSignPdfSuccess(callback);
+    }
+
+    public onESignSendConfirmationDocumentSuccess(callback: (data: { response: string }) => void) {
+        return this.sdk.onESignSendConfirmationDocumentSuccess(callback);
+    }
+
+    public onESignError(callback: (error: ESignError) => void) {
+        return this.sdk.onESignError(callback);
+    }
+
     /**
      * Start eKYC UI with flow (like MainActivity.kt)
      * @param appKey Main app key
@@ -439,8 +835,162 @@ export class FinosEKYCModule {
     }
 }
 
-// Export singleton instance
-export const FinosEKYC = FinosEKYCModule.getInstance();
+// Export singleton instance - ensure it's always initialized
+let _finosEKYCInstance: FinosEKYCModule | null = null;
+
+const getFinosEKYCInstance = (): FinosEKYCModule => {
+    if (!_finosEKYCInstance) {
+        try {
+            _finosEKYCInstance = FinosEKYCModule.getInstance();
+        } catch (error) {
+            console.error('Failed to initialize FinosEKYCModule:', error);
+            throw new Error('FinosEKYCModule initialization failed. Please check native module setup.');
+        }
+    }
+    return _finosEKYCInstance;
+};
+
+// Initialize immediately
+try {
+    _finosEKYCInstance = FinosEKYCModule.getInstance();
+} catch (error) {
+    // Silent initialization - will be created on first access
+}
+
+// Helper to check if a property is a method on FinosEKYCModule
+const isMethod = (prop: string | symbol): boolean => {
+    if (typeof prop !== 'string') return false;
+    // Check if it's a known method from the class
+    const prototype = FinosEKYCModule.prototype as any;
+    return typeof prototype[prop] === 'function' || 
+           prop.startsWith('on') || 
+           prop === 'initialize' || 
+           prop === 'startEkycUI' ||
+           prop === 'startNfcScan' ||
+           prop === 'checkC06' ||
+           prop === 'startOcr' ||
+           prop === 'startLiveness' ||
+           prop === 'startFaceCompare';
+};
+
+// Create a comprehensive stub object with all methods to prevent undefined errors
+const createFinosEKYCStub = (): FinosEKYCModule => {
+    const stub = {} as any;
+    
+    // Add all event listener methods (on* methods)
+    const eventListenerMethods = [
+        'onNfcScanStart', 'onNfcScanSuccess', 'onNfcError',
+        'onC06Success', 'onC06Error',
+        'onOCRSuccess', 'onOCRError',
+        'onLivenessSuccess', 'onLivenessError',
+        'onFaceCompareSuccess', 'onFaceCompareError',
+        'onSmsOtpSendSuccess', 'onSmsOtpVerifySuccess', 'onSmsOtpResendSuccess', 'onSmsOtpError',
+        'onESignInitSuccess', 'onESignOpenSessionSuccess', 'onESignRegisterDeviceSuccess',
+        'onESignListCertsSuccess', 'onESignVerifyCertSuccess', 'onESignListSignRequestSuccess',
+        'onESignConfirmSignSuccess', 'onESignAuthenticateSuccess', 'onESignRegisterRemoteSigningSuccess',
+        'onESignSignPdfSuccess', 'onESignSendConfirmationDocumentSuccess', 'onESignError'
+    ];
+    
+    eventListenerMethods.forEach(method => {
+        stub[method] = (callback?: any) => {
+            console.warn(`⚠️ FinosEKYC.${method} called but module is not initialized`);
+            return null;
+        };
+    });
+    
+    // Add all other methods
+    const otherMethods = [
+        'initialize', 'startNfcScan', 'checkC06', 'startOCR', 'startLiveness', 'startFaceCompare',
+        'startEkycUI', 'sendOtp', 'verifyOtp', 'resendOtp', 'initializeESign', 'openSessionId',
+        'registerDevice', 'listCerts', 'verifyCert', 'listSignRequest', 'confirmSign',
+        'authenticate', 'registerRemoteSigning', 'signPdf', 'sendConfirmationDocument',
+        'onResume', 'onPause', 'isSDKReady', 'getSDKInfo'
+    ];
+    
+    otherMethods.forEach(method => {
+        stub[method] = async (...args: any[]) => {
+            console.warn(`⚠️ FinosEKYC.${method} called but module is not initialized`);
+            throw new Error(`FinosEKYC.${method} is not available. Module may not be initialized.`);
+        };
+    });
+    
+    return stub as FinosEKYCModule;
+};
+
+// Create a safe wrapper using Proxy - ensure it's always an object
+const createFinosEKYCProxy = (): FinosEKYCModule => {
+    try {
+        return new Proxy({} as FinosEKYCModule, {
+            get(_target, prop) {
+                try {
+                    const instance = getFinosEKYCInstance();
+                    const value = (instance as any)[prop];
+                    if (typeof value === 'function') {
+                        return value.bind(instance);
+                    }
+                    return value;
+                } catch (error) {
+                    console.warn(`⚠️ FinosEKYC.${String(prop)} is not available:`, error);
+                    // Always return a function for methods to prevent "undefined" errors
+                    if (isMethod(prop)) {
+                        // For event listeners (on* methods), return a function that returns null
+                        if (typeof prop === 'string' && prop.startsWith('on')) {
+                            return (callback?: any) => {
+                                console.warn(`⚠️ FinosEKYC.${prop} called but module is not initialized`);
+                                return null;
+                            };
+                        }
+                        // For other methods, return a no-op async function
+                        return async (...args: any[]) => {
+                            console.warn(`⚠️ FinosEKYC.${String(prop)} called but module is not initialized`);
+                            throw new Error(`FinosEKYC.${String(prop)} is not available. Module may not be initialized.`);
+                        };
+                    }
+                    return undefined;
+                }
+            }
+        });
+    } catch (error) {
+        console.error('❌ Failed to create FinosEKYC proxy:', error);
+        // Return a comprehensive stub object
+        return createFinosEKYCStub();
+    }
+};
+
+// Create a wrapper that always returns a valid object
+// This ensures FinosEKYC is NEVER undefined and always has all methods
+const createFinosEKYCWrapper = (): FinosEKYCModule => {
+    // Always start with stub to ensure all methods exist
+    const stub = createFinosEKYCStub();
+    const wrapper = { ...stub } as any;
+    
+    // Try to get real instance and override methods
+    try {
+        const realInstance = getFinosEKYCInstance();
+        
+        // Override with real instance methods
+        Object.getOwnPropertyNames(Object.getPrototypeOf(realInstance)).forEach(key => {
+            if (key !== 'constructor' && typeof (realInstance as any)[key] === 'function') {
+                wrapper[key] = ((realInstance as any)[key]).bind(realInstance);
+            }
+        });
+        
+        // Also copy any own properties from real instance
+        Object.keys(realInstance).forEach(key => {
+            if ((realInstance as any)[key] !== undefined) {
+                wrapper[key] = (realInstance as any)[key];
+            }
+        });
+    } catch (error) {
+        // If we can't get instance, wrapper already has all stub methods
+        // No need to do anything
+    }
+    
+    return wrapper as FinosEKYCModule;
+};
+
+// Export - this ensures FinosEKYC is never undefined
+export const FinosEKYC = createFinosEKYCWrapper();
 
 // Export types
 export type { NfcConfig, NfcError } from '../types/ekycNFCType';
@@ -449,6 +999,8 @@ export type { OcrConfig } from '../types/ekycOCRType';
 export type { LivenessConfig } from '../types/ekycLivenessType';
 export type { FaceServiceConfig } from '../types/ekycFaceType';
 export type { SDKEkycResultWithEvent, SDKEkycResultStringWithEvent } from '../types/ekycType';
+export type { SmsOtpConfig, SmsOtpResult, SmsOtpError } from '../types/ekycSmsOtpType';
+export type { UserEsignModel, ESignInitResult, ESignOpenSessionResult, ESignCertificate, ESignSignRequest, ESignError, ESignAuthenticateResult } from '../types/ekycESignType';
 
 // Export constants
 export { SDK_VERSION, SDK_NAME };