@synonymdev/react-native-pubky 0.11.0 → 0.11.1

package/ios/pubkycore.swift

@@ -1,17 +1,15 @@
 // This file was autogenerated by some hot garbage in the `uniffi` crate.
 // Trust me, you don't want to mess with it!
-
-// swiftlint:disable all
 import Foundation
 
 // Depending on the consumer's build setup, the low-level FFI code
 // might be in a separate module, or it might be compiled inline into
 // this module. This is a bit of light hackery to work with both.
 #if canImport(pubkycoreFFI)
-import pubkycoreFFI
+    import pubkycoreFFI
 #endif
 
-fileprivate extension RustBuffer {
+private extension RustBuffer {
     // Allocate a new buffer, copying the contents of a `UInt8` array.
     init(bytes: [UInt8]) {
         let rbuf = bytes.withUnsafeBufferPointer { ptr in
@@ -20,10 +18,6 @@ fileprivate extension RustBuffer {
         self.init(capacity: rbuf.capacity, len: rbuf.len, data: rbuf.data)
     }
 
-    static func empty() -> RustBuffer {
-        RustBuffer(capacity: 0, len:0, data: nil)
-    }
-
     static func from(_ ptr: UnsafeBufferPointer<UInt8>) -> RustBuffer {
         try! rustCall { ffi_pubkycore_rustbuffer_from_bytes(ForeignBytes(bufferPointer: ptr), $0) }
     }
@@ -35,7 +29,7 @@ fileprivate extension RustBuffer {
     }
 }
 
-fileprivate extension ForeignBytes {
+private extension ForeignBytes {
     init(bufferPointer: UnsafeBufferPointer<UInt8>) {
         self.init(len: Int32(bufferPointer.count), data: bufferPointer.baseAddress)
     }
@@ -48,13 +42,11 @@ fileprivate extension ForeignBytes {
 // Helper classes/extensions that don't change.
 // Someday, this will be in a library of its own.
 
-fileprivate extension Data {
+private extension Data {
     init(rustBuffer: RustBuffer) {
-        self.init(
-            bytesNoCopy: rustBuffer.data!,
-            count: Int(rustBuffer.len),
-            deallocator: .none
-        )
+        // TODO: This copies the buffer. Can we read directly from a
+        // Rust buffer?
+        self.init(bytes: rustBuffer.data!, count: Int(rustBuffer.len))
     }
 }
 
@@ -72,15 +64,15 @@ fileprivate extension Data {
 //
 // Instead, the read() method and these helper functions input a tuple of data
 
-fileprivate func createReader(data: Data) -> (data: Data, offset: Data.Index) {
+private func createReader(data: Data) -> (data: Data, offset: Data.Index) {
     (data: data, offset: 0)
 }
 
 // Reads an integer at the current offset, in big-endian order, and advances
 // the offset on success. Throws if reading the integer would move the
 // offset past the end of the buffer.
-fileprivate func readInt<T: FixedWidthInteger>(_ reader: inout (data: Data, offset: Data.Index)) throws -> T {
-    let range = reader.offset..<reader.offset + MemoryLayout<T>.size
+private func readInt<T: FixedWidthInteger>(_ reader: inout (data: Data, offset: Data.Index)) throws -> T {
+    let range = reader.offset ..< reader.offset + MemoryLayout<T>.size
     guard reader.data.count >= range.upperBound else {
         throw UniffiInternalError.bufferOverflow
     }
@@ -90,38 +82,38 @@ fileprivate func readInt<T: FixedWidthInteger>(_ reader: inout (data: Data, offs
         return value as! T
     }
     var value: T = 0
-    let _ = withUnsafeMutableBytes(of: &value, { reader.data.copyBytes(to: $0, from: range)})
+    let _ = withUnsafeMutableBytes(of: &value) { reader.data.copyBytes(to: $0, from: range) }
     reader.offset = range.upperBound
     return value.bigEndian
 }
 
 // Reads an arbitrary number of bytes, to be used to read
 // raw bytes, this is useful when lifting strings
-fileprivate func readBytes(_ reader: inout (data: Data, offset: Data.Index), count: Int) throws -> Array<UInt8> {
-    let range = reader.offset..<(reader.offset+count)
+private func readBytes(_ reader: inout (data: Data, offset: Data.Index), count: Int) throws -> [UInt8] {
+    let range = reader.offset ..< (reader.offset + count)
     guard reader.data.count >= range.upperBound else {
         throw UniffiInternalError.bufferOverflow
     }
     var value = [UInt8](repeating: 0, count: count)
-    value.withUnsafeMutableBufferPointer({ buffer in
+    value.withUnsafeMutableBufferPointer { buffer in
         reader.data.copyBytes(to: buffer, from: range)
-    })
+    }
     reader.offset = range.upperBound
     return value
 }
 
 // Reads a float at the current offset.
-fileprivate func readFloat(_ reader: inout (data: Data, offset: Data.Index)) throws -> Float {
-    return Float(bitPattern: try readInt(&reader))
+private func readFloat(_ reader: inout (data: Data, offset: Data.Index)) throws -> Float {
+    return try Float(bitPattern: readInt(&reader))
 }
 
 // Reads a float at the current offset.
-fileprivate func readDouble(_ reader: inout (data: Data, offset: Data.Index)) throws -> Double {
-    return Double(bitPattern: try readInt(&reader))
+private func readDouble(_ reader: inout (data: Data, offset: Data.Index)) throws -> Double {
+    return try Double(bitPattern: readInt(&reader))
 }
 
 // Indicates if the offset has reached the end of the buffer.
-fileprivate func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Bool {
+private func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Bool {
     return reader.offset < reader.data.count
 }
 
@@ -129,11 +121,11 @@ fileprivate func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Boo
 // struct, but we use standalone functions instead in order to make external
 // types work.  See the above discussion on Readers for details.
 
-fileprivate func createWriter() -> [UInt8] {
+private func createWriter() -> [UInt8] {
     return []
 }
 
-fileprivate func writeBytes<S>(_ writer: inout [UInt8], _ byteArr: S) where S: Sequence, S.Element == UInt8 {
+private func writeBytes<S>(_ writer: inout [UInt8], _ byteArr: S) where S: Sequence, S.Element == UInt8 {
     writer.append(contentsOf: byteArr)
 }
 
@@ -141,22 +133,22 @@ fileprivate func writeBytes<S>(_ writer: inout [UInt8], _ byteArr: S) where S: S
 //
 // Warning: make sure what you are trying to write
 // is in the correct type!
-fileprivate func writeInt<T: FixedWidthInteger>(_ writer: inout [UInt8], _ value: T) {
+private func writeInt<T: FixedWidthInteger>(_ writer: inout [UInt8], _ value: T) {
     var value = value.bigEndian
     withUnsafeBytes(of: &value) { writer.append(contentsOf: $0) }
 }
 
-fileprivate func writeFloat(_ writer: inout [UInt8], _ value: Float) {
+private func writeFloat(_ writer: inout [UInt8], _ value: Float) {
     writeInt(&writer, value.bitPattern)
 }
 
-fileprivate func writeDouble(_ writer: inout [UInt8], _ value: Double) {
+private func writeDouble(_ writer: inout [UInt8], _ value: Double) {
     writeInt(&writer, value.bitPattern)
 }
 
 // Protocol for types that transfer other types across the FFI. This is
-// analogous to the Rust trait of the same name.
-fileprivate protocol FfiConverter {
+// analogous go the Rust trait of the same name.
+private protocol FfiConverter {
     associatedtype FfiType
     associatedtype SwiftType
 
@@ -167,19 +159,13 @@ fileprivate protocol FfiConverter {
 }
 
 // Types conforming to `Primitive` pass themselves directly over the FFI.
-fileprivate protocol FfiConverterPrimitive: FfiConverter where FfiType == SwiftType { }
+private protocol FfiConverterPrimitive: FfiConverter where FfiType == SwiftType {}
 
 extension FfiConverterPrimitive {
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
     public static func lift(_ value: FfiType) throws -> SwiftType {
         return value
     }
 
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
     public static func lower(_ value: SwiftType) -> FfiType {
         return value
     }
@@ -187,12 +173,9 @@ extension FfiConverterPrimitive {
 
 // Types conforming to `FfiConverterRustBuffer` lift and lower into a `RustBuffer`.
 // Used for complex types where it's hard to write a custom lift/lower.
-fileprivate protocol FfiConverterRustBuffer: FfiConverter where FfiType == RustBuffer {}
+private protocol FfiConverterRustBuffer: FfiConverter where FfiType == RustBuffer {}
 
 extension FfiConverterRustBuffer {
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
     public static func lift(_ buf: RustBuffer) throws -> SwiftType {
         var reader = createReader(data: Data(rustBuffer: buf))
         let value = try read(from: &reader)
@@ -203,18 +186,16 @@ extension FfiConverterRustBuffer {
         return value
     }
 
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
     public static func lower(_ value: SwiftType) -> RustBuffer {
-          var writer = createWriter()
-          write(value, into: &writer)
-          return RustBuffer(bytes: writer)
+        var writer = createWriter()
+        write(value, into: &writer)
+        return RustBuffer(bytes: writer)
     }
 }
+
 // An error type for FFI errors. These errors occur at the UniFFI level, not
 // the library level.
-fileprivate enum UniffiInternalError: LocalizedError {
+private enum UniffiInternalError: LocalizedError {
     case bufferOverflow
     case incompleteData
     case unexpectedOptionalTag
@@ -225,7 +206,7 @@ fileprivate enum UniffiInternalError: LocalizedError {
     case unexpectedStaleHandle
     case rustPanic(_ message: String)
 
-    public var errorDescription: String? {
+    var errorDescription: String? {
         switch self {
         case .bufferOverflow: return "Reading the requested value would read past the end of the buffer"
         case .incompleteData: return "The buffer still has data after lifting its containing value"
@@ -240,24 +221,16 @@ fileprivate enum UniffiInternalError: LocalizedError {
     }
 }
 
-fileprivate extension NSLock {
-    func withLock<T>(f: () throws -> T) rethrows -> T {
-        self.lock()
-        defer { self.unlock() }
-        return try f()
-    }
-}
+private let CALL_SUCCESS: Int8 = 0
+private let CALL_ERROR: Int8 = 1
+private let CALL_PANIC: Int8 = 2
+private let CALL_CANCELLED: Int8 = 3
 
-fileprivate let CALL_SUCCESS: Int8 = 0
-fileprivate let CALL_ERROR: Int8 = 1
-fileprivate let CALL_UNEXPECTED_ERROR: Int8 = 2
-fileprivate let CALL_CANCELLED: Int8 = 3
-
-fileprivate extension RustCallStatus {
+private extension RustCallStatus {
     init() {
         self.init(
             code: CALL_SUCCESS,
-            errorBuf: RustBuffer.init(
+            errorBuf: RustBuffer(
                 capacity: 0,
                 len: 0,
                 data: nil
@@ -267,174 +240,90 @@ fileprivate extension RustCallStatus {
 }
 
 private func rustCall<T>(_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
-    let neverThrow: ((RustBuffer) throws -> Never)? = nil
-    return try makeRustCall(callback, errorHandler: neverThrow)
+    try makeRustCall(callback, errorHandler: nil)
 }
 
-private func rustCallWithError<T, E: Swift.Error>(
-    _ errorHandler: @escaping (RustBuffer) throws -> E,
-    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
+private func rustCallWithError<T>(
+    _ errorHandler: @escaping (RustBuffer) throws -> Error,
+    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T
+) throws -> T {
     try makeRustCall(callback, errorHandler: errorHandler)
 }
 
-private func makeRustCall<T, E: Swift.Error>(
+private func makeRustCall<T>(
     _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T,
-    errorHandler: ((RustBuffer) throws -> E)?
+    errorHandler: ((RustBuffer) throws -> Error)?
 ) throws -> T {
-    uniffiEnsurePubkycoreInitialized()
-    var callStatus = RustCallStatus.init()
+    uniffiEnsureInitialized()
+    var callStatus = RustCallStatus()
     let returnedVal = callback(&callStatus)
     try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler)
     return returnedVal
 }
 
-private func uniffiCheckCallStatus<E: Swift.Error>(
+private func uniffiCheckCallStatus(
     callStatus: RustCallStatus,
-    errorHandler: ((RustBuffer) throws -> E)?
+    errorHandler: ((RustBuffer) throws -> Error)?
 ) throws {
     switch callStatus.code {
-        case CALL_SUCCESS:
-            return
-
-        case CALL_ERROR:
-            if let errorHandler = errorHandler {
-                throw try errorHandler(callStatus.errorBuf)
-            } else {
-                callStatus.errorBuf.deallocate()
-                throw UniffiInternalError.unexpectedRustCallError
-            }
-
-        case CALL_UNEXPECTED_ERROR:
-            // When the rust code sees a panic, it tries to construct a RustBuffer
-            // with the message.  But if that code panics, then it just sends back
-            // an empty buffer.
-            if callStatus.errorBuf.len > 0 {
-                throw UniffiInternalError.rustPanic(try FfiConverterString.lift(callStatus.errorBuf))
-            } else {
-                callStatus.errorBuf.deallocate()
-                throw UniffiInternalError.rustPanic("Rust panic")
-            }
-
-        case CALL_CANCELLED:
-            fatalError("Cancellation not supported yet")
-
-        default:
-            throw UniffiInternalError.unexpectedRustCallStatusCode
-    }
-}
-
-private func uniffiTraitInterfaceCall<T>(
-    callStatus: UnsafeMutablePointer<RustCallStatus>,
-    makeCall: () throws -> T,
-    writeReturn: (T) -> ()
-) {
-    do {
-        try writeReturn(makeCall())
-    } catch let error {
-        callStatus.pointee.code = CALL_UNEXPECTED_ERROR
-        callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
-    }
-}
-
-private func uniffiTraitInterfaceCallWithError<T, E>(
-    callStatus: UnsafeMutablePointer<RustCallStatus>,
-    makeCall: () throws -> T,
-    writeReturn: (T) -> (),
-    lowerError: (E) -> RustBuffer
-) {
-    do {
-        try writeReturn(makeCall())
-    } catch let error as E {
-        callStatus.pointee.code = CALL_ERROR
-        callStatus.pointee.errorBuf = lowerError(error)
-    } catch {
-        callStatus.pointee.code = CALL_UNEXPECTED_ERROR
-        callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
-    }
-}
-fileprivate final class UniffiHandleMap<T>: @unchecked Sendable {
-    // All mutation happens with this lock held, which is why we implement @unchecked Sendable.
-    private let lock = NSLock()
-    private var map: [UInt64: T] = [:]
-    private var currentHandle: UInt64 = 1
-
-    func insert(obj: T) -> UInt64 {
-        lock.withLock {
-            let handle = currentHandle
-            currentHandle += 1
-            map[handle] = obj
-            return handle
+    case CALL_SUCCESS:
+        return
+
+    case CALL_ERROR:
+        if let errorHandler = errorHandler {
+            throw try errorHandler(callStatus.errorBuf)
+        } else {
+            callStatus.errorBuf.deallocate()
+            throw UniffiInternalError.unexpectedRustCallError
         }
-    }
 
-     func get(handle: UInt64) throws -> T {
-        try lock.withLock {
-            guard let obj = map[handle] else {
-                throw UniffiInternalError.unexpectedStaleHandle
-            }
-            return obj
+    case CALL_PANIC:
+        // When the rust code sees a panic, it tries to construct a RustBuffer
+        // with the message.  But if that code panics, then it just sends back
+        // an empty buffer.
+        if callStatus.errorBuf.len > 0 {
+            throw try UniffiInternalError.rustPanic(FfiConverterString.lift(callStatus.errorBuf))
+        } else {
+            callStatus.errorBuf.deallocate()
+            throw UniffiInternalError.rustPanic("Rust panic")
         }
-    }
 
-    @discardableResult
-    func remove(handle: UInt64) throws -> T {
-        try lock.withLock {
-            guard let obj = map.removeValue(forKey: handle) else {
-                throw UniffiInternalError.unexpectedStaleHandle
-            }
-            return obj
-        }
-    }
+    case CALL_CANCELLED:
+        throw CancellationError()
 
-    var count: Int {
-        get {
-            map.count
-        }
+    default:
+        throw UniffiInternalError.unexpectedRustCallStatusCode
     }
 }
 
-
 // Public interface members begin here.
-// Magic number for the Rust proxy to call using the same mechanism as every other method,
-// to free the callback once it's dropped by Rust.
-private let IDX_CALLBACK_FREE: Int32 = 0
-// Callback return codes
-private let UNIFFI_CALLBACK_SUCCESS: Int32 = 0
-private let UNIFFI_CALLBACK_ERROR: Int32 = 1
-private let UNIFFI_CALLBACK_UNEXPECTED_ERROR: Int32 = 2
 
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-fileprivate struct FfiConverterBool : FfiConverter {
+private struct FfiConverterBool: FfiConverter {
     typealias FfiType = Int8
     typealias SwiftType = Bool
 
-    public static func lift(_ value: Int8) throws -> Bool {
+    static func lift(_ value: Int8) throws -> Bool {
         return value != 0
     }
 
-    public static func lower(_ value: Bool) -> Int8 {
+    static func lower(_ value: Bool) -> Int8 {
         return value ? 1 : 0
     }
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool {
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool {
         return try lift(readInt(&buf))
     }
 
-    public static func write(_ value: Bool, into buf: inout [UInt8]) {
+    static func write(_ value: Bool, into buf: inout [UInt8]) {
         writeInt(&buf, lower(value))
     }
 }
 
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-fileprivate struct FfiConverterString: FfiConverter {
+private struct FfiConverterString: FfiConverter {
     typealias SwiftType = String
     typealias FfiType = RustBuffer
 
-    public static func lift(_ value: RustBuffer) throws -> String {
+    static func lift(_ value: RustBuffer) throws -> String {
         defer {
             value.deallocate()
         }
@@ -445,7 +334,7 @@ fileprivate struct FfiConverterString: FfiConverter {
         return String(bytes: bytes, encoding: String.Encoding.utf8)!
     }
 
-    public static func lower(_ value: String) -> RustBuffer {
+    static func lower(_ value: String) -> RustBuffer {
         return value.utf8CString.withUnsafeBufferPointer { ptr in
             // The swift string gives us int8_t, we want uint8_t.
             ptr.withMemoryRebound(to: UInt8.self) { ptr in
@@ -456,102 +345,45 @@ fileprivate struct FfiConverterString: FfiConverter {
         }
     }
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String {
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String {
         let len: Int32 = try readInt(&buf)
-        return String(bytes: try readBytes(&buf, count: Int(len)), encoding: String.Encoding.utf8)!
+        return try String(bytes: readBytes(&buf, count: Int(len)), encoding: String.Encoding.utf8)!
     }
 
-    public static func write(_ value: String, into buf: inout [UInt8]) {
+    static func write(_ value: String, into buf: inout [UInt8]) {
         let len = Int32(value.utf8.count)
         writeInt(&buf, len)
         writeBytes(&buf, value.utf8)
     }
 }
 
+public protocol EventNotifierProtocol {}
 
-
-
-public protocol EventNotifierProtocol: AnyObject, Sendable {
-    
-}
-open class EventNotifier: EventNotifierProtocol, @unchecked Sendable {
-    fileprivate let pointer: UnsafeMutableRawPointer!
-
-    /// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
-    public struct NoPointer {
-        public init() {}
-    }
+public class EventNotifier: EventNotifierProtocol {
+    fileprivate let pointer: UnsafeMutableRawPointer
 
     // TODO: We'd like this to be `private` but for Swifty reasons,
     // we can't implement `FfiConverter` without making this `required` and we can't
     // make it `required` without making it `public`.
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
-    required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+    required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
         self.pointer = pointer
     }
 
-    // This constructor can be used to instantiate a fake object.
-    // - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
-    //
-    // - Warning:
-    //     Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
-    public init(noPointer: NoPointer) {
-        self.pointer = nil
-    }
-
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
-    public func uniffiClonePointer() -> UnsafeMutableRawPointer {
-        return try! rustCall { uniffi_pubkycore_fn_clone_eventnotifier(self.pointer, $0) }
-    }
-    // No primary constructor declared for this class.
-
     deinit {
-        guard let pointer = pointer else {
-            return
-        }
-
         try! rustCall { uniffi_pubkycore_fn_free_eventnotifier(pointer, $0) }
     }
-
-    
-
-    
-
 }
 
-
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
 public struct FfiConverterTypeEventNotifier: FfiConverter {
-
     typealias FfiType = UnsafeMutableRawPointer
     typealias SwiftType = EventNotifier
 
-    public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> EventNotifier {
-        return EventNotifier(unsafeFromRawPointer: pointer)
-    }
-
-    public static func lower(_ value: EventNotifier) -> UnsafeMutableRawPointer {
-        return value.uniffiClonePointer()
-    }
-
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EventNotifier {
         let v: UInt64 = try readInt(&buf)
         // The Rust code won't compile if a pointer won't fit in a UInt64.
         // We have to go via `UInt` because that's the thing that's the size of a pointer.
         let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
-        if (ptr == nil) {
+        if ptr == nil {
             throw UniffiInternalError.unexpectedNullPointer
         }
         return try lift(ptr!)
@@ -562,148 +394,194 @@ public struct FfiConverterTypeEventNotifier: FfiConverter {
         // The Rust code won't compile if a pointer won't fit in a `UInt64`.
         writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
     }
-}
 
+    public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> EventNotifier {
+        return EventNotifier(unsafeFromRawPointer: pointer)
+    }
+
+    public static func lower(_ value: EventNotifier) -> UnsafeMutableRawPointer {
+        return value.pointer
+    }
+}
 
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
 public func FfiConverterTypeEventNotifier_lift(_ pointer: UnsafeMutableRawPointer) throws -> EventNotifier {
     return try FfiConverterTypeEventNotifier.lift(pointer)
 }
 
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
 public func FfiConverterTypeEventNotifier_lower(_ value: EventNotifier) -> UnsafeMutableRawPointer {
     return FfiConverterTypeEventNotifier.lower(value)
 }
 
+private extension NSLock {
+    func withLock<T>(f: () throws -> T) rethrows -> T {
+        lock()
+        defer { self.unlock() }
+        return try f()
+    }
+}
 
+private typealias UniFFICallbackHandle = UInt64
+private class UniFFICallbackHandleMap<T> {
+    private var leftMap: [UniFFICallbackHandle: T] = [:]
+    private var counter: [UniFFICallbackHandle: UInt64] = [:]
+    private var rightMap: [ObjectIdentifier: UniFFICallbackHandle] = [:]
+
+    private let lock = NSLock()
+    private var currentHandle: UniFFICallbackHandle = 0
+    private let stride: UniFFICallbackHandle = 1
 
+    func insert(obj: T) -> UniFFICallbackHandle {
+        lock.withLock {
+            let id = ObjectIdentifier(obj as AnyObject)
+            let handle = rightMap[id] ?? {
+                currentHandle += stride
+                let handle = currentHandle
+                leftMap[handle] = obj
+                rightMap[id] = handle
+                return handle
+            }()
+            counter[handle] = (counter[handle] ?? 0) + 1
+            return handle
+        }
+    }
 
+    func get(handle: UniFFICallbackHandle) -> T? {
+        lock.withLock {
+            leftMap[handle]
+        }
+    }
 
+    func delete(handle: UniFFICallbackHandle) {
+        remove(handle: handle)
+    }
 
-public protocol EventListener: AnyObject, Sendable {
-    
-    func onEventOccurred(eventData: String) 
-    
+    @discardableResult
+    func remove(handle: UniFFICallbackHandle) -> T? {
+        lock.withLock {
+            defer { counter[handle] = (counter[handle] ?? 1) - 1 }
+            guard counter[handle] == 1 else { return leftMap[handle] }
+            let obj = leftMap.removeValue(forKey: handle)
+            if let obj = obj {
+                rightMap.removeValue(forKey: ObjectIdentifier(obj as AnyObject))
+            }
+            return obj
+        }
+    }
 }
 
+// Magic number for the Rust proxy to call using the same mechanism as every other method,
+// to free the callback once it's dropped by Rust.
+private let IDX_CALLBACK_FREE: Int32 = 0
+// Callback return codes
+private let UNIFFI_CALLBACK_SUCCESS: Int32 = 0
+private let UNIFFI_CALLBACK_ERROR: Int32 = 1
+private let UNIFFI_CALLBACK_UNEXPECTED_ERROR: Int32 = 2
 
-// Put the implementation in a struct so we don't pollute the top-level namespace
-fileprivate struct UniffiCallbackInterfaceEventListener {
+// Declaration and FfiConverters for EventListener Callback Interface
 
-    // Create the VTable using a series of closures.
-    // Swift automatically converts these into C callback functions.
-    //
-    // This creates 1-element array, since this seems to be the only way to construct a const
-    // pointer that we can pass to the Rust code.
-    static let vtable: [UniffiVTableCallbackInterfaceEventListener] = [UniffiVTableCallbackInterfaceEventListener(
-        onEventOccurred: { (
-            uniffiHandle: UInt64,
-            eventData: RustBuffer,
-            uniffiOutReturn: UnsafeMutableRawPointer,
-            uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
-        ) in
-            let makeCall = {
-                () throws -> () in
-                guard let uniffiObj = try? FfiConverterCallbackInterfaceEventListener.handleMap.get(handle: uniffiHandle) else {
-                    throw UniffiInternalError.unexpectedStaleHandle
-                }
-                return uniffiObj.onEventOccurred(
-                     eventData: try FfiConverterString.lift(eventData)
-                )
-            }
+public protocol EventListener: AnyObject {
+    func onEventOccurred(eventData: String)
+}
 
-            
-            let writeReturn = { () }
-            uniffiTraitInterfaceCall(
-                callStatus: uniffiCallStatus,
-                makeCall: makeCall,
-                writeReturn: writeReturn
+// The ForeignCallback that is passed to Rust.
+private let foreignCallbackCallbackInterfaceEventListener: ForeignCallback = { (handle: UniFFICallbackHandle, method: Int32, argsData: UnsafePointer<UInt8>, argsLen: Int32, out_buf: UnsafeMutablePointer<RustBuffer>) -> Int32 in
+    func invokeOnEventOccurred(_ swiftCallbackInterface: EventListener, _ argsData: UnsafePointer<UInt8>, _ argsLen: Int32, _: UnsafeMutablePointer<RustBuffer>) throws -> Int32 {
+        var reader = createReader(data: Data(bytes: argsData, count: Int(argsLen)))
+        func makeCall() throws -> Int32 {
+            try swiftCallbackInterface.onEventOccurred(
+                eventData: FfiConverterString.read(from: &reader)
             )
-        },
-        uniffiFree: { (uniffiHandle: UInt64) -> () in
-            let result = try? FfiConverterCallbackInterfaceEventListener.handleMap.remove(handle: uniffiHandle)
-            if result == nil {
-                print("Uniffi callback interface EventListener: handle missing in uniffiFree")
-            }
+            return UNIFFI_CALLBACK_SUCCESS
+        }
+        return try makeCall()
+    }
+
+    switch method {
+    case IDX_CALLBACK_FREE:
+        FfiConverterCallbackInterfaceEventListener.drop(handle: handle)
+        // Sucessful return
+        // See docs of ForeignCallback in `uniffi_core/src/ffi/foreigncallbacks.rs`
+        return UNIFFI_CALLBACK_SUCCESS
+
+    case 1:
+        let cb: EventListener
+        do {
+            cb = try FfiConverterCallbackInterfaceEventListener.lift(handle)
+        } catch {
+            out_buf.pointee = FfiConverterString.lower("EventListener: Invalid handle")
+            return UNIFFI_CALLBACK_UNEXPECTED_ERROR
+        }
+        do {
+            return try invokeOnEventOccurred(cb, argsData, argsLen, out_buf)
+        } catch {
+            out_buf.pointee = FfiConverterString.lower(String(describing: error))
+            return UNIFFI_CALLBACK_UNEXPECTED_ERROR
         }
-    )]
-}
 
-private func uniffiCallbackInitEventListener() {
-    uniffi_pubkycore_fn_init_callback_vtable_eventlistener(UniffiCallbackInterfaceEventListener.vtable)
+    // This should never happen, because an out of bounds method index won't
+    // ever be used. Once we can catch errors, we should return an InternalError.
+    // https://github.com/mozilla/uniffi-rs/issues/351
+    default:
+        // An unexpected error happened.
+        // See docs of ForeignCallback in `uniffi_core/src/ffi/foreigncallbacks.rs`
+        return UNIFFI_CALLBACK_UNEXPECTED_ERROR
+    }
 }
 
 // FfiConverter protocol for callback interfaces
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-fileprivate struct FfiConverterCallbackInterfaceEventListener {
-    fileprivate static let handleMap = UniffiHandleMap<EventListener>()
+private enum FfiConverterCallbackInterfaceEventListener {
+    private static let initCallbackOnce: () = {
+        // Swift ensures this initializer code will once run once, even when accessed by multiple threads.
+        try! rustCall { (err: UnsafeMutablePointer<RustCallStatus>) in
+            uniffi_pubkycore_fn_init_callback_eventlistener(foreignCallbackCallbackInterfaceEventListener, err)
+        }
+    }()
+
+    private static func ensureCallbackinitialized() {
+        _ = initCallbackOnce
+    }
+
+    static func drop(handle: UniFFICallbackHandle) {
+        handleMap.remove(handle: handle)
+    }
+
+    private static var handleMap = UniFFICallbackHandleMap<EventListener>()
 }
 
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-extension FfiConverterCallbackInterfaceEventListener : FfiConverter {
+extension FfiConverterCallbackInterfaceEventListener: FfiConverter {
     typealias SwiftType = EventListener
-    typealias FfiType = UInt64
+    // We can use Handle as the FfiType because it's a typealias to UInt64
+    typealias FfiType = UniFFICallbackHandle
 
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
-    public static func lift(_ handle: UInt64) throws -> SwiftType {
-        try handleMap.get(handle: handle)
+    public static func lift(_ handle: UniFFICallbackHandle) throws -> SwiftType {
+        ensureCallbackinitialized()
+        guard let callback = handleMap.get(handle: handle) else {
+            throw UniffiInternalError.unexpectedStaleHandle
+        }
+        return callback
     }
 
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
-        let handle: UInt64 = try readInt(&buf)
+        ensureCallbackinitialized()
+        let handle: UniFFICallbackHandle = try readInt(&buf)
         return try lift(handle)
     }
 
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
-    public static func lower(_ v: SwiftType) -> UInt64 {
+    public static func lower(_ v: SwiftType) -> UniFFICallbackHandle {
+        ensureCallbackinitialized()
         return handleMap.insert(obj: v)
     }
 
-#if swift(>=5.8)
-    @_documentation(visibility: private)
-#endif
     public static func write(_ v: SwiftType, into buf: inout [UInt8]) {
+        ensureCallbackinitialized()
         writeInt(&buf, lower(v))
     }
 }
 
-
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-public func FfiConverterCallbackInterfaceEventListener_lift(_ handle: UInt64) throws -> EventListener {
-    return try FfiConverterCallbackInterfaceEventListener.lift(handle)
-}
-
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-public func FfiConverterCallbackInterfaceEventListener_lower(_ v: EventListener) -> UInt64 {
-    return FfiConverterCallbackInterfaceEventListener.lower(v)
-}
-
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer {
+private struct FfiConverterOptionString: FfiConverterRustBuffer {
     typealias SwiftType = String?
 
-    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+    static func write(_ value: SwiftType, into buf: inout [UInt8]) {
         guard let value = value else {
             writeInt(&buf, Int8(0))
             return
@@ -712,7 +590,7 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer {
         FfiConverterString.write(value, into: &buf)
     }
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
         switch try readInt(&buf) as Int8 {
         case 0: return nil
         case 1: return try FfiConverterString.read(from: &buf)
@@ -721,13 +599,10 @@ fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer {
     }
 }
 
-#if swift(>=5.8)
-@_documentation(visibility: private)
-#endif
-fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer {
+private struct FfiConverterSequenceString: FfiConverterRustBuffer {
     typealias SwiftType = [String]
 
-    public static func write(_ value: [String], into buf: inout [UInt8]) {
+    static func write(_ value: [String], into buf: inout [UInt8]) {
         let len = Int32(value.count)
         writeInt(&buf, len)
         for item in value {
@@ -735,226 +610,297 @@ fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer {
         }
     }
 
-    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] {
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] {
         let len: Int32 = try readInt(&buf)
         var seq = [String]()
         seq.reserveCapacity(Int(len))
         for _ in 0 ..< len {
-            seq.append(try FfiConverterString.read(from: &buf))
+            try seq.append(FfiConverterString.read(from: &buf))
         }
         return seq
     }
 }
-public func auth(url: String, secretKey: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_auth(
-        FfiConverterString.lower(url),
-        FfiConverterString.lower(secretKey),$0
+
+public func auth(url: String, secretKey: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_auth(
+                FfiConverterString.lower(url),
+                FfiConverterString.lower(secretKey), $0
+            )
+        }
     )
-})
 }
-public func createRecoveryFile(secretKey: String, passphrase: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_create_recovery_file(
-        FfiConverterString.lower(secretKey),
-        FfiConverterString.lower(passphrase),$0
+
+public func createRecoveryFile(secretKey: String, passphrase: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_create_recovery_file(
+                FfiConverterString.lower(secretKey),
+                FfiConverterString.lower(passphrase), $0
+            )
+        }
     )
-})
 }
-public func decryptRecoveryFile(recoveryFile: String, passphrase: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_decrypt_recovery_file(
-        FfiConverterString.lower(recoveryFile),
-        FfiConverterString.lower(passphrase),$0
+
+public func decryptRecoveryFile(recoveryFile: String, passphrase: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_decrypt_recovery_file(
+                FfiConverterString.lower(recoveryFile),
+                FfiConverterString.lower(passphrase), $0
+            )
+        }
     )
-})
 }
-public func deleteFile(url: String, secretKey: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_delete_file(
-        FfiConverterString.lower(url),
-        FfiConverterString.lower(secretKey),$0
+
+public func deleteFile(url: String, secretKey: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_delete_file(
+                FfiConverterString.lower(url),
+                FfiConverterString.lower(secretKey), $0
+            )
+        }
     )
-})
 }
-public func generateMnemonicPhrase() -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_generate_mnemonic_phrase($0
+
+public func generateMnemonicPhrase() -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_generate_mnemonic_phrase($0)
+        }
     )
-})
 }
-public func generateMnemonicPhraseAndKeypair() -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_generate_mnemonic_phrase_and_keypair($0
+
+public func generateMnemonicPhraseAndKeypair() -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_generate_mnemonic_phrase_and_keypair($0)
+        }
     )
-})
 }
-public func generateSecretKey() -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_generate_secret_key($0
+
+public func generateSecretKey() -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_generate_secret_key($0)
+        }
     )
-})
 }
-public func get(url: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_get(
-        FfiConverterString.lower(url),$0
+
+public func get(url: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_get(
+                FfiConverterString.lower(url), $0
+            )
+        }
     )
-})
 }
-public func getHomeserver(pubky: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_get_homeserver(
-        FfiConverterString.lower(pubky),$0
+
+public func getHomeserver(pubky: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_get_homeserver(
+                FfiConverterString.lower(pubky), $0
+            )
+        }
     )
-})
 }
-public func getPublicKeyFromSecretKey(secretKey: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_get_public_key_from_secret_key(
-        FfiConverterString.lower(secretKey),$0
+
+public func getPublicKeyFromSecretKey(secretKey: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_get_public_key_from_secret_key(
+                FfiConverterString.lower(secretKey), $0
+            )
+        }
     )
-})
 }
-public func getSignupToken(homeserverPubky: String, adminPassword: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_get_signup_token(
-        FfiConverterString.lower(homeserverPubky),
-        FfiConverterString.lower(adminPassword),$0
+
+public func getSignupToken(homeserverPubky: String, adminPassword: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_get_signup_token(
+                FfiConverterString.lower(homeserverPubky),
+                FfiConverterString.lower(adminPassword), $0
+            )
+        }
     )
-})
 }
-public func list(url: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_list(
-        FfiConverterString.lower(url),$0
+
+public func list(url: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_list(
+                FfiConverterString.lower(url), $0
+            )
+        }
     )
-})
 }
-public func mnemonicPhraseToKeypair(mnemonicPhrase: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_mnemonic_phrase_to_keypair(
-        FfiConverterString.lower(mnemonicPhrase),$0
+
+public func mnemonicPhraseToKeypair(mnemonicPhrase: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_mnemonic_phrase_to_keypair(
+                FfiConverterString.lower(mnemonicPhrase), $0
+            )
+        }
     )
-})
 }
-public func parseAuthUrl(url: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_parse_auth_url(
-        FfiConverterString.lower(url),$0
-    )
-})
-}
-public func publish(recordName: String, recordContent: String, secretKey: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_publish(
-        FfiConverterString.lower(recordName),
-        FfiConverterString.lower(recordContent),
-        FfiConverterString.lower(secretKey),$0
+
+public func parseAuthUrl(url: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_parse_auth_url(
+                FfiConverterString.lower(url), $0
+            )
+        }
     )
-})
-}
-public func publishHttps(recordName: String, target: String, secretKey: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_publish_https(
-        FfiConverterString.lower(recordName),
-        FfiConverterString.lower(target),
-        FfiConverterString.lower(secretKey),$0
+}
+
+public func publish(recordName: String, recordContent: String, secretKey: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_publish(
+                FfiConverterString.lower(recordName),
+                FfiConverterString.lower(recordContent),
+                FfiConverterString.lower(secretKey), $0
+            )
+        }
     )
-})
-}
-public func put(url: String, content: String, secretKey: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_put(
-        FfiConverterString.lower(url),
-        FfiConverterString.lower(content),
-        FfiConverterString.lower(secretKey),$0
+}
+
+public func publishHttps(recordName: String, target: String, secretKey: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_publish_https(
+                FfiConverterString.lower(recordName),
+                FfiConverterString.lower(target),
+                FfiConverterString.lower(secretKey), $0
+            )
+        }
     )
-})
 }
-public func removeEventListener()  {try! rustCall() {
-    uniffi_pubkycore_fn_func_remove_event_listener($0
+
+public func put(url: String, content: String, secretKey: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_put(
+                FfiConverterString.lower(url),
+                FfiConverterString.lower(content),
+                FfiConverterString.lower(secretKey), $0
+            )
+        }
     )
 }
+
+public func removeEventListener() {
+    try! rustCall {
+        uniffi_pubkycore_fn_func_remove_event_listener($0)
+    }
 }
-public func republishHomeserver(secretKey: String, homeserver: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_republish_homeserver(
-        FfiConverterString.lower(secretKey),
-        FfiConverterString.lower(homeserver),$0
-    )
-})
-}
-/**
- * * Resolve a signed packet from a public key
- * * @param public_key The public key to resolve
- * * @returns A vector with two elements: the first element is a boolean indicating success or failure,
- * * and the second element is the response data (either an error message or the resolved signed packet)
- * *
- */
-public func resolve(publicKey: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_resolve(
-        FfiConverterString.lower(publicKey),$0
+
+public func republishHomeserver(secretKey: String, homeserver: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_republish_homeserver(
+                FfiConverterString.lower(secretKey),
+                FfiConverterString.lower(homeserver), $0
+            )
+        }
     )
-})
 }
-public func resolveHttps(publicKey: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_resolve_https(
-        FfiConverterString.lower(publicKey),$0
+
+public func resolve(publicKey: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_resolve(
+                FfiConverterString.lower(publicKey), $0
+            )
+        }
     )
-})
 }
-public func revalidateSession(sessionSecret: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_revalidate_session(
-        FfiConverterString.lower(sessionSecret),$0
+
+public func resolveHttps(publicKey: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_resolve_https(
+                FfiConverterString.lower(publicKey), $0
+            )
+        }
     )
-})
 }
-public func setEventListener(listener: EventListener)  {try! rustCall() {
-    uniffi_pubkycore_fn_func_set_event_listener(
-        FfiConverterCallbackInterfaceEventListener_lower(listener),$0
+
+public func revalidateSession(sessionSecret: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_revalidate_session(
+                FfiConverterString.lower(sessionSecret), $0
+            )
+        }
     )
 }
+
+public func setEventListener(listener: EventListener) {
+    try! rustCall {
+        uniffi_pubkycore_fn_func_set_event_listener(
+            FfiConverterCallbackInterfaceEventListener.lower(listener), $0
+        )
+    }
 }
-public func signIn(secretKey: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_sign_in(
-        FfiConverterString.lower(secretKey),$0
+
+public func signIn(secretKey: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_sign_in(
+                FfiConverterString.lower(secretKey), $0
+            )
+        }
     )
-})
 }
-public func signOut(sessionSecret: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_sign_out(
-        FfiConverterString.lower(sessionSecret),$0
+
+public func signOut(sessionSecret: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_sign_out(
+                FfiConverterString.lower(sessionSecret), $0
+            )
+        }
     )
-})
-}
-public func signUp(secretKey: String, homeserver: String, signupToken: String?) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_sign_up(
-        FfiConverterString.lower(secretKey),
-        FfiConverterString.lower(homeserver),
-        FfiConverterOptionString.lower(signupToken),$0
+}
+
+public func signUp(secretKey: String, homeserver: String, signupToken: String?) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_sign_up(
+                FfiConverterString.lower(secretKey),
+                FfiConverterString.lower(homeserver),
+                FfiConverterOptionString.lower(signupToken), $0
+            )
+        }
     )
-})
 }
-public func switchNetwork(useTestnet: Bool) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_switch_network(
-        FfiConverterBool.lower(useTestnet),$0
+
+public func switchNetwork(useTestnet: Bool) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_switch_network(
+                FfiConverterBool.lower(useTestnet), $0
+            )
+        }
     )
-})
 }
-public func validateMnemonicPhrase(mnemonicPhrase: String) -> [String]  {
-    return try!  FfiConverterSequenceString.lift(try! rustCall() {
-    uniffi_pubkycore_fn_func_validate_mnemonic_phrase(
-        FfiConverterString.lower(mnemonicPhrase),$0
+
+public func validateMnemonicPhrase(mnemonicPhrase: String) -> [String] {
+    return try! FfiConverterSequenceString.lift(
+        try! rustCall {
+            uniffi_pubkycore_fn_func_validate_mnemonic_phrase(
+                FfiConverterString.lower(mnemonicPhrase), $0
+            )
+        }
     )
-})
 }
 
 private enum InitializationResult {
@@ -962,111 +908,109 @@ private enum InitializationResult {
     case contractVersionMismatch
     case apiChecksumMismatch
 }
-// Use a global variable to perform the versioning checks. Swift ensures that
+
+// Use a global variables to perform the versioning checks. Swift ensures that
 // the code inside is only computed once.
-private let initializationResult: InitializationResult = {
+private var initializationResult: InitializationResult {
     // Get the bindings contract version from our ComponentInterface
-    let bindings_contract_version = 29
+    let bindings_contract_version = 24
     // Get the scaffolding contract version by calling the into the dylib
     let scaffolding_contract_version = ffi_pubkycore_uniffi_contract_version()
     if bindings_contract_version != scaffolding_contract_version {
         return InitializationResult.contractVersionMismatch
     }
-    if (uniffi_pubkycore_checksum_func_auth() != 36598) {
+    if uniffi_pubkycore_checksum_func_auth() != 51826 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_create_recovery_file() != 13366) {
+    if uniffi_pubkycore_checksum_func_create_recovery_file() != 48846 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_decrypt_recovery_file() != 56578) {
+    if uniffi_pubkycore_checksum_func_decrypt_recovery_file() != 26407 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_delete_file() != 37648) {
+    if uniffi_pubkycore_checksum_func_delete_file() != 47931 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_generate_mnemonic_phrase() != 38398) {
+    if uniffi_pubkycore_checksum_func_generate_mnemonic_phrase() != 2358 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_generate_mnemonic_phrase_and_keypair() != 13119) {
+    if uniffi_pubkycore_checksum_func_generate_mnemonic_phrase_and_keypair() != 44395 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_generate_secret_key() != 63319) {
+    if uniffi_pubkycore_checksum_func_generate_secret_key() != 12800 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_get() != 12463) {
+    if uniffi_pubkycore_checksum_func_get() != 6591 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_get_homeserver() != 35947) {
+    if uniffi_pubkycore_checksum_func_get_homeserver() != 40658 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_get_public_key_from_secret_key() != 65274) {
+    if uniffi_pubkycore_checksum_func_get_public_key_from_secret_key() != 40316 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_get_signup_token() != 7931) {
+    if uniffi_pubkycore_checksum_func_get_signup_token() != 47927 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_list() != 14351) {
+    if uniffi_pubkycore_checksum_func_list() != 43198 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_mnemonic_phrase_to_keypair() != 59088) {
+    if uniffi_pubkycore_checksum_func_mnemonic_phrase_to_keypair() != 45784 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_parse_auth_url() != 47180) {
+    if uniffi_pubkycore_checksum_func_parse_auth_url() != 27379 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_publish() != 60897) {
+    if uniffi_pubkycore_checksum_func_publish() != 48989 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_publish_https() != 43863) {
+    if uniffi_pubkycore_checksum_func_publish_https() != 5614 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_put() != 29897) {
+    if uniffi_pubkycore_checksum_func_put() != 64514 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_remove_event_listener() != 3828) {
+    if uniffi_pubkycore_checksum_func_remove_event_listener() != 23534 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_republish_homeserver() != 20001) {
+    if uniffi_pubkycore_checksum_func_republish_homeserver() != 63919 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_resolve() != 873) {
+    if uniffi_pubkycore_checksum_func_resolve() != 34317 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_resolve_https() != 34852) {
+    if uniffi_pubkycore_checksum_func_resolve_https() != 17266 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_revalidate_session() != 12593) {
+    if uniffi_pubkycore_checksum_func_revalidate_session() != 57726 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_set_event_listener() != 18894) {
+    if uniffi_pubkycore_checksum_func_set_event_listener() != 60071 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_sign_in() != 31244) {
+    if uniffi_pubkycore_checksum_func_sign_in() != 21584 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_sign_out() != 9048) {
+    if uniffi_pubkycore_checksum_func_sign_out() != 27163 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_sign_up() != 49409) {
+    if uniffi_pubkycore_checksum_func_sign_up() != 48789 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_switch_network() != 48346) {
+    if uniffi_pubkycore_checksum_func_switch_network() != 64215 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_func_validate_mnemonic_phrase() != 9633) {
+    if uniffi_pubkycore_checksum_func_validate_mnemonic_phrase() != 30362 {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_pubkycore_checksum_method_eventlistener_on_event_occurred() != 24359) {
+    if uniffi_pubkycore_checksum_method_eventlistener_on_event_occurred() != 11531 {
         return InitializationResult.apiChecksumMismatch
     }
 
-    uniffiCallbackInitEventListener()
     return InitializationResult.ok
-}()
+}
 
-// Make the ensure init function public so that other modules which have external type references to
-// our types can call it.
-public func uniffiEnsurePubkycoreInitialized() {
+private func uniffiEnsureInitialized() {
     switch initializationResult {
     case .ok:
         break
@@ -1076,5 +1020,3 @@ public func uniffiEnsurePubkycoreInitialized() {
         fatalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
 }
-
-// swiftlint:enable all