banking_dcb_sdk_react_native 0.1.9

package/src/helpers/banking_dcb_react_native.tsx

@@ -0,0 +1,413 @@
+import { APICall } from './network/APICall';
+import { DeviceInfoManager } from './utils/deviceInfoManager';
+import { LibraryConstants } from './utils/LibraryConstants';
+import { type WebViewCallbackFunction } from './utils/webviewCallback';
+import { ServiceNames } from './ServiceNames';
+import { Constants } from './utils/Constants';
+import { WebView } from './webview';
+import { SafeAreaView } from 'react-native-safe-area-context';
+import { StatusBar } from 'react-native';
+export type { WebViewCallbackFunction } from './utils/webviewCallback';
+import { AnalyticsLogger } from './analytics/analytics_logger';
+import * as base64js from 'base64-js';
+
+type InitOptions = {
+  whitelistedDomains: string[];
+  deviceBindingEnabled: boolean;
+};
+
+// Extend the global type to include base64FromArrayBuffer
+declare global {
+  var base64FromArrayBuffer: ((arrayBuffer: ArrayBuffer) => string) | undefined;
+}
+type JSONMap = Record<string, any>;
+
+export class BankingDcbReactNative {
+  private static instance: BankingDcbReactNative | null = null;
+  private static intialized = false;
+
+  private _apiCall = new APICall();
+  static webViewCallback: WebViewCallbackFunction;
+  private _analyticsLogger!: AnalyticsLogger;
+  private constructor() {}
+
+  static getInstance(): BankingDcbReactNative {
+    if (!BankingDcbReactNative.instance) {
+      BankingDcbReactNative.instance = new BankingDcbReactNative();
+    }
+    return BankingDcbReactNative.instance;
+  }
+
+  static async init(
+    hostName: string,
+    options: InitOptions = {
+      whitelistedDomains: [],
+      deviceBindingEnabled: false,
+    }
+  ): Promise<void> {
+    //   console.log("PartnerLibrary.init - initialized:", PartnerLibrary.intialized);
+    if (BankingDcbReactNative.intialized) return;
+
+    try {
+      if (!global.base64FromArrayBuffer) {
+        global.base64FromArrayBuffer = (arrayBuffer: ArrayBuffer) => {
+          return base64js.fromByteArray(new Uint8Array(arrayBuffer));
+        };
+      }
+
+      // Ensure instance exists before setup
+      if (!BankingDcbReactNative.instance) {
+        //     console.log("PartnerLibrary.init - creating new instance");
+        BankingDcbReactNative.instance = new BankingDcbReactNative();
+      }
+      await BankingDcbReactNative.instance._setup(
+        hostName,
+        options.whitelistedDomains,
+        options.deviceBindingEnabled
+      );
+      BankingDcbReactNative.intialized = true;
+    } catch (error) {
+      console.error('Initialization failed: ', error);
+      throw new Error('Initialization failed');
+    }
+  }
+
+  private async _setup(
+    hostName: string,
+    whitelistedDomains: string[],
+    deviceBindingEnabled: boolean
+  ): Promise<void> {
+    LibraryConstants.init({
+      host: hostName,
+      whitelistedDomains: whitelistedDomains,
+      deviceBinding: deviceBindingEnabled,
+    });
+    this._analyticsLogger = new AnalyticsLogger();
+    // this._analyticsLogger.logEvent({ event: 'REACT_NATIVE_INTIALIZED' });
+  }
+
+  async open(
+    module: string,
+    token: string,
+    WebViewCallbackFunction: WebViewCallbackFunction
+  ): Promise<React.ReactElement> {
+    // this._analyticsLogger.logEvent({ event: 'REACT_NATIVE_OPEN_FN_CALLED' });
+
+    if (!BankingDcbReactNative.intialized) {
+      throw new Error('PartnerLibrary not initialized. Call init() first.');
+    }
+    try {
+      let bank = '';
+
+      if (module.includes('banking/')) {
+        const startIndex = module.indexOf('banking/') + 'banking/'.length;
+        const temp = module.substring(startIndex);
+        const endIndex = temp.indexOf('/');
+        bank = endIndex === -1 ? temp : temp.substring(0, endIndex);
+      }
+
+      return this._loginAndNavigateToWebView(
+        module,
+        bank,
+        token,
+        WebViewCallbackFunction
+      );
+    } catch (e) {
+      console.error('Error opening webview:', e);
+      throw e;
+    }
+  }
+
+  private async _checkDeviceBinding(
+    bank: string,
+    url: string,
+    WebViewCallbackFunction: WebViewCallbackFunction
+  ): Promise<React.ReactElement> {
+    // this._analyticsLogger.logEvent({
+    //   event: 'REACT_NATIVE_DEVICE_BINDING_CALLED',
+    // });
+
+    console.log('SDK:LOG: entered in check device binding');
+    if (LibraryConstants.deviceBindingEnabled) {
+      // TODO: Build the device binding flow
+      return Promise.resolve(<></>);
+    } else {
+      console.log('SDK:LOG: calling setup device session');
+
+      return this._setupDeviceSession(bank, url, WebViewCallbackFunction);
+    }
+  }
+
+  private async _loginAndNavigateToWebView(
+    module: string,
+    bank: string,
+    token: string,
+    WebViewCallbackFunction: WebViewCallbackFunction
+  ): Promise<React.ReactElement> {
+    // console.log("PartnerLibrary._loginAndNavigateToWebView - LibraryConstants.hostName:", LibraryConstants.hostName);
+    try {
+      // this._analyticsLogger.logEvent({ event: 'REACT_NATIVE_LOGIN_FN_CALLED' });
+      let tokenResponse: any;
+      const url = ServiceNames.LOGIN_URL;
+      console.log('SDK:LOG: ', url);
+      console.log('SDK:LOG: Token is : ', token);
+      tokenResponse = await this._apiCall.callAPI(
+        'POST',
+        ServiceNames.LOGIN_URL,
+        {
+          body: {
+            token: token,
+          },
+        }
+      );
+      console.log('SDK:LOG Token response is : ', tokenResponse);
+      // this._analyticsLogger.logEvent({
+      //   event: 'REACT_NATIVE_LOGIN_FN_RESPONSE :',
+      //   response: tokenResponse,
+      // });
+
+      if (tokenResponse?.data?.code === 'USER_TOKEN_EXPIRED') {
+        console.log('SDK:LOG Token expired');
+        return Promise.resolve(<></>);
+      }
+
+      if (
+        tokenResponse &&
+        tokenResponse.data &&
+        typeof tokenResponse.data === 'object' &&
+        tokenResponse.data !== null &&
+        'RATE_LIMIT_USER' in tokenResponse.data
+      ) {
+        console.log('SDK:LOG: rate limit user');
+      }
+
+      // console.log("Checking login success condition:", {
+      //     statusCode: tokenResponse?.statusCode,
+      //     code: tokenResponse?.data?.code
+      // });
+
+      if (tokenResponse?.data?.code === 'USER_LOGIN_SUCCESS') {
+        console.log('SDK:LOG: User login success');
+        this.fetchAndSetTheme();
+        return this._checkDeviceBinding(bank, module, WebViewCallbackFunction);
+      } else {
+        console.log(
+          'SDK:LOG: Login not successful. Token Response:',
+          tokenResponse
+        );
+        return Promise.resolve(<></>);
+      }
+    } catch (e) {
+      console.error('SDK:LOG: Error during login:', e);
+      throw e;
+    }
+  }
+
+  private async _setupDeviceSession(
+    bank: string,
+    url: string,
+    WebViewCallbackFunction: WebViewCallbackFunction
+  ): Promise<React.ReactElement> {
+    try {
+      console.log('SDK:LOG: in setup device session');
+
+      const deviceInfo = await DeviceInfoManager.getDeviceInfo();
+      const appVersion = deviceInfo['app_version'] || 'unknown';
+
+      if (__DEV__) {
+        console.log('Device Info:', deviceInfo);
+        console.log('App Version:', appVersion);
+      }
+      console.log('SDK:LOG device uuid is  ');
+
+      const response = await this._apiCall.callAPI(
+        'POST',
+        ServiceNames.DEVICE_SESSION.params({ partner: bank }),
+        {
+          body: {
+            [Constants.MANUFACTURER]: deviceInfo[Constants.MANUFACTURER],
+            [Constants.MODEL]: deviceInfo[Constants.MODEL],
+            [Constants.DEVICE_UUID]: deviceInfo[Constants.DEVICE_UUID],
+            [Constants.OS]: deviceInfo[Constants.OS],
+            [Constants.OS_VERSION]: deviceInfo[Constants.OS_VERSION],
+            [Constants.APP_VERSION]: appVersion,
+          },
+        }
+      );
+      //console.log("response from setup device session is : ", response)
+      if (
+        response &&
+        response.data &&
+        typeof response.data === 'object' &&
+        response.data !== null &&
+        'RATE_LIMIT_USER' in response.data
+      ) {
+        console.log('SDK:LOG: rate limit user');
+      }
+
+      if (response?.status === 200) {
+        return this._openWebView(url, WebViewCallbackFunction);
+      } else {
+        console.warn('SDK:LOG: Error setting up device session:', response);
+        return this._openWebView(url, WebViewCallbackFunction);
+      }
+    } catch (e) {
+      console.error('SDK:LOG: Error setting up device session:', e);
+      throw e;
+    }
+  }
+
+  async _openWebView(
+    url: string,
+    WebViewCallbackFunction: WebViewCallbackFunction
+  ): Promise<React.ReactElement> {
+    console.log('SDK:LOG: entered in open web view');
+    console.log('SDK:LOG: url is : ', LibraryConstants.hostName + url);
+    // this._analyticsLogger.logEvent({
+    //   event: 'REACT_NATIVE_WEBVIEW_OPEN_CALLED',
+    // });
+
+    return (
+      <SafeAreaView style={{ flex: 1 }}>
+        <WebView
+          url={LibraryConstants.hostName + url}
+          onCallback={WebViewCallbackFunction}
+          whitelistedUrls={LibraryConstants.whitelistedDomains}
+          hostName={LibraryConstants.hostName}
+          onPageFinished={() =>
+            console.log('SDK:LOG: WebView page finished loading')
+          }
+        />
+      </SafeAreaView>
+    );
+  }
+
+  async fetchAndSetTheme(): Promise<void> {
+    try {
+      console.log('SDK:LOG: Fetching theme from API');
+
+      const themeResponse: any = await this._apiCall.callAPI(
+        'GET',
+        ServiceNames.THEME_URL
+      );
+      const theme = themeResponse?.data;
+      console.log('SDK:LOG: Theme response:', theme);
+
+      if (theme && theme['--color-primary-500']) {
+        const rgbValues = theme['--color-primary-500'].split(' ').map(Number);
+        if (rgbValues.length === 3) {
+          const [r, g, b] = rgbValues;
+
+          // Update LibraryConstants color
+          LibraryConstants.setPrimaryColorFromRGB(r, g, b);
+
+          // Set status bar color
+
+          StatusBar.setBackgroundColor(LibraryConstants.primaryColor);
+          StatusBar.setBarStyle('light-content');
+
+          console.log(
+            'SDK:LOG: Theme color set successfully:',
+            LibraryConstants.primaryColor
+          );
+        } else {
+          console.warn('Invalid RGB values in theme response');
+        }
+      } else {
+        console.warn('--color-primary-500 not found in theme response');
+      }
+    } catch (e) {
+      console.error('Error Fetching theme: ', e);
+      throw e;
+    }
+  }
+  async publicapi(
+    method: string,
+    apiUrl: string,
+    options?: {
+      body?: Record<string, any>;
+      headers?: Record<string, any>;
+    }
+  ): Promise<any> {
+    return this._apiCall.callAPI(method, apiUrl, options);
+  }
+
+  public async sdkLogin(token: string, partner: string): Promise<JSONMap> {
+    try {
+      // 1) LOGIN
+      console.log('SDK:LOG: ', ServiceNames.LOGIN_URL);
+      console.log('SDK:LOG: Token is: ', token);
+
+      const loginResp = await this._apiCall.callAPI(
+        'POST',
+        ServiceNames.LOGIN_URL,
+        {
+          body: { token },
+        }
+      );
+
+      // Normalize to a JSON object
+      const loginData: JSONMap =
+        loginResp?.data && typeof loginResp.data === 'object'
+          ? { ...loginResp.data }
+          : {};
+
+      const isSuccess =
+        loginResp?.status === 200 && loginData?.code === 'USER_LOGIN_SUCCESS';
+
+      if (!isSuccess) {
+        // Not a successful login → return login JSON as-is
+        return loginData;
+      }
+
+      // 2) DEVICE SESSION
+      try {
+        console.log('SDK:LOG: in device-session');
+
+        const deviceInfo = await DeviceInfoManager.getDeviceInfo();
+        const appVersion = deviceInfo['app_version'] || 'unknown';
+
+        if (__DEV__) {
+          console.log('Device Info:', deviceInfo);
+          console.log('App Version:', appVersion);
+        }
+
+        const deviceResp = await this._apiCall.callAPI(
+          'POST',
+          ServiceNames.DEVICE_SESSION.params({ partner }),
+          {
+            body: {
+              [Constants.MANUFACTURER]: deviceInfo[Constants.MANUFACTURER],
+              [Constants.MODEL]: deviceInfo[Constants.MODEL],
+              [Constants.DEVICE_UUID]: deviceInfo[Constants.DEVICE_UUID],
+              [Constants.OS]: deviceInfo[Constants.OS], // "Android"/"iOS" from your manager
+              [Constants.OS_VERSION]: deviceInfo[Constants.OS_VERSION],
+              [Constants.APP_VERSION]: appVersion,
+            },
+          }
+        );
+
+        // Nest device-session response into the same login JSON
+        loginData.device =
+          deviceResp?.data && typeof deviceResp.data === 'object'
+            ? deviceResp.data
+            : { success: false, message: 'device session null' };
+
+        return loginData;
+      } catch (err: any) {
+        // Keep shape stable if device session fails
+        loginData.device = {
+          success: false,
+          message: String(err?.message || err),
+        };
+        return loginData;
+      }
+    } catch (err: any) {
+      // Absolute fallback: minimal error shape
+      return {
+        success: false,
+        message: `sdkLogin failed: ${String(err?.message || err)}`,
+      };
+    }
+  }
+}

package/src/helpers/helper.tsx

@@ -0,0 +1 @@
+console.log("Helper file loaded");

package/src/helpers/network/APICall.tsx

@@ -0,0 +1,154 @@
+import NetworkManager from './network_manager';
+import { HeaderManager } from '../utils/headerManager';
+
+import {
+  generateAESKey,
+  exportAESKeyBase64,
+  encryptAESKeyWithRSA,
+  encryptAES,
+  decryptAES,
+  getWebsiteKey,
+} from './Encryption';
+
+export class APICall {
+  private networkManager: NetworkManager = new NetworkManager();
+  private headerManager: HeaderManager = new HeaderManager();
+
+  async callAPI(
+    method: string,
+    apiUrl: string,
+    options?: {
+      body?: Record<string, any>;
+      headers?: Record<string, any>;
+      encrypted?: boolean;
+    }
+  ): Promise<any> {
+    const { body, headers, encrypted = true } = options || {};
+    try {
+      const response = encrypted
+        ? await this._callAPIEncrypt(method, apiUrl, body, headers)
+        : await this._callAPIRaw(method, apiUrl, body, headers);
+
+      return response;
+    } catch (error) {
+      console.log('Error in callAPI:', error);
+      throw error;
+    }
+  }
+
+  private async _callAPIRaw(
+    method: string,
+    apiUrl: string,
+    body?: Record<string, any>,
+    headers?: Record<string, any>
+  ): Promise<any> {
+    const mergedHeaders = {
+      ...(await this.headerManager.generateHeaders()),
+      ...(headers || {}),
+    };
+
+    return this.networkManager.request({
+      url: apiUrl,
+      method: method,
+      body: body,
+      headers: mergedHeaders,
+    });
+  }
+  // ----------------- ENCRYPTED CALL (quick-crypto) -----------------
+  private async _callAPIEncrypt(
+    method: string,
+    apiUrl: string,
+    body?: Record<string, any>,
+    headers?: Record<string, any>
+  ): Promise<any> {
+    // 1) Generate ephemeral AES-256 key (Uint8Array)
+    const aesKey = generateAESKey(); // Uint8Array (32 bytes)
+
+    // 2) Export AES key bytes -> Base64 (for RSA input)
+    const aesKeyBase64 = exportAESKeyBase64(aesKey); // string
+
+    // 3) Fetch server public key (cached) and RSA-wrap the AES key
+    const websiteKey = await getWebsiteKey(); // { kid, public, expiry }
+    const rsaEncryptedKey = encryptAESKeyWithRSA(
+      aesKeyBase64,
+      websiteKey.public
+    ); // string
+
+    // 4) Encrypt payload with AES-GCM -> Base64(IV||CT||TAG)
+    const encryptedPayload = encryptAES(JSON.stringify(body ?? {}), aesKey); // string
+
+    // 5) Merge headers (stringify all values)
+    const baseHeaders = await this.headerManager.generateHeaders();
+    const mergedHeaders: Record<string, string> = {
+      ...Object.fromEntries(
+        Object.entries(baseHeaders).map(([k, v]) => [k, String(v)])
+      ),
+      ...(headers
+        ? Object.fromEntries(
+            Object.entries(headers).map(([k, v]) => [k, String(v)])
+          )
+        : {}),
+    };
+
+    // 6) Add encryption headers
+    const encryptedHeaders: Record<string, string> = {
+      'Content-Type': 'application/json;charset=utf-8',
+      'Accept': 'application/json',
+      ...mergedHeaders,
+      'encryption_kid': websiteKey.kid ?? '',
+      'key': rsaEncryptedKey ?? '',
+    };
+
+    // 7) Make the encrypted request with { encrypted: "<blob>" }
+    const response = await this.networkManager.request({
+      url: apiUrl,
+      method,
+      body: { encrypted: encryptedPayload },
+      headers: encryptedHeaders,
+    });
+
+    // 8) Decrypt response if it has { encrypted }
+    const decrypted = APICall.handleDecryptedResponse(response, aesKey);
+    if (decrypted != null) {
+      response!.data = decrypted;
+    }
+    return response;
+  }
+
+  // ----------------- RESPONSE DECRYPT (quick-crypto) -----------------
+  static handleDecryptedResponse(
+    response: any,
+    aesKey: Uint8Array
+  ): Record<string, any> | null {
+    try {
+      if (!response) return null;
+
+      const raw = response.data;
+      // Accept string or object
+      const data: Record<string, any> =
+        typeof raw === 'string' ? JSON.parse(raw) : (raw as any);
+
+      if (!data || typeof data !== 'object' || !('encrypted' in data)) {
+        // no encrypted field, return null to signal "not decrypted"
+        return null;
+      }
+
+      const encryptedPayload = String(data.encrypted ?? '');
+      if (!encryptedPayload) return null;
+
+      const decryptedJson = decryptAES(encryptedPayload, aesKey); // sync
+
+      try {
+        const obj = JSON.parse(decryptedJson);
+        return obj && typeof obj === 'object'
+          ? (obj as Record<string, any>)
+          : null;
+      } catch {
+        // decrypted payload wasn't valid JSON
+        return null;
+      }
+    } catch {
+      return null;
+    }
+  }
+}