ping-openmls-sdk-react-native-macos 0.7.12 → 0.7.14

package/ios/Generated.swift

@@ -4152,6 +4152,26 @@ public func generateMnemonicPhrase() throws -> String {
     })
 }
 
+public func hpkeOpen(sealed: Data, recipientPriv: Data, info: Data) throws -> Data {
+    return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_hpke_open(
+            FfiConverterData.lower(sealed),
+            FfiConverterData.lower(recipientPriv),
+            FfiConverterData.lower(info), $0
+        )
+    })
+}
+
+public func hpkeSeal(plaintext: Data, recipientPub: Data, info: Data) throws -> Data {
+    return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_hpke_seal(
+            FfiConverterData.lower(plaintext),
+            FfiConverterData.lower(recipientPub),
+            FfiConverterData.lower(info), $0
+        )
+    })
+}
+
 public func normalizeMnemonicPhrase(phrase: String) throws -> String {
     return try FfiConverterString.lift(rustCallWithError(FfiConverterTypePingError.lift) {
         uniffi_ping_ffi_fn_func_normalize_mnemonic_phrase(
@@ -4229,6 +4249,12 @@ private var initializationResult: InitializationResult = {
     if uniffi_ping_ffi_checksum_func_generate_mnemonic_phrase() != 9754 {
         return InitializationResult.apiChecksumMismatch
     }
+    if uniffi_ping_ffi_checksum_func_hpke_open() != 21701 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_func_hpke_seal() != 7740 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_func_normalize_mnemonic_phrase() != 55353 {
         return InitializationResult.apiChecksumMismatch
     }

package/ios/PingNativeModule.m

@@ -155,6 +155,21 @@ RCT_EXTERN_METHOD(openLinkingTicket: (NSArray *)sealed
                   resolver: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 
+// Generic HPKE-Base seal/open of arbitrary bytes under a caller-supplied `info`.
+// Free functions — one shared HPKE for app-layer envelopes (device-linking auth
+// envelope) so platforms stop hand-rolling HPKE that drifts cross-platform.
+RCT_EXTERN_METHOD(hpkeSeal: (NSArray *)plaintext
+                  recipientPub: (NSArray *)recipientPub
+                  info: (NSArray *)info
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(hpkeOpen: (NSArray *)sealed
+                  recipientPriv: (NSArray *)recipientPriv
+                  info: (NSArray *)info
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(revokeDevice: (NSArray *)deviceId
                   nowMs: (double)nowMs
                   resolver: (RCTPromiseResolveBlock)resolve

package/ios/PingNativeModule.swift

@@ -709,6 +709,48 @@ public final class PingNative: RCTEventEmitter {
         }
     }
 
+    /// Generic HPKE-Base seal of arbitrary bytes ([CR-3] auth-envelope sharing).
+    /// Free function — like `openLinkingTicket`, no `client` needed. One shared
+    /// HPKE so the desktop link host stops hand-rolling HPKE that drifts.
+    @objc(hpkeSeal:recipientPub:info:resolver:rejecter:)
+    public func hpkeSealNative(
+        _ plaintextBytes: NSArray,
+        recipientPub recipientPubBytes: NSArray,
+        info infoBytes: NSArray,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            let plaintext = try TypeBridge.decodeBytesOrThrow(plaintextBytes, field: "plaintext")
+            let pub = try TypeBridge.decodeBytesOrThrow(recipientPubBytes, field: "recipientPub")
+            let info = try TypeBridge.decodeBytesOrThrow(infoBytes, field: "info")
+            let out = try hpkeSeal(plaintext: plaintext, recipientPub: pub, info: info)
+            resolve(TypeBridge.encodeBytes(out))
+        } catch {
+            reject("HpkeSealFailed", String(describing: error), error)
+        }
+    }
+
+    /// Generic HPKE-Base open — inverse of `hpkeSeal`.
+    @objc(hpkeOpen:recipientPriv:info:resolver:rejecter:)
+    public func hpkeOpenNative(
+        _ sealedBytes: NSArray,
+        recipientPriv recipientPrivBytes: NSArray,
+        info infoBytes: NSArray,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            let sealed = try TypeBridge.decodeBytesOrThrow(sealedBytes, field: "sealed")
+            let priv = try TypeBridge.decodeBytesOrThrow(recipientPrivBytes, field: "recipientPriv")
+            let info = try TypeBridge.decodeBytesOrThrow(infoBytes, field: "info")
+            let out = try hpkeOpen(sealed: sealed, recipientPriv: priv, info: info)
+            resolve(TypeBridge.encodeBytes(out))
+        } catch {
+            reject("HpkeOpenFailed", String(describing: error), error)
+        }
+    }
+
     /// Revoke a device ([CR-2]). Returns the array of Commit envelopes the SDK
     /// produced — one per conversation the device was a locally-known leaf in.
     /// Empty array means the device wasn't locally known (scope limit per CR-2).

package/ios/pingFFI.h

@@ -572,6 +572,16 @@ RustBuffer uniffi_ping_ffi_fn_func_generate_identity_export(RustCallStatus *_Non
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_GENERATE_MNEMONIC_PHRASE
 RustBuffer uniffi_ping_ffi_fn_func_generate_mnemonic_phrase(RustCallStatus *_Nonnull out_status
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_HPKE_OPEN
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_HPKE_OPEN
+RustBuffer uniffi_ping_ffi_fn_func_hpke_open(RustBuffer sealed, RustBuffer recipient_priv, RustBuffer info, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_HPKE_SEAL
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_HPKE_SEAL
+RustBuffer uniffi_ping_ffi_fn_func_hpke_seal(RustBuffer plaintext, RustBuffer recipient_pub, RustBuffer info, RustCallStatus *_Nonnull out_status
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_NORMALIZE_MNEMONIC_PHRASE
@@ -907,6 +917,18 @@ uint16_t uniffi_ping_ffi_checksum_func_generate_identity_export(void
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_GENERATE_MNEMONIC_PHRASE
 uint16_t uniffi_ping_ffi_checksum_func_generate_mnemonic_phrase(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_HPKE_OPEN
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_HPKE_OPEN
+uint16_t uniffi_ping_ffi_checksum_func_hpke_open(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_HPKE_SEAL
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_HPKE_SEAL
+uint16_t uniffi_ping_ffi_checksum_func_hpke_seal(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_NORMALIZE_MNEMONIC_PHRASE

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ping-openmls-sdk-react-native-macos",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "description": "Real MLS for React Native macOS apps — wraps the ping-openmls-sdk Rust core via UniFFI.",
   "homepage": "https://github.com/AMP-Media-Development/ping-openmls-sdk",
   "license": "Apache-2.0",

package/src/MessagingClient.ts

@@ -400,6 +400,40 @@ export class MessagingClient {
     return decodeLinkingTicket(raw);
   }
 
+  /**
+   * Generic HPKE-Base seal of `plaintext` to `recipientPub` (32-byte X25519)
+   * under `info`. One shared HPKE implementation so app layers (e.g. the
+   * device-linking auth envelope) stop hand-rolling per-platform HPKE that
+   * drifts and breaks cross-platform. Mirrors the wasm SDK's
+   * `MessagingClient.hpkeSeal`.
+   */
+  static async hpkeSeal(
+    plaintext: Uint8Array,
+    recipientPub: Uint8Array,
+    info: Uint8Array,
+  ): Promise<Uint8Array> {
+    const out = await NativePing.hpkeSeal(
+      Array.from(plaintext),
+      Array.from(recipientPub),
+      Array.from(info),
+    );
+    return Uint8Array.from(out);
+  }
+
+  /** Generic HPKE-Base open — inverse of {@link hpkeSeal}. `info` must match the sender. */
+  static async hpkeOpen(
+    sealed: Uint8Array,
+    recipientPriv: Uint8Array,
+    info: Uint8Array,
+  ): Promise<Uint8Array> {
+    const out = await NativePing.hpkeOpen(
+      Array.from(sealed),
+      Array.from(recipientPriv),
+      Array.from(info),
+    );
+    return Uint8Array.from(out);
+  }
+
   /**
    * Admit a freshly-linked device to every chat in `entries` — one Commit +
    * Welcome per chat, with per-chat outcomes. Host calls this AFTER

package/src/NativePing.ts

@@ -213,6 +213,15 @@ export interface Spec extends TurboModule {
     newDevicePriv: number[],
   ): Promise<Record<string, unknown>>;
 
+  /**
+   * Generic HPKE-Base seal/open of arbitrary bytes under a caller-supplied
+   * `info`. One shared HPKE for app-layer envelopes (e.g. device-linking auth
+   * envelope) so platforms stop hand-rolling HPKE that drifts cross-platform.
+   * `recipientPub`/`recipientPriv` are 32-byte X25519 keys.
+   */
+  hpkeSeal(plaintext: number[], recipientPub: number[], info: number[]): Promise<number[]>;
+  hpkeOpen(sealed: number[], recipientPriv: number[], info: number[]): Promise<number[]>;
+
   /**
    * Revoke a device ([CR-2]). Returns one Commit envelope per conversation the
    * device was a locally-known leaf in. Empty array means the device wasn't locally