ping-openmls-sdk-react-native-macos 0.7.5 → 0.7.7

package/ios/Generated.swift

@@ -2953,6 +2953,91 @@ public func FfiConverterTypeMessageEnvelope_lower(_ value: MessageEnvelope) -> R
     return FfiConverterTypeMessageEnvelope.lower(value)
 }
 
+public struct RecoveryBackupView {
+    public var v: UInt8
+    public var accountId: Data
+    public var identityExport: Data
+    public var deviceGroupSnapshot: Data
+    public var createdAtMs: UInt64
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(v: UInt8, accountId: Data, identityExport: Data, deviceGroupSnapshot: Data, createdAtMs: UInt64) {
+        self.v = v
+        self.accountId = accountId
+        self.identityExport = identityExport
+        self.deviceGroupSnapshot = deviceGroupSnapshot
+        self.createdAtMs = createdAtMs
+    }
+}
+
+extension RecoveryBackupView: Equatable, Hashable {
+    public static func == (lhs: RecoveryBackupView, rhs: RecoveryBackupView) -> Bool {
+        if lhs.v != rhs.v {
+            return false
+        }
+        if lhs.accountId != rhs.accountId {
+            return false
+        }
+        if lhs.identityExport != rhs.identityExport {
+            return false
+        }
+        if lhs.deviceGroupSnapshot != rhs.deviceGroupSnapshot {
+            return false
+        }
+        if lhs.createdAtMs != rhs.createdAtMs {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(v)
+        hasher.combine(accountId)
+        hasher.combine(identityExport)
+        hasher.combine(deviceGroupSnapshot)
+        hasher.combine(createdAtMs)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeRecoveryBackupView: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RecoveryBackupView {
+        return
+            try RecoveryBackupView(
+                v: FfiConverterUInt8.read(from: &buf),
+                accountId: FfiConverterData.read(from: &buf),
+                identityExport: FfiConverterData.read(from: &buf),
+                deviceGroupSnapshot: FfiConverterData.read(from: &buf),
+                createdAtMs: FfiConverterUInt64.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: RecoveryBackupView, into buf: inout [UInt8]) {
+        FfiConverterUInt8.write(value.v, into: &buf)
+        FfiConverterData.write(value.accountId, into: &buf)
+        FfiConverterData.write(value.identityExport, into: &buf)
+        FfiConverterData.write(value.deviceGroupSnapshot, into: &buf)
+        FfiConverterUInt64.write(value.createdAtMs, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRecoveryBackupView_lift(_ buf: RustBuffer) throws -> RecoveryBackupView {
+    return try FfiConverterTypeRecoveryBackupView.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeRecoveryBackupView_lower(_ value: RecoveryBackupView) -> RustBuffer {
+    return FfiConverterTypeRecoveryBackupView.lower(value)
+}
+
 public struct UserId {
     public var value: Data
 
@@ -3736,12 +3821,47 @@ public func decodeCatchupSnapshot(snapshotBytes: Data) throws -> CatchupSnapshot
     })
 }
 
+public func decryptBackup(blob: Data, mnemonicPhrase: String) throws -> RecoveryBackupView {
+    return try FfiConverterTypeRecoveryBackupView.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_decrypt_backup(
+            FfiConverterData.lower(blob),
+            FfiConverterString.lower(mnemonicPhrase), $0
+        )
+    })
+}
+
+public func encryptBackup(mnemonicPhrase: String, accountId: Data, identityExport: Data, deviceGroupSnapshot: Data, createdAtMs: UInt64) throws -> Data {
+    return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_encrypt_backup(
+            FfiConverterString.lower(mnemonicPhrase),
+            FfiConverterData.lower(accountId),
+            FfiConverterData.lower(identityExport),
+            FfiConverterData.lower(deviceGroupSnapshot),
+            FfiConverterUInt64.lower(createdAtMs), $0
+        )
+    })
+}
+
 public func generateIdentityExport() -> Data {
     return try! FfiConverterData.lift(try! rustCall {
         uniffi_ping_ffi_fn_func_generate_identity_export($0)
     })
 }
 
+public func generateMnemonicPhrase() throws -> String {
+    return try FfiConverterString.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_generate_mnemonic_phrase($0)
+    })
+}
+
+public func normalizeMnemonicPhrase(phrase: String) throws -> String {
+    return try FfiConverterString.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_normalize_mnemonic_phrase(
+            FfiConverterString.lower(phrase), $0
+        )
+    })
+}
+
 public func openLinkingTicket(sealed: Data, newDevicePriv: Data) throws -> LinkingTicket {
     return try FfiConverterTypeLinkingTicket.lift(rustCallWithError(FfiConverterTypePingError.lift) {
         uniffi_ping_ffi_fn_func_open_linking_ticket(
@@ -3779,9 +3899,21 @@ private var initializationResult: InitializationResult = {
     if uniffi_ping_ffi_checksum_func_decode_catchup_snapshot() != 40316 {
         return InitializationResult.apiChecksumMismatch
     }
+    if uniffi_ping_ffi_checksum_func_decrypt_backup() != 58907 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_func_encrypt_backup() != 7671 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_func_generate_identity_export() != 15026 {
         return InitializationResult.apiChecksumMismatch
     }
+    if uniffi_ping_ffi_checksum_func_generate_mnemonic_phrase() != 9754 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_func_normalize_mnemonic_phrase() != 55353 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_func_open_linking_ticket() != 64091 {
         return InitializationResult.apiChecksumMismatch
     }

package/ios/PingNativeModule.m

@@ -146,6 +146,15 @@ RCT_EXTERN_METHOD(consumeLinkingTicket: (NSDictionary *)ticket
                   resolver: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 
+// [CR-3] HPKE-open a sealed LinkingTicket on the new device. Free
+// function (not on the client instance) — the new device is pre-init
+// and doesn't have a MessagingClient yet at the time of the open call.
+// Returns the same dict shape `consumeLinkingTicket` accepts as input.
+RCT_EXTERN_METHOD(openLinkingTicket: (NSArray *)sealed
+                  newDevicePriv: (NSArray *)newDevicePriv
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(revokeDevice: (NSArray *)deviceId
                   nowMs: (double)nowMs
                   resolver: (RCTPromiseResolveBlock)resolve

package/ios/PingNativeModule.swift

@@ -684,6 +684,31 @@ public final class PingNative: RCTEventEmitter {
         }
     }
 
+    /// HPKE-open a sealed `LinkingTicket` on the new device ([CR-3]).
+    /// Free function (not on `client`) — the new device is pre-init and
+    /// doesn't have a `MessagingClient` yet when the open happens. Mirrors
+    /// the wasm SDK's `MessagingClient.openLinkingTicket(sealed, priv)`
+    /// static so the desktop link host can decode the ticket before
+    /// calling `init` + `consumeLinkingTicket`.
+    @objc(openLinkingTicket:newDevicePriv:resolver:rejecter:)
+    public func openLinkingTicketNative(
+        _ sealedBytes: NSArray,
+        newDevicePriv newDevicePrivBytes: NSArray,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        do {
+            let sealed = try TypeBridge.decodeBytesOrThrow(sealedBytes, field: "sealed")
+            let priv = try TypeBridge.decodeBytesOrThrow(newDevicePrivBytes, field: "newDevicePriv")
+            // `open_linking_ticket` is a UniFFI top-level free function;
+            // Swift exposes it camelCased.
+            let ticket = try openLinkingTicket(sealed: sealed, newDevicePriv: priv)
+            resolve(TypeBridge.encodeLinkingTicket(ticket))
+        } catch {
+            reject("OpenLinkingFailed", 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

@@ -552,10 +552,31 @@ uint64_t uniffi_ping_ffi_fn_method_transport_send(void*_Nonnull ptr, RustBuffer
 RustBuffer uniffi_ping_ffi_fn_func_decode_catchup_snapshot(RustBuffer snapshot_bytes, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_DECRYPT_BACKUP
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_DECRYPT_BACKUP
+RustBuffer uniffi_ping_ffi_fn_func_decrypt_backup(RustBuffer blob, RustBuffer mnemonic_phrase, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_ENCRYPT_BACKUP
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_ENCRYPT_BACKUP
+RustBuffer uniffi_ping_ffi_fn_func_encrypt_backup(RustBuffer mnemonic_phrase, RustBuffer account_id, RustBuffer identity_export, RustBuffer device_group_snapshot, uint64_t created_at_ms, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_GENERATE_IDENTITY_EXPORT
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_GENERATE_IDENTITY_EXPORT
 RustBuffer uniffi_ping_ffi_fn_func_generate_identity_export(RustCallStatus *_Nonnull out_status
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_GENERATE_MNEMONIC_PHRASE
+#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_NORMALIZE_MNEMONIC_PHRASE
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_NORMALIZE_MNEMONIC_PHRASE
+RustBuffer uniffi_ping_ffi_fn_func_normalize_mnemonic_phrase(RustBuffer phrase, RustCallStatus *_Nonnull out_status
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_FN_FUNC_OPEN_LINKING_TICKET
@@ -852,12 +873,36 @@ void ffi_ping_ffi_rust_future_complete_void(uint64_t handle, RustCallStatus *_No
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_DECODE_CATCHUP_SNAPSHOT
 uint16_t uniffi_ping_ffi_checksum_func_decode_catchup_snapshot(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_DECRYPT_BACKUP
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_DECRYPT_BACKUP
+uint16_t uniffi_ping_ffi_checksum_func_decrypt_backup(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_ENCRYPT_BACKUP
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_ENCRYPT_BACKUP
+uint16_t uniffi_ping_ffi_checksum_func_encrypt_backup(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_GENERATE_IDENTITY_EXPORT
 #define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_GENERATE_IDENTITY_EXPORT
 uint16_t uniffi_ping_ffi_checksum_func_generate_identity_export(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_GENERATE_MNEMONIC_PHRASE
+#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_NORMALIZE_MNEMONIC_PHRASE
+#define UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_NORMALIZE_MNEMONIC_PHRASE
+uint16_t uniffi_ping_ffi_checksum_func_normalize_mnemonic_phrase(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_PING_FFI_CHECKSUM_FUNC_OPEN_LINKING_TICKET

package/package.json

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

@@ -373,6 +373,33 @@ export class MessagingClient {
     await NativePing.consumeLinkingTicket(encodeLinkingTicket(ticket), Date.now());
   }
 
+  /**
+   * [CR-3] HPKE-open a sealed linking ticket on the new device. Static —
+   * the new device hasn't initialised a `MessagingClient` yet at the
+   * time of the open call (it does `openLinkingTicket` first to extract
+   * the auth-layer fields, hands them to `/v1/auth/link-verify` to
+   * mint tokens, THEN `init`s and `consumeLinkingTicket`s).
+   *
+   * Mirrors the wasm SDK's `MessagingClient.openLinkingTicket` so the
+   * desktop link host can share code shape with the web link host.
+   *
+   * @param sealed - HPKE-sealed bytes from `getLinkingTicket(ticketId)`
+   *                 (the BE relays exactly what the existing device
+   *                 `sealLinkingTicket`'d).
+   * @param newDevicePriv - 32-byte X25519 private key the new device
+   *                        generated for this pairing session.
+   */
+  static async openLinkingTicket(
+    sealed: Uint8Array,
+    newDevicePriv: Uint8Array,
+  ): Promise<LinkingTicket> {
+    const raw = await NativePing.openLinkingTicket(
+      Array.from(sealed),
+      Array.from(newDevicePriv),
+    );
+    return decodeLinkingTicket(raw);
+  }
+
   /**
    * 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

@@ -200,6 +200,19 @@ export interface Spec extends TurboModule {
     nowMs: number,
   ): Promise<null>;
 
+  /**
+   * [CR-3] HPKE-open a sealed linking ticket on the new device. Free
+   * function — runs BEFORE `initClient` so the host can decode the
+   * ticket fields (`user_pubkey`, `new_device_id`, `device_binding_sig`)
+   * and submit them to the auth layer's `/v1/auth/link-verify` before
+   * spinning up the messaging client. Returns the same dict shape
+   * `consumeLinkingTicket` accepts.
+   */
+  openLinkingTicket(
+    sealed: number[],
+    newDevicePriv: number[],
+  ): Promise<Record<string, unknown>>;
+
   /**
    * 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