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

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/package.json

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