ping-openmls-sdk-react-native-macos 0.7.13 → 0.7.15

package/ios/Generated.swift

@@ -752,6 +752,8 @@ public protocol MessagingClientProtocol: AnyObject {
 
     func listDevices() -> [DeviceInfo]
 
+    func members(conversationId: ConversationId) -> [MemberInfo]
+
     func processEnvelope(envelope: MessageEnvelope, nowMs: UInt64) async throws -> IncomingMessage?
 
     func removeMembers(conversationId: ConversationId, leafIndexes: [UInt32], nowMs: UInt64) async throws
@@ -998,6 +1000,13 @@ open class MessagingClient:
         })
     }
 
+    open func members(conversationId: ConversationId) -> [MemberInfo] {
+        return try! FfiConverterSequenceTypeMemberInfo.lift(try! rustCall {
+            uniffi_ping_ffi_fn_method_messagingclient_members(self.uniffiClonePointer(),
+                                                              FfiConverterTypeConversationId.lower(conversationId), $0)
+        })
+    }
+
     open func processEnvelope(envelope: MessageEnvelope, nowMs: UInt64) async throws -> IncomingMessage? {
         return
             try await uniffiRustCallAsync(
@@ -3014,6 +3023,67 @@ public func FfiConverterTypeLinkingTicket_lower(_ value: LinkingTicket) -> RustB
     return FfiConverterTypeLinkingTicket.lower(value)
 }
 
+public struct MemberInfo {
+    public var userId: UserId
+    public var leafIndex: UInt32
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(userId: UserId, leafIndex: UInt32) {
+        self.userId = userId
+        self.leafIndex = leafIndex
+    }
+}
+
+extension MemberInfo: Equatable, Hashable {
+    public static func == (lhs: MemberInfo, rhs: MemberInfo) -> Bool {
+        if lhs.userId != rhs.userId {
+            return false
+        }
+        if lhs.leafIndex != rhs.leafIndex {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(userId)
+        hasher.combine(leafIndex)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeMemberInfo: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MemberInfo {
+        return
+            try MemberInfo(
+                userId: FfiConverterTypeUserId.read(from: &buf),
+                leafIndex: FfiConverterUInt32.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: MemberInfo, into buf: inout [UInt8]) {
+        FfiConverterTypeUserId.write(value.userId, into: &buf)
+        FfiConverterUInt32.write(value.leafIndex, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMemberInfo_lift(_ buf: RustBuffer) throws -> MemberInfo {
+    return try FfiConverterTypeMemberInfo.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeMemberInfo_lower(_ value: MemberInfo) -> RustBuffer {
+    return FfiConverterTypeMemberInfo.lower(value)
+}
+
 public struct MessageEnvelope {
     public var v: UInt8
     public var conversationId: ConversationId
@@ -3947,6 +4017,31 @@ private struct FfiConverterSequenceTypeKeyPackageEntry: FfiConverterRustBuffer {
     }
 }
 
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceTypeMemberInfo: FfiConverterRustBuffer {
+    typealias SwiftType = [MemberInfo]
+
+    static func write(_ value: [MemberInfo], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeMemberInfo.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [MemberInfo] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [MemberInfo]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterTypeMemberInfo.read(from: &buf))
+        }
+        return seq
+    }
+}
+
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
@@ -4318,6 +4413,9 @@ private var initializationResult: InitializationResult = {
     if uniffi_ping_ffi_checksum_method_messagingclient_list_devices() != 10141 {
         return InitializationResult.apiChecksumMismatch
     }
+    if uniffi_ping_ffi_checksum_method_messagingclient_members() != 51351 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_method_messagingclient_process_envelope() != 11247 {
         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

@@ -447,6 +447,11 @@ RustBuffer uniffi_ping_ffi_fn_method_messagingclient_list_conversations(void*_No
 RustBuffer uniffi_ping_ffi_fn_method_messagingclient_list_devices(void*_Nonnull ptr, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_METHOD_MESSAGINGCLIENT_MEMBERS
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_METHOD_MESSAGINGCLIENT_MEMBERS
+RustBuffer uniffi_ping_ffi_fn_method_messagingclient_members(void*_Nonnull ptr, RustBuffer conversation_id, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_METHOD_MESSAGINGCLIENT_PROCESS_ENVELOPE
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_METHOD_MESSAGINGCLIENT_PROCESS_ENVELOPE
 uint64_t uniffi_ping_ffi_fn_method_messagingclient_process_envelope(void*_Nonnull ptr, RustBuffer envelope, uint64_t now_ms
@@ -1055,6 +1060,12 @@ uint16_t uniffi_ping_ffi_checksum_method_messagingclient_list_conversations(void
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_METHOD_MESSAGINGCLIENT_LIST_DEVICES
 uint16_t uniffi_ping_ffi_checksum_method_messagingclient_list_devices(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_METHOD_MESSAGINGCLIENT_MEMBERS
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_METHOD_MESSAGINGCLIENT_MEMBERS
+uint16_t uniffi_ping_ffi_checksum_method_messagingclient_members(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_METHOD_MESSAGINGCLIENT_PROCESS_ENVELOPE

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ping-openmls-sdk-react-native-macos",
-  "version": "0.7.13",
+  "version": "0.7.15",
   "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