ping-openmls-sdk-react-native-macos 0.2.3 → 0.6.0

package/ios/Generated.swift

@@ -724,9 +724,9 @@ public func FfiConverterTypeMessageObserver_lower(_ value: MessageObserver) -> U
 }
 
 public protocol MessagingClientProtocol: AnyObject {
-    func addMembers(conversationId: ConversationId, keyPackages: [Data], nowMs: UInt64) async throws
+    func addMembers(conversationId: ConversationId, entries: [KeyPackageEntry], nowMs: UInt64) async throws
 
-    func buildLinkingTicket(newDeviceId: DeviceId, newDeviceKp: Data, nowMs: UInt64) async throws -> LinkingTicket
+    func buildLinkingTicket(newDeviceId: DeviceId, newDeviceKp: Data, lastAppEvents: [CatchupAppEvent], nowMs: UInt64) async throws -> LinkingTicket
 
     func consumeLinkingTicket(ticket: LinkingTicket, nowMs: UInt64) async throws
 
@@ -736,8 +736,14 @@ public protocol MessagingClientProtocol: AnyObject {
 
     func deviceInfo(nowMs: UInt64) -> DeviceInfo
 
+    func exportConversationSecret(conversationId: ConversationId, label: String, context: Data, length: UInt32) throws -> Data
+
+    func exportConversationStateSnapshot(conversationId: ConversationId, nowMs: UInt64) throws -> Data
+
     func freshKeyPackage() throws -> Data
 
+    func importStateSnapshot(snapshotBytes: Data, nowMs: UInt64) async throws -> ConversationId
+
     func joinConversation(welcome: MessageEnvelope, nowMs: UInt64) async throws -> ConversationId
 
     func listConversations() -> [ConversationMeta]
@@ -748,7 +754,7 @@ public protocol MessagingClientProtocol: AnyObject {
 
     func removeMembers(conversationId: ConversationId, leafIndexes: [UInt32], nowMs: UInt64) async throws
 
-    func revokeDevice(deviceId: DeviceId, nowMs: UInt64) async throws
+    func revokeDevice(deviceId: DeviceId, nowMs: UInt64) async throws -> [MessageEnvelope]
 
     func send(conversationId: ConversationId, plaintext: Data, nowMs: UInt64) async throws -> MessageEnvelope
 
@@ -808,11 +814,11 @@ open class MessagingClient:
         try! rustCall { uniffi_ping_ffi_fn_free_messagingclient(pointer, $0) }
     }
 
-    public static func `init`(identityExport: Data, deviceLabel: String, storage: Storage, transport: Transport, nowMs: UInt64) async throws -> MessagingClient {
+    public static func `init`(identityExport: Data, deviceLabel: String, storage: Storage, transport: Transport, nowMs: UInt64, sqlitePath: String?, sqliteEncryptionKey: Data?, deviceSigningSecretKey: Data?) async throws -> MessagingClient {
         return
             try await uniffiRustCallAsync(
                 rustFutureFunc: {
-                    uniffi_ping_ffi_fn_constructor_messagingclient_init(FfiConverterData.lower(identityExport), FfiConverterString.lower(deviceLabel), FfiConverterTypeStorage.lower(storage), FfiConverterTypeTransport.lower(transport), FfiConverterUInt64.lower(nowMs))
+                    uniffi_ping_ffi_fn_constructor_messagingclient_init(FfiConverterData.lower(identityExport), FfiConverterString.lower(deviceLabel), FfiConverterTypeStorage.lower(storage), FfiConverterTypeTransport.lower(transport), FfiConverterUInt64.lower(nowMs), FfiConverterOptionString.lower(sqlitePath), FfiConverterOptionData.lower(sqliteEncryptionKey), FfiConverterOptionData.lower(deviceSigningSecretKey))
                 },
                 pollFunc: ffi_ping_ffi_rust_future_poll_pointer,
                 completeFunc: ffi_ping_ffi_rust_future_complete_pointer,
@@ -822,13 +828,13 @@ open class MessagingClient:
             )
     }
 
-    open func addMembers(conversationId: ConversationId, keyPackages: [Data], nowMs: UInt64) async throws {
+    open func addMembers(conversationId: ConversationId, entries: [KeyPackageEntry], nowMs: UInt64) async throws {
         return
             try await uniffiRustCallAsync(
                 rustFutureFunc: {
                     uniffi_ping_ffi_fn_method_messagingclient_add_members(
                         self.uniffiClonePointer(),
-                        FfiConverterTypeConversationId.lower(conversationId), FfiConverterSequenceData.lower(keyPackages), FfiConverterUInt64.lower(nowMs)
+                        FfiConverterTypeConversationId.lower(conversationId), FfiConverterSequenceTypeKeyPackageEntry.lower(entries), FfiConverterUInt64.lower(nowMs)
                     )
                 },
                 pollFunc: ffi_ping_ffi_rust_future_poll_void,
@@ -839,13 +845,13 @@ open class MessagingClient:
             )
     }
 
-    open func buildLinkingTicket(newDeviceId: DeviceId, newDeviceKp: Data, nowMs: UInt64) async throws -> LinkingTicket {
+    open func buildLinkingTicket(newDeviceId: DeviceId, newDeviceKp: Data, lastAppEvents: [CatchupAppEvent], nowMs: UInt64) async throws -> LinkingTicket {
         return
             try await uniffiRustCallAsync(
                 rustFutureFunc: {
                     uniffi_ping_ffi_fn_method_messagingclient_build_linking_ticket(
                         self.uniffiClonePointer(),
-                        FfiConverterTypeDeviceId.lower(newDeviceId), FfiConverterData.lower(newDeviceKp), FfiConverterUInt64.lower(nowMs)
+                        FfiConverterTypeDeviceId.lower(newDeviceId), FfiConverterData.lower(newDeviceKp), FfiConverterSequenceTypeCatchupAppEvent.lower(lastAppEvents), FfiConverterUInt64.lower(nowMs)
                     )
                 },
                 pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
@@ -903,12 +909,47 @@ open class MessagingClient:
         })
     }
 
+    open func exportConversationSecret(conversationId: ConversationId, label: String, context: Data, length: UInt32) throws -> Data {
+        return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+            uniffi_ping_ffi_fn_method_messagingclient_export_conversation_secret(self.uniffiClonePointer(),
+                                                                                 FfiConverterTypeConversationId.lower(conversationId),
+                                                                                 FfiConverterString.lower(label),
+                                                                                 FfiConverterData.lower(context),
+                                                                                 FfiConverterUInt32.lower(length), $0)
+        })
+    }
+
+    open func exportConversationStateSnapshot(conversationId: ConversationId, nowMs: UInt64) throws -> Data {
+        return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+            uniffi_ping_ffi_fn_method_messagingclient_export_conversation_state_snapshot(self.uniffiClonePointer(),
+                                                                                         FfiConverterTypeConversationId.lower(conversationId),
+                                                                                         FfiConverterUInt64.lower(nowMs), $0)
+        })
+    }
+
     open func freshKeyPackage() throws -> Data {
         return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
             uniffi_ping_ffi_fn_method_messagingclient_fresh_key_package(self.uniffiClonePointer(), $0)
         })
     }
 
+    open func importStateSnapshot(snapshotBytes: Data, nowMs: UInt64) async throws -> ConversationId {
+        return
+            try await uniffiRustCallAsync(
+                rustFutureFunc: {
+                    uniffi_ping_ffi_fn_method_messagingclient_import_state_snapshot(
+                        self.uniffiClonePointer(),
+                        FfiConverterData.lower(snapshotBytes), FfiConverterUInt64.lower(nowMs)
+                    )
+                },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterTypeConversationId.lift,
+                errorHandler: FfiConverterTypePingError.lift
+            )
+    }
+
     open func joinConversation(welcome: MessageEnvelope, nowMs: UInt64) async throws -> ConversationId {
         return
             try await uniffiRustCallAsync(
@@ -972,7 +1013,7 @@ open class MessagingClient:
             )
     }
 
-    open func revokeDevice(deviceId: DeviceId, nowMs: UInt64) async throws {
+    open func revokeDevice(deviceId: DeviceId, nowMs: UInt64) async throws -> [MessageEnvelope] {
         return
             try await uniffiRustCallAsync(
                 rustFutureFunc: {
@@ -981,10 +1022,10 @@ open class MessagingClient:
                         FfiConverterTypeDeviceId.lower(deviceId), FfiConverterUInt64.lower(nowMs)
                     )
                 },
-                pollFunc: ffi_ping_ffi_rust_future_poll_void,
-                completeFunc: ffi_ping_ffi_rust_future_complete_void,
-                freeFunc: ffi_ping_ffi_rust_future_free_void,
-                liftFunc: { $0 },
+                pollFunc: ffi_ping_ffi_rust_future_poll_rust_buffer,
+                completeFunc: ffi_ping_ffi_rust_future_complete_rust_buffer,
+                freeFunc: ffi_ping_ffi_rust_future_free_rust_buffer,
+                liftFunc: FfiConverterSequenceTypeMessageEnvelope.lift,
                 errorHandler: FfiConverterTypePingError.lift
             )
     }
@@ -1770,6 +1811,205 @@ public func FfiConverterTypeTransport_lower(_ value: Transport) -> UnsafeMutable
     return FfiConverterTypeTransport.lower(value)
 }
 
+public struct CatchupAppEvent {
+    public var conversationId: ConversationId
+    public var appEventBytes: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(conversationId: ConversationId, appEventBytes: Data) {
+        self.conversationId = conversationId
+        self.appEventBytes = appEventBytes
+    }
+}
+
+extension CatchupAppEvent: Equatable, Hashable {
+    public static func == (lhs: CatchupAppEvent, rhs: CatchupAppEvent) -> Bool {
+        if lhs.conversationId != rhs.conversationId {
+            return false
+        }
+        if lhs.appEventBytes != rhs.appEventBytes {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(conversationId)
+        hasher.combine(appEventBytes)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeCatchupAppEvent: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CatchupAppEvent {
+        return
+            try CatchupAppEvent(
+                conversationId: FfiConverterTypeConversationId.read(from: &buf),
+                appEventBytes: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: CatchupAppEvent, into buf: inout [UInt8]) {
+        FfiConverterTypeConversationId.write(value.conversationId, into: &buf)
+        FfiConverterData.write(value.appEventBytes, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCatchupAppEvent_lift(_ buf: RustBuffer) throws -> CatchupAppEvent {
+    return try FfiConverterTypeCatchupAppEvent.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCatchupAppEvent_lower(_ value: CatchupAppEvent) -> RustBuffer {
+    return FfiConverterTypeCatchupAppEvent.lower(value)
+}
+
+public struct CatchupSnapshotEntry {
+    public var conversationId: ConversationId
+    public var meta: ConversationMeta
+    public var groupStateBytes: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(conversationId: ConversationId, meta: ConversationMeta, groupStateBytes: Data) {
+        self.conversationId = conversationId
+        self.meta = meta
+        self.groupStateBytes = groupStateBytes
+    }
+}
+
+extension CatchupSnapshotEntry: Equatable, Hashable {
+    public static func == (lhs: CatchupSnapshotEntry, rhs: CatchupSnapshotEntry) -> Bool {
+        if lhs.conversationId != rhs.conversationId {
+            return false
+        }
+        if lhs.meta != rhs.meta {
+            return false
+        }
+        if lhs.groupStateBytes != rhs.groupStateBytes {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(conversationId)
+        hasher.combine(meta)
+        hasher.combine(groupStateBytes)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeCatchupSnapshotEntry: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CatchupSnapshotEntry {
+        return
+            try CatchupSnapshotEntry(
+                conversationId: FfiConverterTypeConversationId.read(from: &buf),
+                meta: FfiConverterTypeConversationMeta.read(from: &buf),
+                groupStateBytes: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: CatchupSnapshotEntry, into buf: inout [UInt8]) {
+        FfiConverterTypeConversationId.write(value.conversationId, into: &buf)
+        FfiConverterTypeConversationMeta.write(value.meta, into: &buf)
+        FfiConverterData.write(value.groupStateBytes, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCatchupSnapshotEntry_lift(_ buf: RustBuffer) throws -> CatchupSnapshotEntry {
+    return try FfiConverterTypeCatchupSnapshotEntry.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCatchupSnapshotEntry_lower(_ value: CatchupSnapshotEntry) -> RustBuffer {
+    return FfiConverterTypeCatchupSnapshotEntry.lower(value)
+}
+
+public struct CatchupSnapshotView {
+    public var v: UInt8
+    public var conversationMetas: [CatchupSnapshotEntry]
+    public var lastAppEventsPerConv: [CatchupAppEvent]
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(v: UInt8, conversationMetas: [CatchupSnapshotEntry], lastAppEventsPerConv: [CatchupAppEvent]) {
+        self.v = v
+        self.conversationMetas = conversationMetas
+        self.lastAppEventsPerConv = lastAppEventsPerConv
+    }
+}
+
+extension CatchupSnapshotView: Equatable, Hashable {
+    public static func == (lhs: CatchupSnapshotView, rhs: CatchupSnapshotView) -> Bool {
+        if lhs.v != rhs.v {
+            return false
+        }
+        if lhs.conversationMetas != rhs.conversationMetas {
+            return false
+        }
+        if lhs.lastAppEventsPerConv != rhs.lastAppEventsPerConv {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(v)
+        hasher.combine(conversationMetas)
+        hasher.combine(lastAppEventsPerConv)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeCatchupSnapshotView: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CatchupSnapshotView {
+        return
+            try CatchupSnapshotView(
+                v: FfiConverterUInt8.read(from: &buf),
+                conversationMetas: FfiConverterSequenceTypeCatchupSnapshotEntry.read(from: &buf),
+                lastAppEventsPerConv: FfiConverterSequenceTypeCatchupAppEvent.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: CatchupSnapshotView, into buf: inout [UInt8]) {
+        FfiConverterUInt8.write(value.v, into: &buf)
+        FfiConverterSequenceTypeCatchupSnapshotEntry.write(value.conversationMetas, into: &buf)
+        FfiConverterSequenceTypeCatchupAppEvent.write(value.lastAppEventsPerConv, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCatchupSnapshotView_lift(_ buf: RustBuffer) throws -> CatchupSnapshotView {
+    return try FfiConverterTypeCatchupSnapshotView.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCatchupSnapshotView_lower(_ value: CatchupSnapshotView) -> RustBuffer {
+    return FfiConverterTypeCatchupSnapshotView.lower(value)
+}
+
 public struct ConversationId {
     public var value: Data
 
@@ -2277,6 +2517,67 @@ public func FfiConverterTypeIncomingMessage_lower(_ value: IncomingMessage) -> R
     return FfiConverterTypeIncomingMessage.lower(value)
 }
 
+public struct KeyPackageEntry {
+    public var deviceId: DeviceId
+    public var keyPackage: Data
+
+    /// Default memberwise initializers are never public by default, so we
+    /// declare one manually.
+    public init(deviceId: DeviceId, keyPackage: Data) {
+        self.deviceId = deviceId
+        self.keyPackage = keyPackage
+    }
+}
+
+extension KeyPackageEntry: Equatable, Hashable {
+    public static func == (lhs: KeyPackageEntry, rhs: KeyPackageEntry) -> Bool {
+        if lhs.deviceId != rhs.deviceId {
+            return false
+        }
+        if lhs.keyPackage != rhs.keyPackage {
+            return false
+        }
+        return true
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(deviceId)
+        hasher.combine(keyPackage)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeKeyPackageEntry: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyPackageEntry {
+        return
+            try KeyPackageEntry(
+                deviceId: FfiConverterTypeDeviceId.read(from: &buf),
+                keyPackage: FfiConverterData.read(from: &buf)
+            )
+    }
+
+    public static func write(_ value: KeyPackageEntry, into buf: inout [UInt8]) {
+        FfiConverterTypeDeviceId.write(value.deviceId, into: &buf)
+        FfiConverterData.write(value.keyPackage, into: &buf)
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeKeyPackageEntry_lift(_ buf: RustBuffer) throws -> KeyPackageEntry {
+    return try FfiConverterTypeKeyPackageEntry.lift(buf)
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+public func FfiConverterTypeKeyPackageEntry_lower(_ value: KeyPackageEntry) -> RustBuffer {
+    return FfiConverterTypeKeyPackageEntry.lower(value)
+}
+
 public struct LinkingTicket {
     public var v: UInt8
     public var userId: UserId
@@ -2852,23 +3153,48 @@ private struct FfiConverterSequenceString: FfiConverterRustBuffer {
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
-private struct FfiConverterSequenceData: FfiConverterRustBuffer {
-    typealias SwiftType = [Data]
+private struct FfiConverterSequenceTypeCatchupAppEvent: FfiConverterRustBuffer {
+    typealias SwiftType = [CatchupAppEvent]
 
-    static func write(_ value: [Data], into buf: inout [UInt8]) {
+    static func write(_ value: [CatchupAppEvent], into buf: inout [UInt8]) {
         let len = Int32(value.count)
         writeInt(&buf, len)
         for item in value {
-            FfiConverterData.write(item, into: &buf)
+            FfiConverterTypeCatchupAppEvent.write(item, into: &buf)
         }
     }
 
-    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [Data] {
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CatchupAppEvent] {
         let len: Int32 = try readInt(&buf)
-        var seq = [Data]()
+        var seq = [CatchupAppEvent]()
         seq.reserveCapacity(Int(len))
         for _ in 0 ..< len {
-            try seq.append(FfiConverterData.read(from: &buf))
+            try seq.append(FfiConverterTypeCatchupAppEvent.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceTypeCatchupSnapshotEntry: FfiConverterRustBuffer {
+    typealias SwiftType = [CatchupSnapshotEntry]
+
+    static func write(_ value: [CatchupSnapshotEntry], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeCatchupSnapshotEntry.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CatchupSnapshotEntry] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [CatchupSnapshotEntry]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterTypeCatchupSnapshotEntry.read(from: &buf))
         }
         return seq
     }
@@ -2974,6 +3300,31 @@ private struct FfiConverterSequenceTypeIncomingMessage: FfiConverterRustBuffer {
     }
 }
 
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+private struct FfiConverterSequenceTypeKeyPackageEntry: FfiConverterRustBuffer {
+    typealias SwiftType = [KeyPackageEntry]
+
+    static func write(_ value: [KeyPackageEntry], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeKeyPackageEntry.write(item, into: &buf)
+        }
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [KeyPackageEntry] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [KeyPackageEntry]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            try seq.append(FfiConverterTypeKeyPackageEntry.read(from: &buf))
+        }
+        return seq
+    }
+}
+
 #if swift(>=5.8)
     @_documentation(visibility: private)
 #endif
@@ -3112,12 +3463,38 @@ public func uniffiForeignFutureHandleCountPing() -> Int {
     UNIFFI_FOREIGN_FUTURE_HANDLE_MAP.count
 }
 
+public func decodeCatchupSnapshot(snapshotBytes: Data) throws -> CatchupSnapshotView {
+    return try FfiConverterTypeCatchupSnapshotView.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_decode_catchup_snapshot(
+            FfiConverterData.lower(snapshotBytes), $0
+        )
+    })
+}
+
 public func generateIdentityExport() -> Data {
     return try! FfiConverterData.lift(try! rustCall {
         uniffi_ping_ffi_fn_func_generate_identity_export($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(
+            FfiConverterData.lower(sealed),
+            FfiConverterData.lower(newDevicePriv), $0
+        )
+    })
+}
+
+public func sealLinkingTicket(ticket: LinkingTicket, newDevicePub: Data) throws -> Data {
+    return try FfiConverterData.lift(rustCallWithError(FfiConverterTypePingError.lift) {
+        uniffi_ping_ffi_fn_func_seal_linking_ticket(
+            FfiConverterTypeLinkingTicket.lower(ticket),
+            FfiConverterData.lower(newDevicePub), $0
+        )
+    })
+}
+
 private enum InitializationResult {
     case ok
     case contractVersionMismatch
@@ -3134,19 +3511,28 @@ private var initializationResult: InitializationResult = {
     if bindings_contract_version != scaffolding_contract_version {
         return InitializationResult.contractVersionMismatch
     }
+    if uniffi_ping_ffi_checksum_func_decode_catchup_snapshot() != 40316 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_func_generate_identity_export() != 15026 {
         return InitializationResult.apiChecksumMismatch
     }
+    if uniffi_ping_ffi_checksum_func_open_linking_ticket() != 64091 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_func_seal_linking_ticket() != 37263 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_method_messageobserver_on_application_message() != 7190 {
         return InitializationResult.apiChecksumMismatch
     }
     if uniffi_ping_ffi_checksum_method_messageobserver_on_conversation_updated() != 50154 {
         return InitializationResult.apiChecksumMismatch
     }
-    if uniffi_ping_ffi_checksum_method_messagingclient_add_members() != 59894 {
+    if uniffi_ping_ffi_checksum_method_messagingclient_add_members() != 2224 {
         return InitializationResult.apiChecksumMismatch
     }
-    if uniffi_ping_ffi_checksum_method_messagingclient_build_linking_ticket() != 54304 {
+    if uniffi_ping_ffi_checksum_method_messagingclient_build_linking_ticket() != 21631 {
         return InitializationResult.apiChecksumMismatch
     }
     if uniffi_ping_ffi_checksum_method_messagingclient_consume_linking_ticket() != 11953 {
@@ -3161,9 +3547,18 @@ private var initializationResult: InitializationResult = {
     if uniffi_ping_ffi_checksum_method_messagingclient_device_info() != 51623 {
         return InitializationResult.apiChecksumMismatch
     }
+    if uniffi_ping_ffi_checksum_method_messagingclient_export_conversation_secret() != 18264 {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if uniffi_ping_ffi_checksum_method_messagingclient_export_conversation_state_snapshot() != 48273 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_method_messagingclient_fresh_key_package() != 54233 {
         return InitializationResult.apiChecksumMismatch
     }
+    if uniffi_ping_ffi_checksum_method_messagingclient_import_state_snapshot() != 56077 {
+        return InitializationResult.apiChecksumMismatch
+    }
     if uniffi_ping_ffi_checksum_method_messagingclient_join_conversation() != 48291 {
         return InitializationResult.apiChecksumMismatch
     }
@@ -3179,7 +3574,7 @@ private var initializationResult: InitializationResult = {
     if uniffi_ping_ffi_checksum_method_messagingclient_remove_members() != 62054 {
         return InitializationResult.apiChecksumMismatch
     }
-    if uniffi_ping_ffi_checksum_method_messagingclient_revoke_device() != 63664 {
+    if uniffi_ping_ffi_checksum_method_messagingclient_revoke_device() != 28772 {
         return InitializationResult.apiChecksumMismatch
     }
     if uniffi_ping_ffi_checksum_method_messagingclient_send() != 11574 {
@@ -3215,7 +3610,7 @@ private var initializationResult: InitializationResult = {
     if uniffi_ping_ffi_checksum_method_transport_send() != 46493 {
         return InitializationResult.apiChecksumMismatch
     }
-    if uniffi_ping_ffi_checksum_constructor_messagingclient_init() != 38981 {
+    if uniffi_ping_ffi_checksum_constructor_messagingclient_init() != 35443 {
         return InitializationResult.apiChecksumMismatch
     }
 

package/ios/PingNativeModule.m

@@ -49,9 +49,17 @@ RCT_EXTERN_METHOD(generateIdentityExport: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 
 // Stage 4b: MessagingClient lifecycle.
+// [CR-4] sqlitePath + sqliteEncryptionKeyB64 are optional (nullable) — passing nil for
+// path falls back to the in-memory provider.
+// `deviceSigningSecretKeyB64` is the optional 32-byte Ed25519 secret the SDK adopts
+// as its device signing key on first init — used to align device_id with the host
+// auth layer's JWT claim. Pass nil to keep the random-key default.
 RCT_EXTERN_METHOD(initClient: (NSString *)identityB64
                   deviceLabel: (NSString *)deviceLabel
                   nowMs: (double)nowMs
+                  sqlitePath: (NSString *)sqlitePath
+                  sqliteEncryptionKeyB64: (NSString *)sqliteEncryptionKeyB64
+                  deviceSigningSecretKeyB64: (NSString *)deviceSigningSecretKeyB64
                   resolver: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 
@@ -81,8 +89,9 @@ RCT_EXTERN_METHOD(sendMessage: (NSArray *)conversationId
                   resolver: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 
+// [CR-2] entries are `{ deviceId: [Int], keyPackage: [Int] }` dicts.
 RCT_EXTERN_METHOD(addMembers: (NSArray *)conversationId
-                  keyPackages: (NSArray *)keyPackages
+                  entries: (NSArray *)entries
                   nowMs: (double)nowMs
                   resolver: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
@@ -114,8 +123,10 @@ RCT_EXTERN_METHOD(setObserver: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 
 // Stage 4f: linking + revocation.
+// [CR-13] lastAppEvents is an array of { conversationId, appEventBytes } dicts.
 RCT_EXTERN_METHOD(buildLinkingTicket: (NSArray *)newDeviceId
                   newDeviceKp: (NSArray *)newDeviceKp
+                  lastAppEvents: (NSArray *)lastAppEvents
                   nowMs: (double)nowMs
                   resolver: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
@@ -130,6 +141,25 @@ RCT_EXTERN_METHOD(revokeDevice: (NSArray *)deviceId
                   resolver: (RCTPromiseResolveBlock)resolve
                   rejecter: (RCTPromiseRejectBlock)reject)
 
+// [CR-8] Export a derived secret from a conversation's MLS exporter.
+RCT_EXTERN_METHOD(exportConversationSecret: (NSArray *)conversationId
+                  label: (NSString *)label
+                  context: (NSArray *)context
+                  length: (nonnull NSNumber *)length
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+// [CR-7] Export/import a portable MLS state snapshot for cross-device transfer.
+RCT_EXTERN_METHOD(exportConversationStateSnapshot: (NSArray *)conversationId
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(importStateSnapshot: (NSArray *)snapshotBytes
+                  nowMs: (double)nowMs
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter: (RCTPromiseRejectBlock)reject)
+
 // Stage 5 polish: macOS clipboard helper.
 RCT_EXTERN_METHOD(setClipboard: (NSString *)text
                   resolver: (RCTPromiseResolveBlock)resolve