@dpdpguard/react-native 1.3.0 → 2.1.0

package/DpdpGuardReactNative.podspec

@@ -0,0 +1,35 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "DpdpGuardReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/dpdp-guard-ai/dpdpguard-react-native-sdk.git", :tag => "v#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.swift_version = "5.9"
+
+  # Secure Enclave key generation and ECDSA signing; CryptoKit (via a Swift
+  # shim, DpdpGuardOfflineCrypto) for the AES-GCM sealing of the
+  # pending-capture store -- CommonCrypto's public headers have no GCM API
+  # on current SDKs.
+  s.frameworks   = "Security"
+
+  # Swift's ClangImporter builds this pod's umbrella module in plain
+  # Objective-C mode by default, but DpdpGuardOffline.h pulls in the
+  # TurboModule codegen header (DpdpGuardOfflineSpec.h), which is C++ and
+  # refuses to compile outside Objective-C++. objcxx interop mode makes
+  # Swift import it as such instead of tripping that guard.
+  s.pod_target_xcconfig = {
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx"
+  }
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -9,24 +9,31 @@ https://github.com/dpdp-guard-ai/dpdpbot/blob/main/docs/specs/mobile-server-sdk.
 
 ## What's here vs. what's not
 
-This repo was originally scaffolded as a `create-react-native-library`
-turbo-module (`multiply()` native stub, Android/iOS native folders) on the
-assumption it would eventually bridge over the native Android/iOS consent
-engines (ADR-005). That native bridge was never built, and on review it
-isn't the right shape for this package anyway: `dpdpguard-android-sdk` and
-`dpdpguard-ios-sdk` are separate, independently-versioned native libraries
-(ADR-003), and bridging to them would tie every RN release to whatever
-native SDK versions happen to be vendored alongside it, for no benefit —
-none of this SDK's functionality needs on-device native code. The
-turbo-module scaffold (native folders, `NativeReactNative.ts`,
-`multiply()`) has been removed.
-
-What's implemented instead is the **HTTP client layer**: a typed
-`DpdpGuardClient` over DPDP Guard's public `/api/v1` (spec §4.2), following
-the same pattern as `dpdpguard-server-sdk`/`dpdpguard-js-sdk` — usable
-today from RN app code via plain `fetch`, with no native module involved.
-This is also the pattern `dpdpguard-flutter-sdk` follows, for consistency
-across both hybrid SDKs.
+Two layers, with different requirements:
+
+**The HTTP client** — a typed `DpdpGuardClient` over DPDP Guard's public
+`/api/v1` (spec §4.2), following the same pattern as
+`dpdpguard-server-sdk`/`dpdpguard-js-sdk` and `dpdpguard-flutter-sdk`.
+Plain `fetch`, no native module involved; usable from any JS runtime.
+
+**Offline consent capture** — the device-side half of
+`docs/specs/offline-consent-capture.md` §4, matching what
+`dpdpguard-ios-sdk` ships natively. This *does* need native code: consent
+captured away from the network is signed by a key held in the device's
+secure element, and the pending queue is encrypted at rest. It requires
+React Native's new architecture.
+
+The split matters for what gets written twice. **The `dpdpcca/2`
+canonicalization lives only in JavaScript** (`src/offline/captureArtifact.ts`),
+tested against `@dpdpguard/contract`'s golden vectors. The native modules
+under `ios/` and `android/` do key storage, signing, and encrypted
+persistence only. A second canonicalization in Swift and a third in Kotlin
+could drift from the server's, and drift there means a legitimate consent
+quarantining as `signature_mismatch` on sync — so there is exactly one.
+
+This is a reversal of the position taken in `1.0.0`, which removed the
+`create-react-native-library` turbo-module scaffold on the reasoning that
+nothing here needed on-device native code. Offline capture does.
 
 **Deliberately excluded, for security, not by omission:**
 
@@ -43,12 +50,13 @@ across both hybrid SDKs.
   client. The *unkeyed* half of the audit hash is available as
   `canonicalAuditString()` (see [Audit-hash canonicalization](#audit-hash-canonicalization));
   it needs no secret.
-- **No offline consent capture.** `dpdpguard-ios-sdk` implements the
-  device-side Cryptographic Consent Artifact (`docs/specs/offline-consent-capture.md`
-  §4) on top of Secure Enclave key storage and an encrypted local store.
-  That needs native code, which this package deliberately doesn't have — and
-  a software-only port would produce artifacts that don't prove what the
-  spec's artifacts prove.
+- **No direct sync of offline captures.**
+  `POST /api/v1/offline/captures` is declared `security: [apiKey]` — the
+  same org-scoped service key `brokerToken()` would need. So
+  `OfflineCaptureManager.syncPending()` takes a transport function you
+  supply, which in practice POSTs the batch to your own backend to be
+  forwarded with the key attached. Capture, signing, and queueing all
+  happen on-device; only the final hop is brokered.
 
 ## Usage
 
@@ -151,6 +159,102 @@ server-side, so this package stops at the canonical form — hand it to your
 backend to sign, or use it to check which event a hash your backend
 returned refers to.
 
+## Offline consent capture
+
+For field agents, POS terminals, and IVR gateways capturing consent away
+from the network (`docs/specs/offline-consent-capture.md` §4). Requires the
+new architecture — the native module is autolinked; no manual step beyond
+`pod install`.
+
+### 1. Enroll the device, once
+
+```ts
+import { OfflineCaptureManager } from '@dpdpguard/react-native';
+
+const offline = new OfflineCaptureManager({
+  organizationId: 'org_abc123',
+  deviceId: 'device_pune_114', // the agentDevices row for this device
+});
+
+const { publicKeySPKIBase64, hardwareBacked } = await offline.enroll();
+```
+
+The private key is generated inside the Secure Enclave (iOS) or
+StrongBox/TEE (Android) and never leaves the device — this SDK cannot
+transmit it. Register `publicKeySPKIBase64` on `agentDevices` through the
+fleet-enrollment console flow; until you do, every capture from this device
+quarantines as `unknown_device`.
+
+Check `hardwareBacked` before allowing capture in production. It is `false`
+on Simulators, emulators, and hardware with no secure element, where the
+key is only software-protected — the server cannot tell the difference from
+the signature alone, so this is the only place that decision can be made.
+
+### 2. Capture, with no connectivity
+
+```ts
+const session = await offline.capture({
+  noticeId: 'notice_v3',
+  noticeVersion: 3,
+  noticeLocale: 'hi', // the language actually rendered — s. 5(3) evidence
+  purposeGrants: [
+    { purposeKey: 'kyc_verification', purposeLabel: 'KYC', category: 'essential', status: 'opt_in' },
+    { purposeKey: 'marketing', purposeLabel: 'Marketing', category: 'non_essential', status: 'opt_out' },
+  ],
+  dataTypes: ['pan', 'aadhaar'],
+  principalHandle: { kind: 'phone_hash', value: '9876543210' },
+  channel: 'agent_app',
+});
+```
+
+Nothing here touches the network. Pass every purpose the principal was
+*shown*, opted in or out: proving someone was shown marketing and refused
+is what distinguishes granular consent from a notice that quietly omitted
+it.
+
+### 3. Sync when connectivity returns
+
+`POST /api/v1/offline/captures` requires an org-scoped service API key,
+which must never ship in an app bundle — so you supply the transport, and
+it goes through your own backend:
+
+```ts
+const results = await offline.syncPending(async (body) => {
+  const response = await fetch('https://my-backend.example/dpdp/offline-captures', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${myAppSessionToken}` },
+    body: JSON.stringify(body), // forward verbatim; your backend adds the DPDP Guard API key
+  });
+  return response.json(); // { results: [...] }
+});
+
+for (const result of results) {
+  if (result.status !== 'verified') {
+    console.warn(`${result.clientSessionId}: ${result.status} — ${result.reason}`);
+  }
+}
+```
+
+**Partial success is normal.** A resolved promise does not mean every
+capture committed — inspect each result. Batches are split at 200 sessions,
+which is the endpoint's limit. Every acknowledged session is evicted from
+the local store, including quarantined and rejected ones: those are
+retained server-side as evidence (spec §4.4 — never silently dropped), so
+keeping a local copy would only mean resubmitting them forever.
+
+A `withdrawalToken` on a verified result is what makes the consent
+withdrawable under s. 6(4) — print it on the slip or read it out.
+
+### What the device signs
+
+`capture()` builds the `dpdpcca/2` canonical string
+(`conformance/audit-hash-spec.md`) and has the secure element sign its
+UTF-8 bytes with ECDSA P-256 / SHA-256. The server recomputes that string
+at sync and verifies it, so the canonicalization is exact: token lengths in
+UTF-8 bytes, byte-wise sorts, explicit list counts. It is implemented once,
+in JavaScript, and checked against the contract's golden vectors —
+`canonicalCaptureString()` is exported if you need to re-derive it.
+
 ## Contract
 
 Depends on

package/android/build.gradle

@@ -0,0 +1,45 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.24"
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "ai.dpdpguard.offline"
+
+  compileSdk 35
+
+  defaultConfig {
+    // KeyInfo.getSecurityLevel() and StrongBox both need modern APIs, but
+    // the module degrades rather than crashes below them: see
+    // DpdpGuardOfflineModule.isHardwareBacked.
+    minSdk 24
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/ai/dpdpguard/offline/DpdpGuardOfflineModule.kt

@@ -0,0 +1,317 @@
+package ai.dpdpguard.offline
+
+import android.os.Build
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyInfo
+import android.security.keystore.KeyProperties
+import android.util.Base64
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import java.io.File
+import java.security.KeyFactory
+import java.security.KeyPairGenerator
+import java.security.KeyStore
+import java.security.PrivateKey
+import java.security.Signature
+import java.security.spec.ECGenParameterSpec
+import javax.crypto.Cipher
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+import javax.crypto.spec.GCMParameterSpec
+
+/**
+ * Secure-element key storage, ECDSA P-256 signing, and an encrypted local
+ * queue for offline consent capture (docs/specs/offline-consent-capture.md
+ * §4).
+ *
+ * Deliberately narrow: this module never builds the `dpdpcca/2` canonical
+ * string. That lives in JavaScript (src/offline/captureArtifact.ts), tested
+ * against the contract's golden vectors, so there is exactly one
+ * implementation of the bytes a signature commits to — a second one here
+ * could drift, and drift means a legitimate consent quarantining as
+ * `signature_mismatch`.
+ */
+@ReactModule(name = DpdpGuardOfflineModule.NAME)
+class DpdpGuardOfflineModule(reactContext: ReactApplicationContext) :
+  NativeDpdpGuardOfflineSpec(reactContext) {
+
+  companion object {
+    const val NAME = "DpdpGuardOffline"
+
+    private const val KEYSTORE = "AndroidKeyStore"
+    private const val SIGNING_KEY_ALIAS = "ai.dpdpguard.offline.signing-key"
+    private const val STORE_KEY_ALIAS = "ai.dpdpguard.offline.store-key"
+    private const val STORE_DIRECTORY = "dpdpguard-offline-captures"
+    private const val SESSION_EXTENSION = ".dpdpcap"
+
+    /** AES-GCM nonce length, in bytes. */
+    private const val NONCE_LENGTH = 12
+    private const val TAG_BITS = 128
+  }
+
+  override fun getName(): String = NAME
+
+  private val keyStore: KeyStore by lazy {
+    KeyStore.getInstance(KEYSTORE).apply { load(null) }
+  }
+
+  private val storeDirectory: File by lazy {
+    // filesDir, not cacheDir or external storage: pending captures hold PII
+    // and are evidence of a legal event, so they must not be evictable by
+    // the OS or readable by another app.
+    File(reactApplicationContext.filesDir, STORE_DIRECTORY).apply { mkdirs() }
+  }
+
+  // --- Signing key ---------------------------------------------------------
+
+  private fun signingKeyEntry(): KeyStore.PrivateKeyEntry {
+    (keyStore.getEntry(SIGNING_KEY_ALIAS, null) as? KeyStore.PrivateKeyEntry)?.let {
+      return it
+    }
+
+    val spec = KeyGenParameterSpec.Builder(
+      SIGNING_KEY_ALIAS,
+      KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY,
+    )
+      .setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))
+      .setDigests(KeyProperties.DIGEST_SHA256)
+      // No setUserAuthenticationRequired: a field agent captures consent for
+      // someone else, often on a shared device, so gating each signature on
+      // the agent's biometric would block the capture the spec requires to
+      // work at zero bars and with no interaction beyond the notice itself.
+      .apply {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+          // StrongBox where the hardware has it; fall through below if not.
+          setIsStrongBoxBacked(true)
+        }
+      }
+      .build()
+
+    val generator = KeyPairGenerator.getInstance(
+      KeyProperties.KEY_ALGORITHM_EC,
+      KEYSTORE,
+    )
+
+    try {
+      generator.initialize(spec)
+      generator.generateKeyPair()
+    } catch (strongBoxUnavailable: Exception) {
+      // StrongBoxUnavailableException on devices without a dedicated secure
+      // element. Retry against the TEE: a TEE-held key is still non-
+      // exportable, and isHardwareBacked() reports what was actually used.
+      val fallback = KeyGenParameterSpec.Builder(
+        SIGNING_KEY_ALIAS,
+        KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY,
+      )
+        .setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))
+        .setDigests(KeyProperties.DIGEST_SHA256)
+        .build()
+      generator.initialize(fallback)
+      generator.generateKeyPair()
+    }
+
+    return keyStore.getEntry(SIGNING_KEY_ALIAS, null) as KeyStore.PrivateKeyEntry
+  }
+
+  override fun enrollDevice(promise: Promise) {
+    try {
+      val entry = signingKeyEntry()
+      // getEncoded() on an EC public key is already SPKI DER, exactly what
+      // agentDevices.publicKey stores.
+      val spki = entry.certificate.publicKey.encoded
+      promise.resolve(Base64.encodeToString(spki, Base64.NO_WRAP))
+    } catch (error: Exception) {
+      promise.reject("enroll_failed", "Could not create the device signing key.", error)
+    }
+  }
+
+  override fun getPublicKey(promise: Promise) {
+    try {
+      val entry = keyStore.getEntry(SIGNING_KEY_ALIAS, null) as? KeyStore.PrivateKeyEntry
+      if (entry == null) {
+        promise.resolve(null)
+        return
+      }
+      val spki = entry.certificate.publicKey.encoded
+      promise.resolve(Base64.encodeToString(spki, Base64.NO_WRAP))
+    } catch (error: Exception) {
+      promise.reject("keystore_failed", "Could not read the device signing key.", error)
+    }
+  }
+
+  override fun isHardwareBacked(promise: Promise) {
+    try {
+      val entry = keyStore.getEntry(SIGNING_KEY_ALIAS, null) as? KeyStore.PrivateKeyEntry
+      if (entry == null) {
+        promise.resolve(false)
+        return
+      }
+
+      val privateKey: PrivateKey = entry.privateKey
+      val factory = KeyFactory.getInstance(privateKey.algorithm, KEYSTORE)
+      val info = factory.getKeySpec(privateKey, KeyInfo::class.java)
+
+      val backed = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        info.securityLevel == KeyProperties.SECURITY_LEVEL_TRUSTED_ENVIRONMENT ||
+          info.securityLevel == KeyProperties.SECURITY_LEVEL_STRONGBOX
+      } else {
+        @Suppress("DEPRECATION")
+        info.isInsideSecureHardware
+      }
+      promise.resolve(backed)
+    } catch (error: Exception) {
+      promise.resolve(false)
+    }
+  }
+
+  override fun sign(canonical: String, promise: Promise) {
+    try {
+      val entry = signingKeyEntry()
+      val signature = Signature.getInstance("SHA256withECDSA").apply {
+        initSign(entry.privateKey)
+        update(canonical.toByteArray(Charsets.UTF_8))
+      }
+      val der = signature.sign()
+      val p1363 = p1363FromDer(der)
+        ?: throw IllegalStateException("Signature was not valid X9.62 DER.")
+      promise.resolve(Base64.encodeToString(p1363, Base64.NO_WRAP))
+    } catch (error: Exception) {
+      promise.reject("sign_failed", "The device refused to sign the capture.", error)
+    }
+  }
+
+  /**
+   * Converts the X9.62 DER signature the JCA returns into the raw
+   * IEEE-P1363 `r || s` pair the server verifies. Both integers are
+   * left-padded to exactly 32 bytes: DER strips leading zeroes and may add
+   * a padding byte, so neither is a fixed width on the wire.
+   */
+  private fun p1363FromDer(der: ByteArray): ByteArray? {
+    if (der.size < 8 || der[0] != 0x30.toByte()) return null
+
+    var index = 1
+    // Skip the (possibly long-form) sequence length.
+    index += if (der[index].toInt() and 0x80 != 0) {
+      1 + (der[index].toInt() and 0x7f)
+    } else {
+      1
+    }
+
+    val out = ByteArray(64)
+    for (half in 0..1) {
+      if (index >= der.size || der[index] != 0x02.toByte()) return null
+      index++
+      if (index >= der.size) return null
+
+      var intLength = der[index].toInt() and 0xff
+      index++
+      if (intLength == 0 || index + intLength > der.size) return null
+
+      var start = index
+      index += intLength // Advance by the declared length, before trimming.
+
+      while (intLength > 1 && der[start] == 0x00.toByte()) {
+        start++
+        intLength--
+      }
+      if (intLength > 32) return null
+
+      System.arraycopy(der, start, out, half * 32 + (32 - intLength), intLength)
+    }
+    return out
+  }
+
+  // --- Encrypted store -----------------------------------------------------
+
+  private fun storeKey(): SecretKey {
+    (keyStore.getEntry(STORE_KEY_ALIAS, null) as? KeyStore.SecretKeyEntry)?.let {
+      return it.secretKey
+    }
+
+    val generator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, KEYSTORE)
+    generator.init(
+      KeyGenParameterSpec.Builder(
+        STORE_KEY_ALIAS,
+        KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT,
+      )
+        .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+        .setKeySize(256)
+        .build(),
+    )
+    return generator.generateKey()
+  }
+
+  /** On-disk layout is `nonce(12) || ciphertext || tag(16)`. */
+  private fun seal(plaintext: ByteArray): ByteArray {
+    val cipher = Cipher.getInstance("AES/GCM/NoPadding")
+    cipher.init(Cipher.ENCRYPT_MODE, storeKey())
+    val sealed = cipher.doFinal(plaintext)
+    return cipher.iv + sealed
+  }
+
+  private fun open(sealed: ByteArray): ByteArray? = try {
+    if (sealed.size <= NONCE_LENGTH) {
+      null
+    } else {
+      val cipher = Cipher.getInstance("AES/GCM/NoPadding")
+      cipher.init(
+        Cipher.DECRYPT_MODE,
+        storeKey(),
+        GCMParameterSpec(TAG_BITS, sealed, 0, NONCE_LENGTH),
+      )
+      cipher.doFinal(sealed, NONCE_LENGTH, sealed.size - NONCE_LENGTH)
+    }
+  } catch (corrupt: Exception) {
+    null
+  }
+
+  /** clientSessionId is client-supplied; keep it out of the path. */
+  private fun fileFor(clientSessionId: String): File {
+    val safeName = Base64.encodeToString(
+      clientSessionId.toByteArray(Charsets.UTF_8),
+      Base64.NO_WRAP or Base64.URL_SAFE or Base64.NO_PADDING,
+    )
+    return File(storeDirectory, safeName + SESSION_EXTENSION)
+  }
+
+  override fun saveSession(clientSessionId: String, sessionJson: String, promise: Promise) {
+    try {
+      fileFor(clientSessionId).writeBytes(seal(sessionJson.toByteArray(Charsets.UTF_8)))
+      promise.resolve(null)
+    } catch (error: Exception) {
+      promise.reject("store_failed", "Could not persist the capture.", error)
+    }
+  }
+
+  override fun loadPendingSessions(promise: Promise) {
+    try {
+      val sessions = com.facebook.react.bridge.Arguments.createArray()
+      storeDirectory.listFiles()
+        ?.filter { it.name.endsWith(SESSION_EXTENSION) }
+        ?.forEach { file ->
+          // A file that will not open is corrupt or was written under a key
+          // that no longer exists. Skip it rather than failing the whole
+          // drain — the sessions that can still sync are evidence too.
+          val plaintext = open(file.readBytes()) ?: return@forEach
+          sessions.pushString(String(plaintext, Charsets.UTF_8))
+        }
+      promise.resolve(sessions)
+    } catch (error: Exception) {
+      promise.reject("store_failed", "Could not read pending captures.", error)
+    }
+  }
+
+  override fun removeSession(clientSessionId: String, promise: Promise) {
+    fileFor(clientSessionId).delete()
+    promise.resolve(null)
+  }
+
+  override fun removeAllSessions(promise: Promise) {
+    storeDirectory.listFiles()
+      ?.filter { it.name.endsWith(SESSION_EXTENSION) }
+      ?.forEach { it.delete() }
+    promise.resolve(null)
+  }
+}

package/android/src/main/java/ai/dpdpguard/offline/DpdpGuardOfflinePackage.kt

@@ -0,0 +1,33 @@
+package ai.dpdpguard.offline
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+/** Autolinked entry point for [DpdpGuardOfflineModule]. */
+class DpdpGuardOfflinePackage : BaseReactPackage() {
+
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? = if (name == DpdpGuardOfflineModule.NAME) {
+    DpdpGuardOfflineModule(reactContext)
+  } else {
+    null
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
+    mapOf(
+      DpdpGuardOfflineModule.NAME to ReactModuleInfo(
+        DpdpGuardOfflineModule.NAME,
+        DpdpGuardOfflineModule.NAME,
+        false, // canOverrideExistingModule
+        false, // needsEagerInit
+        false, // isCxxModule
+        true, // isTurboModule
+      ),
+    )
+  }
+}

package/ios/DpdpGuardOffline.h

@@ -0,0 +1,18 @@
+#import <DpdpGuardOfflineSpec/DpdpGuardOfflineSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Secure-element key storage, ECDSA P-256 signing, and an encrypted local
+ * queue for offline consent capture
+ * (docs/specs/offline-consent-capture.md §4).
+ *
+ * Deliberately narrow: this module never builds the `dpdpcca/2` canonical
+ * string. That lives in JavaScript (src/offline/captureArtifact.ts), tested
+ * against the contract's golden vectors, so there is exactly one
+ * implementation of the bytes a signature commits to.
+ */
+@interface DpdpGuardOffline : NSObject <NativeDpdpGuardOfflineSpec>
+@end
+
+NS_ASSUME_NONNULL_END