react-native-unit-components 1.9.1 → 1.10.0

package/src/helpers/pushProvisioningService/hooks/useCardWallet.ts

@@ -1,10 +1,14 @@
-import { useEffect, useState } from 'react';
+import { useEffect, useState, useRef } from 'react';
 import { UNWalletCode, type UNWallet, UNWalletName } from '../../../types/shared/wallet.types';
 import { UnitSDK } from '../../../unitSdkManager/UnitSdkManager';
 import { getMobileWalletPayload } from '../../../networking/requests/UNWalletPayloadRequest';
-import { useSelector } from 'react-redux';
-import { selectWallet } from '../../../slices/pushProvisioningSlice';
+import { useSelector, useDispatch } from 'react-redux';
+import { selectWallet, setSignedNonce } from '../../../slices/pushProvisioningSlice';
 import { useLaunchInitialize } from './useLaunchInitialize';
+import { UNVPErrorType } from '../types';
+import { promiseRejectToUNVPErrorType } from '../helpers';
+import { UNErrorCodes, UNErrorData } from '../../../types/shared/error.types';
+import { isUNError } from '../../../types/internal/errorHelpers';
 
 export type CardToEncryptedPayload = {
   [cardId: string]: string;
@@ -14,13 +18,19 @@ export const useCardWallet = (cardId: string) => {
   const [currentUNWallet, setCurrentUNWallet] = useState<UNWallet>();
   const { signedNonce } = useSelector(selectWallet);
   const { initializePushProvisioning } = useLaunchInitialize();
+  const dispatch = useDispatch();
+  const isRecoveringSignedNonceRef = useRef<boolean>(false);
+
+  const shouldRecoverVPSDKForError = (errorType: UNVPErrorType) => {
+    const recoveringTypes = [UNVPErrorType.PayloadDecryptionFailed, UNVPErrorType.SessionExpired, UNVPErrorType.InvalidNonce];
+    return recoveringTypes.includes(errorType);
+  };
 
   useEffect(() => {
     const getEncryptedPayload = async () => {
       const env = UnitSDK.getEnv();
       const customerToken = UnitSDK.getCustomerToken();
       if (!env || !customerToken) return;
-
       // In case we use flow
       if (!signedNonce) {
         await initializePushProvisioning();
@@ -37,13 +47,32 @@ export const useCardWallet = (cardId: string) => {
         const encryptedPayload = await getEncryptedPayload();
         if (!encryptedPayload) return;
         const walletsResponse = await currentProvisioningModule.launchGetWallets(JSON.stringify({ encPayload: encryptedPayload }));
-
         const unWallet: UNWallet | null = parseWalletsResponse(walletsResponse);
         if (!unWallet) return;
         setCurrentUNWallet(unWallet);
         return;
       } catch (error) {
-        return Promise.reject(error);
+        console.error('Coudln\'t get card wallet data:', error);
+        if (isRecoveringSignedNonceRef.current) return;
+        isRecoveringSignedNonceRef.current = true;
+
+        // handle unit network api errors
+        if (isUNError(error)) {
+          const errors: UNErrorData[] = error.errors;
+          // errors will return in an array but hold only a single error element
+          if (errors[0]?.code === UNErrorCodes.INVALID_NONCE) {
+            dispatch(setSignedNonce(null));
+          }
+          return;
+        }
+
+        // handle VDE SDK errors
+        const errorType = promiseRejectToUNVPErrorType(error);
+        if (!errorType) return;
+        if (shouldRecoverVPSDKForError(errorType)) {
+          dispatch(setSignedNonce(null));
+          return;
+        }
       }
     };
 

package/src/helpers/pushProvisioningService/types.ts

@@ -0,0 +1,52 @@
+export enum UNVPErrorType {
+  EmptyAppId = 'EmptyAppId',
+  DeviceAuthenticationFailed = 'DeviceAuthenticationFailed',
+  DeviceRootDetection = 'DeviceRootDetection',
+  HookDetection = 'HookDetection',
+  PlayIntegrityCheckFailed = 'PlayIntegrityCheckFailed',
+  EmptyEncryptedPayload = 'EmptyEncryptedPayload',
+  NoWallets = 'NoWallets',
+  InvalidCardId = 'InvalidCardId',
+  ProvisioningNotAllowed = 'ProvisioningNotAllowed',
+  CancelledByUser = 'CancelledByUser',
+  GoogleWalletCreationFailed = 'GoogleWalletCreationFailed',
+  UnknownErrorOccurred = 'UnknownErrorOccurred',
+  WalletProvisioningInconclusive = 'WalletProvisioningInconclusive',
+  WalletProvisioningError = 'WalletProvisioningError',
+  NetworkFailure = 'NetworkFailure',
+  SessionExpired = 'SessionExpired',
+  InvalidInfo = 'InvalidInfo',
+  PayloadDecryptionFailed = 'PayloadDecryptionFailed',
+  ApiError = 'ApiError',
+  InvalidNonce = 'InvalidNonce',
+  SDKLockout = 'SDKLockout',
+  NoBrowserFound = 'NoBrowserFound',
+  TLCMFeatureNotSupported = 'TLCMFeatureNotSupported',
+  TLCMUnsupportedWallet = 'TLCMUnsupportedWallet',
+  TLCMDetailsNotFoundInPaySdk = 'TLCMDetailsNotFoundInPaySdk',
+  TLCMTokenStatusExists = 'TLCMTokenStatusExists',
+  TLCMInvalidOperationInput = 'TLCMInvalidOperationInput',
+  TLCMInvalidRequest = 'TLCMInvalidRequest',
+  TLCMUpdateStatusNotAllowed = 'TLCMUpdateStatusNotAllowed',
+  TLCMTokenNotFound = 'TLCMTokenNotFound',
+}
+
+export interface UNVPError {
+  code: string;
+  description: string;
+  type: UNVPErrorType;
+  correlationId: string;
+}
+
+export type UNNativePromiseReject = {
+  code: string;
+  message: string;
+}
+
+export interface UNMobileWalletPayload {
+  data: {
+    attributes: {
+      payload: string;
+    };
+  };
+}

package/src/hooks/useListenerToEvent.ts

@@ -0,0 +1,32 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { useEffect, useRef } from 'react';
+import { useSelector } from 'react-redux';
+import type { RootState } from '../store';
+import type { NativeMessageType } from '../messages/nativeMessages';
+import type { WebViewMessageType } from '../messages/webMessages';
+
+export type BusEventKey = NativeMessageType | WebViewMessageType
+
+type EventListener = {
+  busEventKey: BusEventKey,
+  action: (data: any) => void
+}
+
+export const useListenerToEvent = (listener: EventListener) => {
+  const isFirstRun = useRef(true);
+  const event = useSelector((state: RootState) => state.sharedEvents.event);
+  useEffect(() => {
+    if (isFirstRun.current) {
+      isFirstRun.current = false;
+      return;
+    }
+
+    if (event == null || event == undefined || event?.key != listener.busEventKey) {
+      return;
+    }
+
+    listener.action(event.data);
+
+  }, [event]);
+};

package/src/messages/webMessages/index.ts

@@ -8,10 +8,12 @@ import type { UnitEvent, UnitMessage } from './unitMessages';
 import type { AccountEvent, AccountMessage } from './accountMessage';
 import type { CheckEvent, CheckMessage } from './checkMessage';
 import type { ActivityEvent, ActivityMessage } from './activityMessage';
+import type { MultipleCardsEvent, MultipleCardsMessage } from './multipleCardsMessage';
 
 export type WebViewMessageType =
   | PageMessage
   | CardMessage
+  | MultipleCardsMessage
   | UnitMessage
   | PaymentMessage
   | AccountMessage
@@ -22,6 +24,7 @@ type WebViewEvent =
   | PageEvent
   | UnitEvent
   | CardEvent
+  | MultipleCardsEvent
   | BookPaymentEvent
   | PaymentMessage
   | ACHEvent

package/src/messages/webMessages/multipleCardsMessage.ts

@@ -0,0 +1,9 @@
+import type { UNCardData } from '../../types/shared';
+
+export enum MultipleCardsMessage {
+  UNIT_MULTIPLE_CARDS_CARD_CLICKED = 'unitMultipleCardsCardClicked',
+}
+
+export type MultipleCardsCardClickedEvent = UNCardData;
+
+export type MultipleCardsEvent = MultipleCardsCardClickedEvent

package/src/messages/webMessages/onLoadMessage.ts

@@ -1,16 +1,26 @@
-import type {UNAccountData, UNCounterpartyAccountData, UNCardData, UNError, UNOnLoadResponseData } from '../../types/shared';
+import type {
+  UNAccountData,
+  UNCounterpartyAccountData,
+  UNCardData,
+  UNError,
+  UNOnLoadResponseData,
+} from '../../types/shared';
 import type { UNAuthorizationData } from '../../types/shared/authorization.types';
 import type { UNTransactionData } from '../../types/shared/transactions.types';
 
 export enum RESPONSE_KEYS {
   errors = 'errors',
   card = 'cardResult',
+  cards = 'cardsResult',
   account = 'accountResult',
   counterpartyAccount = 'counterpartyResult',
   transactions = 'transactionsResult',
-  authorization = 'authorizationResult'
+  authorizations = 'authorizationsResult'
 }
 
+export type CardsOnLoadResponse = {
+  [RESPONSE_KEYS.cards]: UNOnLoadResponseData<[UNCardData]>
+}
 export type CardOnLoadResponse = {
   [RESPONSE_KEYS.card]: UNOnLoadResponseData<UNCardData>
 }
@@ -29,12 +39,13 @@ export type ACHOnLoadResponse = {
 }
 
 export type ActivityOnLoadResponse = {
-  [RESPONSE_KEYS.authorization]: UNOnLoadResponseData<UNAuthorizationData>,
+  [RESPONSE_KEYS.authorizations]: UNOnLoadResponseData<UNAuthorizationData>,
   [RESPONSE_KEYS.transactions]: UNOnLoadResponseData<UNTransactionData>
 }
 
 export type UnitOnLoadResponseSuccessData =
   | CardOnLoadResponse
+  | CardsOnLoadResponse
   | ACHOnLoadResponse
   | AccountsOnLoadResponse
   | AccountOnLoadResponse

package/src/networking/requests/UNWalletPayloadRequest.ts

@@ -1,6 +1,14 @@
 import axios from 'axios';
 import { APIHeaders, UNIT_SECURE_URL } from '../common/UNNetworkConstants';
 import type { UNEnvironment } from '../../unitSdkManager/UnitSdkManager';
+import type { UNMobileWalletPayload } from '../../helpers/pushProvisioningService/types';
+import type { UNError, UNErrorData } from '../../types/shared/error.types';
+
+const isUNMobileWalletPayload = (object: any): object is UNMobileWalletPayload => {
+  return 'data' in object &&
+    'attributes' in object.data &&
+    'payload' in object.data.attributes;
+};
 
 // TODO: use apiClient class for handling requests.
 
@@ -28,9 +36,22 @@ export const getMobileWalletPayload = async (customerToken: string, cardId: stri
       {
         headers: headers,
       });
-    const encryptedPayload = response.data.data.attributes.payload;
-    return encryptedPayload;
-  } catch (error) {
-    return Promise.reject(error);
+    if (!isUNMobileWalletPayload(response.data)) {
+      const error: UNErrorData = {title: `Couldn't get mobile wallet payload. Status:${response.status} Response data:${response.data}`};
+      throw error;
+    } else {
+      const encryptedPayload = response.data.data.attributes.payload;
+      return encryptedPayload;
+    }
+  } catch (error: unknown) {
+    // Converts the error into a UNError
+    if (axios.isAxiosError<UNError>(error) && error.response) {
+      const unErrors = error.response.data;
+      throw unErrors;
+    } else if (error instanceof Error)  {
+      const unexpectedError: UNErrorData = {title: 'Unexpected error', error: error};
+      throw unexpectedError;
+    }
+    throw {title: `Unexpected error: ${error}`};
   }
 };

package/src/slices/ConfigurationSlice.ts

@@ -0,0 +1,31 @@
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import type { RootState } from '../store';
+
+export interface ConfigurationState {
+  unitScript?: string;
+  theme?: string;
+  language?: string;
+}
+
+const initialState: ConfigurationState = {};
+
+const ConfigurationSlice = createSlice({
+  name: 'Configuration',
+  initialState: initialState,
+  reducers: {
+    setUnitScript(state, action: PayloadAction<string | undefined>) {
+      state.unitScript = action.payload;
+    },
+    setTheme(state, action: PayloadAction<string | undefined>) {
+      state.theme = action.payload;
+    },
+    setLanguage(state, action: PayloadAction<string | undefined>) {
+      state.language = action.payload;
+    },
+  },
+
+});
+
+export const { setUnitScript, setLanguage, setTheme } = ConfigurationSlice.actions;
+export const selectConfiguration = (state: RootState) => state.configuration;
+export default ConfigurationSlice.reducer;

package/src/slices/SharedEventsSlice.ts

@@ -0,0 +1,93 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import type { RootState } from '../store';
+import type { SlotRendering, WebComponentRendering } from '../types/internal/bottomSheet.types';
+import type { UNAccountData, UNCardData } from '../types/shared';
+import type { ActivityFiltersChangedEvent } from '../messages/webMessages/activityMessage';
+import type { RequestRefreshEvent } from '../messages/webMessages/unitMessages';
+import type { BottomSheetNativeMessage } from '../messages/nativeMessages/bottomSheetMessage';
+import type { CardMessage } from '../messages/webMessages/cardMessage';
+import type { AccountMessage } from '../messages/webMessages/accountMessage';
+import type { ActivityMessage } from '../messages/webMessages/activityMessage';
+import type { UnitMessage } from '../messages/webMessages/unitMessages';
+import type { MultipleCardsMessage } from '../messages/webMessages/multipleCardsMessage';
+
+type EmptyObj = Record<PropertyKey, never>;
+
+type SlotRenderingEventState = {
+  key: BottomSheetNativeMessage.START_FLOW,
+  data: SlotRendering
+}
+type MultipleCardsCardClickedEventState = {
+  key: MultipleCardsMessage.UNIT_MULTIPLE_CARDS_CARD_CLICKED,
+  data: UNCardData
+}
+
+type CardStatusChangedEventState = {
+  key: CardMessage.CARD_STATUS_CHANGED,
+  data: UNCardData
+}
+
+type CardActivatedEventState = {
+  key: CardMessage.CARD_ACTIVATED,
+  data: UNCardData
+}
+
+type AccountChangedEventState = {
+  key: AccountMessage.UNIT_ACCOUNT_CHANGED,
+  data: UNAccountData
+}
+
+type ActivityFiltersChangedEventState = {
+  key: ActivityMessage.UNIT_ACTIVITY_FILTERS_CHANGED
+  data: ActivityFiltersChangedEvent
+}
+
+type RequestCloseFlowEventState = {
+  key: UnitMessage.UNIT_REQUEST_CLOSE_FLOW,
+  data: EmptyObj
+}
+
+type WebComponentRenderingEventState = {
+  key: BottomSheetNativeMessage.START_FLOW,
+  data: WebComponentRendering
+}
+
+type RequestRefreshEventState = {
+  key: UnitMessage.UNIT_REQUEST_REFRESH,
+  data: RequestRefreshEvent
+}
+
+//currently left state suffixes to avoid the duplication of the event names
+type SharedEvent =
+  SlotRenderingEventState
+  | CardStatusChangedEventState
+  | CardActivatedEventState
+  | MultipleCardsCardClickedEventState
+  | AccountChangedEventState
+  | ActivityFiltersChangedEventState
+  | RequestCloseFlowEventState
+  | WebComponentRenderingEventState
+  | RequestRefreshEventState
+
+type SharedEventsState = {
+  event?: SharedEvent
+}
+
+const initialState: SharedEventsState = {};
+
+const SharedEventsSlice = createSlice({
+  name: 'SharedEvents',
+  initialState: initialState,
+  reducers: {
+    setEvent(state, action: PayloadAction<SharedEvent>) {
+      state.event = action.payload;
+    },
+  },
+
+});
+
+export const { setEvent } = SharedEventsSlice.actions;
+export const selectSharedEvents = (state: RootState) => state.sharedEvents;
+export default SharedEventsSlice.reducer;

package/src/store/store.ts

@@ -1,10 +1,14 @@
 import { configureStore } from '@reduxjs/toolkit';
 import wallet from '../slices/pushProvisioningSlice';
+import configuration from '../slices/ConfigurationSlice';
+import sharedEvents from '../slices/SharedEventsSlice';
 
 export const store = configureStore({
   reducer: {
-    wallet
-  }
+    wallet,
+    configuration,
+    sharedEvents,
+  },
 });
 
 export type RootState = ReturnType<typeof store.getState>;

package/src/types/internal/errorHelpers.ts

@@ -0,0 +1,22 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import type { UNErrorData } from '../shared/error.types';
+import type { UNError } from '../shared';
+
+const isUNErrorData = (obj: any): obj is UNErrorData => {
+  return (
+    typeof obj === 'object' &&
+    'title' in obj
+  );
+};
+
+export const isUNErrorDataArray = (arr: any): arr is UNErrorData[] => {
+  return (
+    Array.isArray(arr) &&
+    arr.every((item) => isUNErrorData(item))
+  );
+};
+
+export const isUNError = (error: any): error is UNError => {
+  return 'errors' in error && isUNErrorDataArray(error.errors);
+};

package/src/types/internal/webComponent.types.ts

@@ -1,5 +1,6 @@
 export enum WebComponentType {
   card = 'unit-elements-card',
+  multipleCards = 'unit-elements-multiple-cards',
   bookPayment = 'unit-elements-book-payment',
   activity = 'unit-elements-activity',
   slot = 'unit-elements-sdk-slot',
@@ -7,7 +8,6 @@ export enum WebComponentType {
   checkDeposit = 'unit-elements-check-deposit',
   achDebitPayment = 'unit-elements-ach-debit-payment',
   achCreditPayment = 'unit-elements-ach-credit-payment',
-
   cardAction = 'unit-elements-card-action',
 }
 

package/src/types/shared/activity.types.ts

@@ -2,7 +2,12 @@ import type { RESPONSE_KEYS } from '../../messages/webMessages/onLoadMessage';
 import type { UNAuthorizationData } from './authorization.types';
 import type { UNTransactionData } from './transactions.types';
 
+export const enum UNActivityComponentPaginationType {
+  infiniteScroll = 'infiniteScroll',
+  pagination = 'pagination'
+}
+
 export type UNActivityOnLoadData = {
-  [RESPONSE_KEYS.authorization]: UNAuthorizationData,
+  [RESPONSE_KEYS.authorizations]: UNAuthorizationData,
   [RESPONSE_KEYS.transactions]: UNTransactionData,
 }

package/src/types/shared/error.types.ts

@@ -0,0 +1,38 @@
+export type UNError = {
+  errors: UNErrorData[]
+}
+
+export type UNErrorData = {
+  status?: string,
+  title: string,
+  detail?: string,
+  details?: string,
+  meta?: UNErrorMeta
+  code?: UNErrorCodes,
+  error?: Error
+}
+
+interface UNErrorMeta {
+  meta: Record<string, string>,
+}
+
+export enum UNErrorCodes {
+    FEATURE_DISABLED = 'feature_disabled',
+    INVALID_VALUE = 'invalid_value',
+    LIMITS_EXCEEDED = 'limits_exceeded',
+    NOT_FOUND = 'not_found',
+    ACCOUNT_CUSTOMER_MISMATCH = 'account_customer_mismatch',
+    NOT_SUPPORTED_FOR_ACCOUNT_STATUS = 'not_supported_for_account_status',
+    NOT_SUPPORTED_FOR_ACCOUNT_TYPE = 'not_supported_for_account_type',
+    NOT_SUPPORTED_FOR_CARD = 'not_supported_for_card',
+    NOT_SUPPORTED_FOR_CARD_STATUS = 'not_supported_for_card_status',
+    NOT_SUPPORTED_FOR_CARD_TYPE = 'not_supported_for_card_type',
+    INVALID_NONCE = 'invalid_nonce',
+    NOT_SUPPORTED_FOR_PAYMENT_TYPE = 'not_supported_for_payment_type',
+    PAYMENT_INVALID = 'payment_invalid',
+    UNAUTHORIZED = 'unauthorized',
+    FORBIDDEN = 'forbidden',
+    ALREADY_EXISTS = 'already_exists',
+    CUSTOMER_NAME_UNDELIVERABLE = 'customer_name_undeliverable',
+    CUSTOMER_ADDRESS_UNDELIVERABLE = 'customer_address_undeliverable',
+}

package/src/types/shared/index.ts

@@ -7,4 +7,6 @@ export * from './account.types';
 export * from './checkDeposit.types';
 export * from './activity.types';
 export * from './fonts.types';
+export * from './error.types';
 export * from './versioning.types';
+export * from './multipleCards.types';

package/src/types/shared/multipleCards.types.ts

@@ -0,0 +1,8 @@
+import type { UNCardData } from './card.types';
+
+export const enum UNMultipleCardsComponentPaginationType {
+  infiniteScroll = 'infiniteScroll',
+  pagination = 'pagination'
+}
+
+export type UNMultipleCardsOnLoadData = UNCardData[];

package/src/types/shared/onLoadResponse.types.ts

@@ -1,19 +1,9 @@
+import type { UNError } from './error.types';
+
 export type UNOnLoadResponseData<T> = {
   data: T,
 }
 
-export type UNError = {
-  errors: UNErrorData[]
-}
-
-export type UNErrorData = {
-  status: string,
-  title: string,
-  detail?: string,
-  details?: string,
-  meta?: Record<string, string>
-}
-
 export type UNOnLoadResponse<T> =
   | UNOnLoadResponseData<T>
   | UNError

package/src/unitSdkManager/UnitSdk.api.ts

@@ -1,15 +1,14 @@
-import EventBus from '../helpers/EventBus';
-import { SDKMessage, SdkScriptFetched } from '../messages/nativeMessages/sdkMessage';
 import { UnitSDK } from './UnitSdkManager';
 
 import { getUnitScriptUrl } from './UnitSdkManager.utils.internal';
+import { store } from '../store/store';
+import { setUnitScript, selectConfiguration } from '../slices/ConfigurationSlice';
 
 let isLoadingScript = false;
 
-/** globalUnitScript is exported ONLY to our project components **/
-export let globalUnitScript = '';
-
 export const fetchUnitScript = async () => {
+  const configurationState = selectConfiguration(store.getState());
+  const globalUnitScript = configurationState.unitScript;
   const env = UnitSDK.getEnv();
   const webVersioningStrategy = UnitSDK.getWebVersioningStrategy();
   if (isLoadingScript || globalUnitScript || !env) {
@@ -21,9 +20,7 @@ export const fetchUnitScript = async () => {
     const unitScriptRes = await fetch(getUnitScriptUrl(env, webVersioningStrategy));
     const unitScript = await unitScriptRes.text();
     if (unitScript) {
-      const scriptFetchData: SdkScriptFetched = { unitScript };
-      EventBus.Instance.event(SDKMessage.IS_SCRIPT_FETCHED, scriptFetchData);
-      globalUnitScript = unitScript;
+      store.dispatch(setUnitScript(unitScript));
     }
     return null;
   } catch (e) {

package/src/unitSdkManager/UnitSdk.constants.ts

@@ -3,7 +3,7 @@ import { UNVersioningStrategyType, UNWebVersioningStrategy } from '../types/shar
 const WEB_SDK_RECOMMENDED_STRATEGY: UNWebVersioningStrategy = {
   type: UNVersioningStrategyType.upToNextMinor,
   major: 1,
-  minor: 2,
+  minor: 3,
 };
 
 export const UNSDKConstants = {

package/src/unitSdkManager/UnitSdkManager.ts

@@ -1,12 +1,12 @@
 import type { NativeModules } from 'react-native';
-import EventBus from '../helpers/EventBus';
-import { SDKMessage } from '../messages/nativeMessages/sdkMessage';
 import { fetchUnitScript } from './UnitSdk.api';
 import { UnitUiManager } from './unitUiManager/unitUiManager';
 import type { UNFonts } from '../types/shared/fonts.types';
 import { warnClientIfNeeded } from '../utils/webVersioningStrategy.utils';
 import { UNSDKConstants } from './UnitSdk.constants';
 import type { UNWebVersioningStrategy } from '../types/shared';
+import { setTheme, setLanguage } from '../slices/ConfigurationSlice';
+import { store } from '../store/store';
 
 export enum UNEnvironment {
   sandbox = 'sandbox',
@@ -18,8 +18,6 @@ export class UnitSDK {
   protected static env?: UNEnvironment;
   protected static webVersioningStrategy: UNWebVersioningStrategy;
   protected static customerToken?: string;
-  protected static theme?: string;
-  protected static language?: string;
   protected static fonts?: UNFonts;
   protected static signedNonce?: string;
   protected static pushProvisionModule?: typeof NativeModules;
@@ -28,14 +26,12 @@ export class UnitSDK {
     try {
       this.env = env;
       this.webVersioningStrategy = webVersioningStrategy;
-      this.theme = theme;
-      this.language = language;
       this.fonts = fonts;
-
+      store.dispatch(setTheme(theme));
+      store.dispatch(setLanguage(language));
       this.ui = new UnitUiManager();
       warnClientIfNeeded(this.webVersioningStrategy);
       await fetchUnitScript();
-      EventBus.Instance.event(SDKMessage.IS_SDK_INITIALIZED, {});
     } catch (e) {
       console.log(e);
     }
@@ -50,8 +46,8 @@ export class UnitSDK {
   };
 
   /**
- * @deprecated - Unit SDK is managing the signedNonce, no need to provide it
- */
+   * @deprecated - Unit SDK is managing the signedNonce, no need to provide it
+   */
   public static setSignedNonce = (signedNonce: string) => {
     this.signedNonce = signedNonce;
   };
@@ -64,21 +60,13 @@ export class UnitSDK {
     return this.webVersioningStrategy;
   };
 
-  public static getTheme = () => {
-    return this.theme;
-  };
-
-  public static getLanguage = () => {
-    return this.language;
-  };
-
   public static getFonts = () => {
     return this.fonts;
   };
 
   /**
- * @deprecated - Unit SDK is managing the signedNonce, no need to provide it
- */
+   * @deprecated - Unit SDK is managing the signedNonce, no need to provide it
+   */
   public static getSignedNonce = () => {
     return this.signedNonce;
   };