feat: support multiple HyperServices instances

Adds a HyperServiceInstance class that creates independent, keyed
HyperServices objects alongside the existing module-wide singleton API,
each with its own event channel. This PR covers the core integration:
create, initiate, process, terminate, back-press and status helpers.
Merchant views, HyperFragmentView and processWithActivity/openPaymentPage
per instance follow in a separate PR.

JS:
- HyperServiceInstance: constructor(tenantId?, clientId?), initiate,
  process, terminate, onBackPressed, isNull, isInitialised and
  getHyperEventString() as the instance's event channel
- lazy linking error; platform guards for iOS-only gaps

Android:
- keyed create/initiate/process/terminate/back-press/isInitialised with
  per-key event emission
- permission and activity results forwarded to every live instance
- invalidate() terminates and clears keyed state on React reloads
- every skipped call logged to logcat alongside SdkTracker telemetry
- legacy single-instance API behaviour preserved exactly
- resolve ReactHost reflectively so the module compiles on RN < 0.74
- fix rnVersion Groovy scoping crash for newArchEnabled=false consumers

iOS:
- keyed methods mirrored with per-key delegate retention, dynamic
  supportedEvents, synchronized dict access, and invalidate cleanup
- podspec: RN version detection for development layouts; folly compiler
  flags applied

Example app:
- toolchain modernized: React Native 0.79.7 (react 19), AGP 8.9 via RNGP,
  Gradle 8.13, compileSdk 36, Kotlin 2.0.21, RN 0.79 Podfile, Flipper
  removed; Jetifier re-enabled for the Juspay micro-SDKs with RN AARs on
  the ignorelist
- demo flows for multiple instances: create/select instances, initiate,
  process and terminate per instance with per-instance event listeners
- generateSign accepts PKCS#8/PKCS#1 keys with or without PEM armor on
  both platforms, with errors surfaced in the UI

Docs:
- README section covering merchant integration for multiple instances

Co-authored-by: Anurag Singh <as6003688@gmail.com>
Co-authored-by: yuvrajjsingh0 <yuvraj.singh@juspay.in>

Author: 3 people

README.md

@@ -110,6 +110,13 @@ const { HyperSdkReact } = NativeModules;
 export default HyperSdkReact as HyperSdkReactType;
 ```
 
+For apps that need more than one tenant / client in the same session, the module also exports a
+`HyperServiceInstance` class. See [Multiple HyperServices Instances](#multiple-hyperservices-instances).
+
+```ts
+import HyperSdkReact, { HyperServiceInstance } from 'hyper-sdk-react';
+```
+
 ### Import HyperSDK
 
 ```ts
@@ -134,6 +141,9 @@ This method creates an instance of `HyperServices` class in the React Bridge Mod
 HyperSdkReact.createHyperServices();
 ```
 
+This creates a single, module-wide instance. If you need several independent instances (multiple
+tenants / clients), use [`HyperServiceInstance`](#multiple-hyperservices-instances) instead.
+
 ### Step-2: Initiate
 
 This method should be called on the render of the host screen. This will boot up the SDK and start the Hyper engine. It takes a `stringified JSON` as its argument which will contain the base parameters for the entire session and remains static throughout one SDK instance lifetime.
@@ -340,7 +350,7 @@ If your view dynamically computes height. Height can be obtained by adding the f
   useLayoutEffect(() => {
     if (ref.current?.measure) {
       ref.current.measure((x, y, width, height, pageX, pageY) => {
-        HyperServices.updateMerchantViewHeight(HyperSdkReact.JuspayHeader, height);
+        HyperSdkReact.updateMerchantViewHeight(HyperSdkReact.JuspayHeader, height);
       });
     }
   }, []);
@@ -369,6 +379,166 @@ If your `AppDelegate` is in `swift` and you are using react native version great
 
 ```
 
+## Multiple HyperServices Instances
+
+By default the module keeps a **single** `HyperServices` object, and every top-level API
+(`HyperSdkReact.initiate`, `HyperSdkReact.process`, …) operates on it. If your app needs to talk to
+more than one tenant / client in the same session — for example a marketplace that switches between
+two Juspay merchants, or a super-app hosting several sub-brands — you can create independent
+instances with `HyperServiceInstance`.
+
+Each instance owns its own `HyperServices` object natively and **emits its events on its own channel**.
+This is the only real difference in the integration: the event name is no longer the constant
+`HyperSdkReact.HyperEvent`, it is the instance's own key, returned by `getHyperEventString()`.
+
+### Step-1: Import
+
+```ts
+import HyperSdkReact, { HyperServiceInstance } from 'hyper-sdk-react';
+```
+
+### Step-2: Create an instance
+
+Replaces `HyperSdkReact.createHyperServices()` / `HyperSdkReact.createHyperServicesWithTenantId()`.
+The constructor allocates the native object immediately and generates the instance key.
+
+```ts
+// Default tenant / client
+const instance = new HyperServiceInstance();
+
+// Explicit tenant and client
+const tenantInstance = new HyperServiceInstance(tenantId, clientId);
+```
+
+On Android the native object can only be created while an activity is in the foreground, and creation
+happens asynchronously on the native side — so a synchronous `isNull()` right after the constructor
+will still report `true`. If you want to confirm creation succeeded, check `isNull()` on a later tick
+(for example just before calling `initiate`). Hold on to the object for the whole
+lifetime of the flow — an instance can only be addressed through the reference you keep in JS. A common pattern is a `Map` keyed by `getHyperEventString()`:
+
+```ts
+const instances = new Map<string, HyperServiceInstance>();
+const instance = new HyperServiceInstance(tenantId, clientId);
+instances.set(instance.getHyperEventString(), instance);
+```
+
+`preFetch` stays global and is still called once as `HyperSdkReact.preFetch(...)` — it is not per-instance.
+
+### Step-3: Listen to events from this instance
+
+Register the listener **before** calling `initiate`, using the instance's key as the event name.
+Events for one instance are never delivered on another instance's channel, nor on `HyperSdkReact.HyperEvent`.
+
+```ts
+componentDidMount() {
+  const eventEmitter = new NativeEventEmitter(NativeModules.HyperSdkReact);
+
+  this.eventListener = eventEmitter.addListener(
+    this.instance.getHyperEventString(),
+    (resp) => {
+      const data = JSON.parse(resp);
+      switch (data.event || '') {
+        case 'show_loader':
+          break;
+        case 'hide_loader':
+          break;
+        case 'initiate_result':
+          console.log('initiate_result: ', data.payload || {});
+          break;
+        case 'process_result':
+          console.log('process_result: ', data.payload || {});
+          break;
+        default:
+          console.log('Unknown Event', data);
+      }
+    }
+  );
+}
+
+componentWillUnmount() {
+  this.eventListener.remove();
+}
+```
+
+**Note**: the key is generated per instance, so it must be threaded through to whichever screen
+listens for the response. If you navigate to another screen to run `process`, pass the instance (or
+its key) through the navigation params and subscribe there.
+
+### Step-4: Initiate and Process
+
+Same payloads as the single-instance API — only the receiver changes.
+
+```ts
+instance.initiate(JSON.stringify(initiatePayload));
+instance.process(JSON.stringify(processPayload));
+```
+
+### Step-5: Android hardware back-press handling
+
+Back press must be offered to the instance that currently owns the screen. With more than one live
+instance, track which one is in the foreground and delegate to that one:
+
+```ts
+BackHandler.addEventListener('hardwareBackPress', () => {
+  const instance = this.activeInstance;
+  return !!instance && !instance.isNull() && instance.onBackPressed();
+});
+```
+
+### Step-6: Android permissions and activity results
+
+Unchanged and still done once, at the activity level — the snippets in
+[Step-6](#step-6-android-permissions-handling) of the single-instance guide apply as-is. No
+per-instance wiring is required in `MainActivity`.
+
+Permission and activity results are offered to every live instance; the SDK routes them internally by
+request code, so no per-instance wiring is needed.
+
+### Step-7: Terminate
+
+Terminate each instance you created. Terminating one instance does not affect the others.
+
+```ts
+instance.terminate();
+```
+
+After `terminate()` the key is released natively; also remove the JS listener registered in
+[Step-3](#step-3-listen-to-events-from-this-instance) and drop your reference to the object, otherwise
+the instance is retained on the JS side.
+
+### Helpers
+
+```ts
+const isNull: boolean = instance.isNull();          // native object missing / already terminated
+instance.isInitialised().then((init: boolean) => {}); // initiate has completed
+const key: string = instance.getHyperEventString();   // event channel for this instance
+```
+
+### Instance API
+
+```ts
+class HyperServiceInstance {
+  constructor(tenantId?: string, clientId?: string);
+  initiate(data: string): void;
+  process(data: string): void;
+  terminate(): void;
+  onBackPressed(): boolean;
+  isNull(): boolean;
+  isInitialised(): Promise<boolean>;
+  getHyperEventString(): string;
+}
+```
+
+### Limitations
+
+- **`processWithActivity`, `openPaymentPage`, merchant views** (`JuspayHeader`, `JuspayFooter`, …)
+  and **`HyperFragmentView`** are not instance-aware yet; they operate on the single-instance
+  (module-level) API. Use `HyperSdkReact.*` for flows that need them.
+- **Permission and activity results** are offered to every live instance and routed internally by
+  request code. If two instances trigger flows that wait on the same Android request code at the same
+  moment, results cannot be disambiguated — avoid two simultaneous permission-driven flows.
+- The single-instance `HyperSdkReact.*` API and `HyperServiceInstance` can coexist in one app.
+
 ## Payload Structure
 
 Please refer [here for Express Checkout SDK](https://developer.juspay.in/v2.0/docs/payload) and [here for Payment Page SDK](https://developer.juspay.in/v4.0/docs/payload), for all request and response payload structure.

android/build.gradle

@@ -59,7 +59,7 @@ def getRNVersion() {
 }
 
 
-def rnVersion = getRNVersion()
+ext.rnVersion = getRNVersion()
 println "Found react native version as ${rnVersion}"
 
 def isNewArchitectureEnabled() {