@finos_sdk/sdk-ekyc 1.2.2 → 1.2.9

package/dist/src/modules/FinosEKYCModule.js

@@ -109,6 +109,23 @@ class FinosEKYCModule {
     isSDKReady() {
         return this.isInitialized && this.sdk.isSDKInitialized();
     }
+    /**
+     * Set transaction ID
+     * @param transactionId Transaction ID string
+     */
+    async setTransactionId(transactionId) {
+        this.validateSDKReady();
+        try {
+            console.log('🆔 Setting transaction ID:', transactionId);
+            const result = await this.sdk.setTransactionId(transactionId);
+            console.log('✅ Transaction ID set successfully');
+            return result;
+        }
+        catch (error) {
+            console.error('❌ Failed to set transaction ID:', error);
+            throw error;
+        }
+    }
     /**
      * Start NFC scanning for Vietnamese CCCD
      * @param config NFC configuration
@@ -310,6 +327,328 @@ class FinosEKYCModule {
         this.sdk.removeAllListeners();
         console.log('🧹 All event listeners removed');
     }
+    // ==================== SMS OTP Methods ====================
+    /**
+     * Send SMS OTP
+     * @param config SMS OTP configuration
+     */
+    async sendOtp(config) {
+        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
+     */
+    async verifyOtp(config, otpCode) {
+        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)
+     */
+    async resendOtp(config) {
+        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
+    onSmsOtpSendSuccess(callback) {
+        const listener = this.sdk.onSmsOtpSendSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpSendSuccess: Event emitter not ready. Make sure SDK is initialized.');
+        }
+        return listener;
+    }
+    onSmsOtpVerifySuccess(callback) {
+        const listener = this.sdk.onSmsOtpVerifySuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpVerifySuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onSmsOtpResendSuccess(callback) {
+        const listener = this.sdk.onSmsOtpResendSuccess(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpResendSuccess: Event emitter not ready.');
+        }
+        return listener;
+    }
+    onSmsOtpError(callback) {
+        const listener = this.sdk.onSmsOtpError(callback);
+        if (!listener) {
+            console.warn('⚠️ onSmsOtpError: Event emitter not ready.');
+        }
+        return listener;
+    }
+    // ==================== eSign Methods ====================
+    /**
+     * Initialize eSign SDK
+     */
+    async initializeESign() {
+        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)
+     */
+    async openSessionId(accessToken, username, rememberMe, userEsignModel, privateKeyFilePath) {
+        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
+     */
+    async registerDevice(recoverCode, pinCode, fcmToken) {
+        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)
+     */
+    async listCerts(pageNumber = 1, pageSize = 10) {
+        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
+     */
+    async verifyCert(serial) {
+        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)
+     */
+    async listSignRequest(pageNumber = 1, pageSize = 10) {
+        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)
+     */
+    async confirmSign(signRequestId, pinCode, authId, authData, confirm = true) {
+        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
+     */
+    async authenticate(username, password) {
+        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
+     */
+    async registerRemoteSigning(accessToken, requestJson) {
+        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
+     */
+    async signPdf(accessToken, requestJson) {
+        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
+     */
+    async sendConfirmationDocument(accessToken, requestJson) {
+        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
+    onESignInitSuccess(callback) {
+        return this.sdk.onESignInitSuccess(callback);
+    }
+    onESignOpenSessionSuccess(callback) {
+        return this.sdk.onESignOpenSessionSuccess(callback);
+    }
+    onESignRegisterDeviceSuccess(callback) {
+        return this.sdk.onESignRegisterDeviceSuccess(callback);
+    }
+    onESignListCertsSuccess(callback) {
+        return this.sdk.onESignListCertsSuccess(callback);
+    }
+    onESignVerifyCertSuccess(callback) {
+        return this.sdk.onESignVerifyCertSuccess(callback);
+    }
+    onESignListSignRequestSuccess(callback) {
+        return this.sdk.onESignListSignRequestSuccess(callback);
+    }
+    onESignConfirmSignSuccess(callback) {
+        return this.sdk.onESignConfirmSignSuccess(callback);
+    }
+    onESignAuthenticateSuccess(callback) {
+        return this.sdk.onESignAuthenticateSuccess(callback);
+    }
+    onESignRegisterRemoteSigningSuccess(callback) {
+        return this.sdk.onESignRegisterRemoteSigningSuccess(callback);
+    }
+    onESignSignPdfSuccess(callback) {
+        return this.sdk.onESignSignPdfSuccess(callback);
+    }
+    onESignSendConfirmationDocumentSuccess(callback) {
+        return this.sdk.onESignSendConfirmationDocumentSuccess(callback);
+    }
+    onESignError(callback) {
+        return this.sdk.onESignError(callback);
+    }
     /**
      * Start eKYC UI with flow (like MainActivity.kt)
      * @param appKey Main app key
@@ -352,7 +691,151 @@ class FinosEKYCModule {
     }
 }
 exports.FinosEKYCModule = FinosEKYCModule;
-// Export singleton instance
-exports.FinosEKYC = FinosEKYCModule.getInstance();
+// Export singleton instance - ensure it's always initialized
+let _finosEKYCInstance = null;
+const getFinosEKYCInstance = () => {
+    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) => {
+    if (typeof prop !== 'string')
+        return false;
+    // Check if it's a known method from the class
+    const prototype = FinosEKYCModule.prototype;
+    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 = () => {
+    const stub = {};
+    // 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) => {
+            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) => {
+            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;
+};
+// Create a safe wrapper using Proxy - ensure it's always an object
+const createFinosEKYCProxy = () => {
+    try {
+        return new Proxy({}, {
+            get(_target, prop) {
+                try {
+                    const instance = getFinosEKYCInstance();
+                    const value = instance[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) => {
+                                console.warn(`⚠️ FinosEKYC.${prop} called but module is not initialized`);
+                                return null;
+                            };
+                        }
+                        // For other methods, return a no-op async function
+                        return async (...args) => {
+                            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 = () => {
+    // Always start with stub to ensure all methods exist
+    const stub = createFinosEKYCStub();
+    const wrapper = Object.assign({}, stub);
+    // 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[key] === 'function') {
+                wrapper[key] = (realInstance[key]).bind(realInstance);
+            }
+        });
+        // Also copy any own properties from real instance
+        Object.keys(realInstance).forEach(key => {
+            if (realInstance[key] !== undefined) {
+                wrapper[key] = realInstance[key];
+            }
+        });
+    }
+    catch (error) {
+        // If we can't get instance, wrapper already has all stub methods
+        // No need to do anything
+    }
+    return wrapper;
+};
+// Export - this ensures FinosEKYC is never undefined
+exports.FinosEKYC = createFinosEKYCWrapper();
 // Default export
 exports.default = exports.FinosEKYC;