@runflame/wallet-rn 0.0.0-stage → 0.0.1-rc.1

package/ios/FlameWallet.swift

@@ -0,0 +1,2453 @@
+// 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(FlameWalletFFI)
+import FlameWalletFFI
+#endif
+
+fileprivate extension RustBuffer {
+    // Allocate a new buffer, copying the contents of a `UInt8` array.
+    init(bytes: [UInt8]) {
+        let rbuf = bytes.withUnsafeBufferPointer { ptr in
+            RustBuffer.from(ptr)
+        }
+        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_flamewallet_ffi_rustbuffer_from_bytes(ForeignBytes(bufferPointer: ptr), $0) }
+    }
+
+    // Frees the buffer in place.
+    // The buffer must not be used after this is called.
+    func deallocate() {
+        try! rustCall { ffi_flamewallet_ffi_rustbuffer_free(self, $0) }
+    }
+}
+
+fileprivate extension ForeignBytes {
+    init(bufferPointer: UnsafeBufferPointer<UInt8>) {
+        self.init(len: Int32(bufferPointer.count), data: bufferPointer.baseAddress)
+    }
+
+    init(rawBufferPointer: UnsafeRawBufferPointer) {
+        self.init(
+            len: Int32(rawBufferPointer.count),
+            data: rawBufferPointer.baseAddress?.assumingMemoryBound(to: UInt8.self)
+        )
+    }
+}
+
+// Converter for `&[u8]` / `[ByRef] bytes` arguments.
+//
+// Conforms to `FfiConverter` so the compiler enforces the full converter
+// method set. Only the scope-bound `lower(_:_body:)` overload is sound —
+// zero-copy byte buffers only flow foreign -> Rust, and only in argument
+// position. The four protocol-witness methods (`lift`, `lower`, `read`,
+// `write`) `fatalError` at runtime if anyone reaches them.
+//
+// The scope-bound `lower` takes a closure because the `ForeignBytes`
+// pointer is only guaranteed valid for the duration of
+// `Data.withUnsafeBytes`. Callers must run the full FFI call inside
+// the closure body.
+fileprivate enum FfiConverterByRefBytes: FfiConverter {
+    typealias SwiftType = Data
+    typealias FfiType = ForeignBytes
+
+    static func lower<R>(_ value: Data, _ body: (ForeignBytes) throws -> R) rethrows -> R {
+        return try value.withUnsafeBytes { rawBuf in
+            try body(ForeignBytes(rawBufferPointer: rawBuf))
+        }
+    }
+
+    static func lower(_ value: Data) -> ForeignBytes {
+        fatalError("ByRef bytes cannot use the plain lower: returning ForeignBytes escapes the Data.withUnsafeBytes scope. Use the scope-bound lower(_:_body:) overload instead.")
+    }
+
+    static func lift(_ value: ForeignBytes) throws -> Data {
+        fatalError("ByRef bytes cannot be lifted: zero-copy &[u8] only flows foreign->Rust")
+    }
+
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data {
+        fatalError("ByRef bytes cannot be read from a buffer: zero-copy &[u8] is only supported in argument position, not nested in records/options/etc.")
+    }
+
+    static func write(_ value: Data, into buf: inout [UInt8]) {
+        fatalError("ByRef bytes cannot be written to a buffer: zero-copy &[u8] is only supported in argument position, not nested in records/options/etc.")
+    }
+}
+
+// For every type used in the interface, we provide helper methods for conveniently
+// lifting and lowering that type from C-compatible data, and for reading and writing
+// values of that type in a buffer.
+
+// Helper classes/extensions that don't change.
+// Someday, this will be in a library of its own.
+
+fileprivate extension Data {
+    init(rustBuffer: RustBuffer) {
+        self.init(
+            bytesNoCopy: rustBuffer.data!,
+            count: Int(rustBuffer.len),
+            deallocator: .none
+        )
+    }
+}
+
+// Define reader functionality.  Normally this would be defined in a class or
+// struct, but we use standalone functions instead in order to make external
+// types work.
+//
+// With external types, one swift source file needs to be able to call the read
+// method on another source file's FfiConverter, but then what visibility
+// should Reader have?
+// - If Reader is fileprivate, then this means the read() must also
+//   be fileprivate, which doesn't work with external types.
+// - If Reader is internal/public, we'll get compile errors since both source
+//   files will try define the same type.
+//
+// Instead, the read() method and these helper functions input a tuple of data
+
+fileprivate 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
+    guard reader.data.count >= range.upperBound else {
+        throw UniffiInternalError.bufferOverflow
+    }
+    if T.self == UInt8.self {
+        let value = reader.data[reader.offset]
+        reader.offset += 1
+        return value as! T
+    }
+    var value: T = 0
+    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)
+    guard reader.data.count >= range.upperBound else {
+        throw UniffiInternalError.bufferOverflow
+    }
+    var value = [UInt8](repeating: 0, count: count)
+    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))
+}
+
+// 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))
+}
+
+// Indicates if the offset has reached the end of the buffer.
+fileprivate func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Bool {
+    return reader.offset < reader.data.count
+}
+
+// Define writer functionality.  Normally this would be defined in a class or
+// 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] {
+    return []
+}
+
+fileprivate func writeBytes<S>(_ writer: inout [UInt8], _ byteArr: S) where S: Sequence, S.Element == UInt8 {
+    writer.append(contentsOf: byteArr)
+}
+
+// Writes an integer in big-endian order.
+//
+// Warning: make sure what you are trying to write
+// is in the correct type!
+fileprivate 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) {
+    writeInt(&writer, value.bitPattern)
+}
+
+fileprivate 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 {
+    associatedtype FfiType
+    associatedtype SwiftType
+
+    static func lift(_ value: FfiType) throws -> SwiftType
+    static func lower(_ value: SwiftType) -> FfiType
+    static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType
+    static func write(_ value: SwiftType, into buf: inout [UInt8])
+}
+
+// Types conforming to `Primitive` pass themselves directly over the FFI.
+fileprivate 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
+    }
+}
+
+// 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 {}
+
+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)
+        if hasRemaining(reader) {
+            throw UniffiInternalError.incompleteData
+        }
+        buf.deallocate()
+        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)
+    }
+}
+// An error type for FFI errors. These errors occur at the UniFFI level, not
+// the library level.
+fileprivate enum UniffiInternalError: LocalizedError {
+    case bufferOverflow
+    case incompleteData
+    case unexpectedOptionalTag
+    case unexpectedEnumCase
+    case unexpectedNullPointer
+    case unexpectedRustCallStatusCode
+    case unexpectedRustCallError
+    case unexpectedStaleHandle
+    case rustPanic(_ message: String)
+
+    public 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"
+        case .unexpectedOptionalTag: return "Unexpected optional tag; should be 0 or 1"
+        case .unexpectedEnumCase: return "Raw enum value doesn't match any cases"
+        case .unexpectedNullPointer: return "Raw pointer value was null"
+        case .unexpectedRustCallStatusCode: return "Unexpected RustCallStatus code"
+        case .unexpectedRustCallError: return "CALL_ERROR but no errorClass specified"
+        case .unexpectedStaleHandle: return "The object in the handle map has been dropped already"
+        case let .rustPanic(message): return message
+        }
+    }
+}
+
+fileprivate extension NSLock {
+    func withLock<T>(f: () throws -> T) rethrows -> T {
+        self.lock()
+        defer { self.unlock() }
+        return try f()
+    }
+}
+
+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 {
+    init() {
+        self.init(
+            code: CALL_SUCCESS,
+            errorBuf: RustBuffer.init(
+                capacity: 0,
+                len: 0,
+                data: nil
+            )
+        )
+    }
+}
+
+private func rustCall<T>(_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
+    let neverThrow: ((RustBuffer) throws -> Never)? = nil
+    return try makeRustCall(callback, errorHandler: neverThrow)
+}
+
+private func rustCallWithError<T, E: Swift.Error>(
+    _ errorHandler: @escaping (RustBuffer) throws -> E,
+    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
+    try makeRustCall(callback, errorHandler: errorHandler)
+}
+
+private func makeRustCall<T, E: Swift.Error>(
+    _ callback: (UnsafeMutablePointer<RustCallStatus>) -> T,
+    errorHandler: ((RustBuffer) throws -> E)?
+) throws -> T {
+    uniffiEnsureFlamewalletFfiInitialized()
+    var callStatus = RustCallStatus.init()
+    let returnedVal = callback(&callStatus)
+    try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler)
+    return returnedVal
+}
+
+private func uniffiCheckCallStatus<E: Swift.Error>(
+    callStatus: RustCallStatus,
+    errorHandler: ((RustBuffer) throws -> E)?
+) 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))
+    }
+}
+// Initial value and increment amount for handles. 
+// These ensure that SWIFT handles always have the lowest bit set
+fileprivate let UNIFFI_HANDLEMAP_INITIAL: UInt64 = 1
+fileprivate let UNIFFI_HANDLEMAP_DELTA: UInt64 = 2
+
+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 = UNIFFI_HANDLEMAP_INITIAL
+
+    func insert(obj: T) -> UInt64 {
+        lock.withLock {
+            return doInsert(obj)
+        }
+    }
+
+    // Low-level insert function, this assumes `lock` is held.
+    private func doInsert(_ obj: T) -> UInt64 {
+        let handle = currentHandle
+        currentHandle += UNIFFI_HANDLEMAP_DELTA
+        map[handle] = obj
+        return handle
+    }
+
+     func get(handle: UInt64) throws -> T {
+        try lock.withLock {
+            guard let obj = map[handle] else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return obj
+        }
+    }
+
+     func clone(handle: UInt64) throws -> UInt64 {
+        try lock.withLock {
+            guard let obj = map[handle] else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return doInsert(obj)
+        }
+    }
+
+    @discardableResult
+    func remove(handle: UInt64) throws -> T {
+        try lock.withLock {
+            guard let obj = map.removeValue(forKey: handle) else {
+                throw UniffiInternalError.unexpectedStaleHandle
+            }
+            return obj
+        }
+    }
+
+    var count: Int {
+        get {
+            map.count
+        }
+    }
+}
+
+
+// Public interface members begin here.
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt8: FfiConverterPrimitive {
+    typealias FfiType = UInt8
+    typealias SwiftType = UInt8
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt8 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: UInt8, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt32: FfiConverterPrimitive {
+    typealias FfiType = UInt32
+    typealias SwiftType = UInt32
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt32 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterUInt64: FfiConverterPrimitive {
+    typealias FfiType = UInt64
+    typealias SwiftType = UInt64
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> UInt64 {
+        return try lift(readInt(&buf))
+    }
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterBool : FfiConverter {
+    typealias FfiType = Int8
+    typealias SwiftType = Bool
+
+    public static func lift(_ value: Int8) throws -> Bool {
+        return value != 0
+    }
+
+    public static func lower(_ value: Bool) -> Int8 {
+        return value ? 1 : 0
+    }
+
+    public 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]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterString: FfiConverter {
+    typealias SwiftType = String
+    typealias FfiType = RustBuffer
+
+    public static func lift(_ value: RustBuffer) throws -> String {
+        defer {
+            value.deallocate()
+        }
+        if value.data == nil {
+            return String()
+        }
+        let bytes = UnsafeBufferPointer<UInt8>(start: value.data!, count: Int(value.len))
+        // Use Swift's native UTF-8 decoder; `String(bytes:encoding:.utf8)` goes
+        // through Foundation's NSString and silently strips a leading U+FEFF BOM.
+        // Invalid UTF-8 substitutes U+FFFD instead of trapping (unreachable
+        // given Rust's `String` invariant).
+        return String(decoding: bytes, as: UTF8.self)
+    }
+
+    public 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
+                // The swift string gives us a trailing null byte, we don't want it.
+                let buf = UnsafeBufferPointer(rebasing: ptr.prefix(upTo: ptr.count - 1))
+                return RustBuffer.from(buf)
+            }
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String {
+        let len: Int32 = try readInt(&buf)
+        // See `lift` above for why we avoid Foundation's NSString-backed decoder here.
+        return String(decoding: try readBytes(&buf, count: Int(len)), as: UTF8.self)
+    }
+
+    public static func write(_ value: String, into buf: inout [UInt8]) {
+        let len = Int32(value.utf8.count)
+        writeInt(&buf, len)
+        writeBytes(&buf, value.utf8)
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterData: FfiConverterRustBuffer {
+    typealias SwiftType = Data
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Data {
+        let len: Int32 = try readInt(&buf)
+        return Data(try readBytes(&buf, count: Int(len)))
+    }
+
+    public static func write(_ value: Data, into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        writeBytes(&buf, value)
+    }
+}
+
+
+
+
+/**
+ * One account, `m/35263'/network'/0'`, behind an opaque handle.
+ *
+ * The handle is the only thing that ever holds key material: every
+ * spending key is derived inside a call and dropped before it returns. It
+ * is safe to share across threads. Calls that read or advance the counter
+ * are serialized; [`Wallet::build_transfer`] works on a copy and holds no
+ * lock while it proves.
+ */
+public protocol WalletProtocol: AnyObject, Sendable {
+    
+    /**
+     * The address and predicate at `path`, without issuing anything.
+     */
+    func address(path: KeyPath) throws  -> IssuedAddress
+    
+    /**
+     * Builds, proves and signs a transfer. The keys come from the paths
+     * the inputs name and never leave this call.
+     *
+     * Proving takes seconds on a phone, so it runs on a copy of the
+     * account with the lock released: other calls on this handle, from a
+     * UI thread say, do not wait for it. The build never touches the
+     * counter, so nothing the copy does needs writing back.
+     */
+    func buildTransfer(request: TransferRequest) throws  -> Transfer
+    
+    /**
+     * The network this wallet's addresses are encoded for.
+     */
+    func network()  -> Network
+    
+    /**
+     * Issues the next receiving address and advances the counter.
+     */
+    func nextAddress() throws  -> IssuedAddress
+    
+    /**
+     * The next receiving index not yet issued.
+     */
+    func nextIndex()  -> UInt32
+    
+    /**
+     * Opens the note that followed `contract` in its log, as a scan serves
+     * the pair; `note` is `None` when the scan served none. `path` is what
+     * [`Wallet::owns`] found for the contract's predicate. The opening it
+     * gives is what a later [`crate::TransferInput`] spends the output with.
+     */
+    func openNote(contract: Data, note: Data?, path: KeyPath) throws  -> ReceivedNote
+    
+    /**
+     * Which path below `next_index + gap`, on either branch, owns
+     * `predicate`; `None` if none does. The scan re-derives every address
+     * it covers, so `gap` is the caller's cost budget.
+     */
+    func owns(predicate: Data, gap: UInt32) throws  -> KeyPath?
+    
+    /**
+     * The account's receiving key in bech32f (`recv1…` / `testrecv1…`):
+     * what an indexer is given to find this wallet's payments. It derives
+     * every address and links their activity, and can neither spend nor
+     * read a payment's amount.
+     */
+    func receivingKey()  -> String
+    
+}
+/**
+ * One account, `m/35263'/network'/0'`, behind an opaque handle.
+ *
+ * The handle is the only thing that ever holds key material: every
+ * spending key is derived inside a call and dropped before it returns. It
+ * is safe to share across threads. Calls that read or advance the counter
+ * are serialized; [`Wallet::build_transfer`] works on a copy and holds no
+ * lock while it proves.
+ */
+open class Wallet: WalletProtocol, @unchecked Sendable {
+    fileprivate let handle: UInt64
+
+    /// Used to instantiate a [FFIObject] without an actual handle, for fakes in tests, mostly.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public struct NoHandle {
+        public init() {}
+    }
+
+    // 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(unsafeFromHandle handle: UInt64) {
+        self.handle = handle
+    }
+
+    // This constructor can be used to instantiate a fake object.
+    // - Parameter noHandle: 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 handle the FFI lower functions will crash.
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public init(noHandle: NoHandle) {
+        self.handle = 0
+    }
+
+#if swift(>=5.8)
+    @_documentation(visibility: private)
+#endif
+    public func uniffiCloneHandle() -> UInt64 {
+        return try! rustCall { uniffi_flamewallet_ffi_fn_clone_wallet(self.handle, $0) }
+    }
+    /**
+     * The account below a 64-byte seed, as [`mnemonic_to_seed`] gives it,
+     * with `next_index` receiving addresses already issued. The seed holds
+     * keys, not history: an app stores [`Wallet::next_index`] after each
+     * [`Wallet::next_address`] and passes it back here; a new wallet
+     * passes 0.
+     */
+public convenience init(seed: Data, network: Network, nextIndex: UInt32)throws  {
+    let handle =
+        try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_constructor_wallet_new(
+        FfiConverterData.lower(seed),
+        FfiConverterTypeNetwork_lower(network),
+        FfiConverterUInt32.lower(nextIndex),uniffiCallStatus
+    )
+}
+    self.init(unsafeFromHandle: handle)
+}
+
+    deinit {
+        if handle == 0 {
+            // Mock objects have handle=0 don't try to free them
+            return
+        }
+
+        try! rustCall { uniffi_flamewallet_ffi_fn_free_wallet(handle, $0) }
+    }
+
+    
+    /**
+     * The account below `phrase` and `passphrase`, without the caller ever
+     * seeing the seed; `next_index` as in [`Wallet::new`].
+     */
+public static func fromMnemonic(phrase: String, passphrase: String, network: Network, nextIndex: UInt32)throws  -> Wallet  {
+    return try  FfiConverterTypeWallet_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_constructor_wallet_from_mnemonic(
+        FfiConverterString.lower(phrase),
+        FfiConverterString.lower(passphrase),
+        FfiConverterTypeNetwork_lower(network),
+        FfiConverterUInt32.lower(nextIndex),uniffiCallStatus
+    )
+})
+}
+    
+
+    
+    /**
+     * The address and predicate at `path`, without issuing anything.
+     */
+open func address(path: KeyPath)throws  -> IssuedAddress  {
+    return try  FfiConverterTypeIssuedAddress_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_address(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeKeyPath_lower(path),uniffiCallStatus
+    )
+})
+}
+    
+    /**
+     * Builds, proves and signs a transfer. The keys come from the paths
+     * the inputs name and never leave this call.
+     *
+     * Proving takes seconds on a phone, so it runs on a copy of the
+     * account with the lock released: other calls on this handle, from a
+     * UI thread say, do not wait for it. The build never touches the
+     * counter, so nothing the copy does needs writing back.
+     */
+open func buildTransfer(request: TransferRequest)throws  -> Transfer  {
+    return try  FfiConverterTypeTransfer_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_build_transfer(
+            self.uniffiCloneHandle(),
+        FfiConverterTypeTransferRequest_lower(request),uniffiCallStatus
+    )
+})
+}
+    
+    /**
+     * The network this wallet's addresses are encoded for.
+     */
+open func network() -> Network  {
+    return try!  FfiConverterTypeNetwork_lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_network(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+    
+    /**
+     * Issues the next receiving address and advances the counter.
+     */
+open func nextAddress()throws  -> IssuedAddress  {
+    return try  FfiConverterTypeIssuedAddress_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_next_address(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+    
+    /**
+     * The next receiving index not yet issued.
+     */
+open func nextIndex() -> UInt32  {
+    return try!  FfiConverterUInt32.lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_next_index(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+    
+    /**
+     * Opens the note that followed `contract` in its log, as a scan serves
+     * the pair; `note` is `None` when the scan served none. `path` is what
+     * [`Wallet::owns`] found for the contract's predicate. The opening it
+     * gives is what a later [`crate::TransferInput`] spends the output with.
+     */
+open func openNote(contract: Data, note: Data?, path: KeyPath)throws  -> ReceivedNote  {
+    return try  FfiConverterTypeReceivedNote_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_open_note(
+            self.uniffiCloneHandle(),
+        FfiConverterData.lower(contract),
+        FfiConverterOptionData.lower(note),
+        FfiConverterTypeKeyPath_lower(path),uniffiCallStatus
+    )
+})
+}
+    
+    /**
+     * Which path below `next_index + gap`, on either branch, owns
+     * `predicate`; `None` if none does. The scan re-derives every address
+     * it covers, so `gap` is the caller's cost budget.
+     */
+open func owns(predicate: Data, gap: UInt32)throws  -> KeyPath?  {
+    return try  FfiConverterOptionTypeKeyPath.lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_owns(
+            self.uniffiCloneHandle(),
+        FfiConverterData.lower(predicate),
+        FfiConverterUInt32.lower(gap),uniffiCallStatus
+    )
+})
+}
+    
+    /**
+     * The account's receiving key in bech32f (`recv1…` / `testrecv1…`):
+     * what an indexer is given to find this wallet's payments. It derives
+     * every address and links their activity, and can neither spend nor
+     * read a payment's amount.
+     */
+open func receivingKey() -> String  {
+    return try!  FfiConverterString.lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_receiving_key(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+    
+
+    
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeWallet: FfiConverter {
+    typealias FfiType = UInt64
+    typealias SwiftType = Wallet
+
+    public static func lift(_ handle: UInt64) throws -> Wallet {
+        return Wallet(unsafeFromHandle: handle)
+    }
+
+    public static func lower(_ value: Wallet) -> UInt64 {
+        return value.uniffiCloneHandle()
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Wallet {
+        let handle: UInt64 = try readInt(&buf)
+        return try lift(handle)
+    }
+
+    public static func write(_ value: Wallet, into buf: inout [UInt8]) {
+        writeInt(&buf, lower(value))
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWallet_lift(_ handle: UInt64) throws -> Wallet {
+    return try FfiConverterTypeWallet.lift(handle)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWallet_lower(_ value: Wallet) -> UInt64 {
+    return FfiConverterTypeWallet.lower(value)
+}
+
+
+
+
+/**
+ * A published contract, as much of it as a wallet reads.
+ */
+public struct ContractInfo: Equatable, Hashable {
+    /**
+     * The 32-byte contract id.
+     */
+    public var id: Data
+    /**
+     * The 32-byte compressed point it is locked with: what
+     * [`crate::Wallet::owns`] is asked about.
+     */
+    public var predicate: Data
+    public var value: ContractValue
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(
+        /**
+         * The 32-byte contract id.
+         */id: Data, 
+        /**
+         * The 32-byte compressed point it is locked with: what
+         * [`crate::Wallet::owns`] is asked about.
+         */predicate: Data, value: ContractValue) {
+        self.id = id
+        self.predicate = predicate
+        self.value = value
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension ContractInfo: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeContractInfo: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ContractInfo {
+        return
+            try ContractInfo(
+                id: FfiConverterData.read(from: &buf), 
+                predicate: FfiConverterData.read(from: &buf), 
+                value: FfiConverterTypeContractValue.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: ContractInfo, into buf: inout [UInt8]) {
+        FfiConverterData.write(value.id, into: &buf)
+        FfiConverterData.write(value.predicate, into: &buf)
+        FfiConverterTypeContractValue.write(value.value, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeContractInfo_lift(_ buf: RustBuffer) throws -> ContractInfo {
+    return try FfiConverterTypeContractInfo.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeContractInfo_lower(_ value: ContractInfo) -> RustBuffer {
+    return FfiConverterTypeContractInfo.lower(value)
+}
+
+
+/**
+ * One contract the transfer creates.
+ */
+public struct CreatedOutput: Equatable, Hashable {
+    public var contractId: Data
+    /**
+     * Its published bytes, as an indexer will serve them once confirmed.
+     */
+    public var contract: Data
+    /**
+     * The encrypted note that follows it on chain, as an indexer's scan
+     * serves it. Its recipient opens it with [`crate::Wallet::open_note`];
+     * so does this wallet, for its change.
+     */
+    public var note: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(contractId: Data, 
+        /**
+         * Its published bytes, as an indexer will serve them once confirmed.
+         */contract: Data, 
+        /**
+         * The encrypted note that follows it on chain, as an indexer's scan
+         * serves it. Its recipient opens it with [`crate::Wallet::open_note`];
+         * so does this wallet, for its change.
+         */note: Data) {
+        self.contractId = contractId
+        self.contract = contract
+        self.note = note
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension CreatedOutput: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeCreatedOutput: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CreatedOutput {
+        return
+            try CreatedOutput(
+                contractId: FfiConverterData.read(from: &buf), 
+                contract: FfiConverterData.read(from: &buf), 
+                note: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: CreatedOutput, into buf: inout [UInt8]) {
+        FfiConverterData.write(value.contractId, into: &buf)
+        FfiConverterData.write(value.contract, into: &buf)
+        FfiConverterData.write(value.note, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCreatedOutput_lift(_ buf: RustBuffer) throws -> CreatedOutput {
+    return try FfiConverterTypeCreatedOutput.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeCreatedOutput_lower(_ value: CreatedOutput) -> RustBuffer {
+    return FfiConverterTypeCreatedOutput.lower(value)
+}
+
+
+/**
+ * An address the wallet has handed out, with the predicate an indexer is
+ * asked about.
+ */
+public struct IssuedAddress: Equatable, Hashable {
+    public var path: KeyPath
+    /**
+     * bech32f: `f1…` on mainnet, `tf1…` on testnet.
+     */
+    public var address: String
+    /**
+     * The 32-byte compressed point that locks payments to this address.
+     */
+    public var predicate: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(path: KeyPath, 
+        /**
+         * bech32f: `f1…` on mainnet, `tf1…` on testnet.
+         */address: String, 
+        /**
+         * The 32-byte compressed point that locks payments to this address.
+         */predicate: Data) {
+        self.path = path
+        self.address = address
+        self.predicate = predicate
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension IssuedAddress: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeIssuedAddress: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> IssuedAddress {
+        return
+            try IssuedAddress(
+                path: FfiConverterTypeKeyPath.read(from: &buf), 
+                address: FfiConverterString.read(from: &buf), 
+                predicate: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: IssuedAddress, into buf: inout [UInt8]) {
+        FfiConverterTypeKeyPath.write(value.path, into: &buf)
+        FfiConverterString.write(value.address, into: &buf)
+        FfiConverterData.write(value.predicate, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeIssuedAddress_lift(_ buf: RustBuffer) throws -> IssuedAddress {
+    return try FfiConverterTypeIssuedAddress.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeIssuedAddress_lower(_ value: IssuedAddress) -> RustBuffer {
+    return FfiConverterTypeIssuedAddress.lower(value)
+}
+
+
+/**
+ * A position below the account: `m/35263'/network'/0'/branch/index`.
+ * `branch` is `0` for receiving and `1` for change.
+ */
+public struct KeyPath: Equatable, Hashable {
+    public var branch: UInt32
+    public var index: UInt32
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(branch: UInt32, index: UInt32) {
+        self.branch = branch
+        self.index = index
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension KeyPath: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeKeyPath: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> KeyPath {
+        return
+            try KeyPath(
+                branch: FfiConverterUInt32.read(from: &buf), 
+                index: FfiConverterUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: KeyPath, into buf: inout [UInt8]) {
+        FfiConverterUInt32.write(value.branch, into: &buf)
+        FfiConverterUInt32.write(value.index, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeKeyPath_lift(_ buf: RustBuffer) throws -> KeyPath {
+    return try FfiConverterTypeKeyPath.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeKeyPath_lower(_ value: KeyPath) -> RustBuffer {
+    return FfiConverterTypeKeyPath.lower(value)
+}
+
+
+/**
+ * The secret behind a confidential output: what its recipient needs in
+ * order to spend it. Scalars are 32 canonical little-endian bytes.
+ */
+public struct Opening: Equatable, Hashable {
+    public var qty: UInt64
+    public var flavor: Data
+    public var qtyBlinding: Data
+    public var flavorBlinding: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(qty: UInt64, flavor: Data, qtyBlinding: Data, flavorBlinding: Data) {
+        self.qty = qty
+        self.flavor = flavor
+        self.qtyBlinding = qtyBlinding
+        self.flavorBlinding = flavorBlinding
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension Opening: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeOpening: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Opening {
+        return
+            try Opening(
+                qty: FfiConverterUInt64.read(from: &buf), 
+                flavor: FfiConverterData.read(from: &buf), 
+                qtyBlinding: FfiConverterData.read(from: &buf), 
+                flavorBlinding: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: Opening, into buf: inout [UInt8]) {
+        FfiConverterUInt64.write(value.qty, into: &buf)
+        FfiConverterData.write(value.flavor, into: &buf)
+        FfiConverterData.write(value.qtyBlinding, into: &buf)
+        FfiConverterData.write(value.flavorBlinding, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeOpening_lift(_ buf: RustBuffer) throws -> Opening {
+    return try FfiConverterTypeOpening.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeOpening_lower(_ value: Opening) -> RustBuffer {
+    return FfiConverterTypeOpening.lower(value)
+}
+
+
+/**
+ * What an opened note gives its recipient.
+ */
+public struct ReceivedNote: Equatable, Hashable {
+    /**
+     * What a [`crate::TransferInput`] spends the output with.
+     */
+    public var opening: Opening
+    /**
+     * The memo, as the sender wrote it.
+     */
+    public var memo: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(
+        /**
+         * What a [`crate::TransferInput`] spends the output with.
+         */opening: Opening, 
+        /**
+         * The memo, as the sender wrote it.
+         */memo: Data) {
+        self.opening = opening
+        self.memo = memo
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension ReceivedNote: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeReceivedNote: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ReceivedNote {
+        return
+            try ReceivedNote(
+                opening: FfiConverterTypeOpening.read(from: &buf), 
+                memo: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: ReceivedNote, into buf: inout [UInt8]) {
+        FfiConverterTypeOpening.write(value.opening, into: &buf)
+        FfiConverterData.write(value.memo, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeReceivedNote_lift(_ buf: RustBuffer) throws -> ReceivedNote {
+    return try FfiConverterTypeReceivedNote.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeReceivedNote_lower(_ value: ReceivedNote) -> RustBuffer {
+    return FfiConverterTypeReceivedNote.lower(value)
+}
+
+
+/**
+ * A signed transfer, ready to publish.
+ */
+public struct Transfer: Equatable, Hashable {
+    /**
+     * The 32-byte transaction id.
+     */
+    public var txid: Data
+    /**
+     * `BlockTx::to_bytes`: what a node's `submit_tx` takes.
+     */
+    public var blockTx: Data
+    /**
+     * In the order they are published, which is not request order: the
+     * builder sorts them so that position says nothing about which one is
+     * the change. Match one to its request by its predicate.
+     */
+    public var outputs: [CreatedOutput]
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(
+        /**
+         * The 32-byte transaction id.
+         */txid: Data, 
+        /**
+         * `BlockTx::to_bytes`: what a node's `submit_tx` takes.
+         */blockTx: Data, 
+        /**
+         * In the order they are published, which is not request order: the
+         * builder sorts them so that position says nothing about which one is
+         * the change. Match one to its request by its predicate.
+         */outputs: [CreatedOutput]) {
+        self.txid = txid
+        self.blockTx = blockTx
+        self.outputs = outputs
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension Transfer: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTransfer: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Transfer {
+        return
+            try Transfer(
+                txid: FfiConverterData.read(from: &buf), 
+                blockTx: FfiConverterData.read(from: &buf), 
+                outputs: FfiConverterSequenceTypeCreatedOutput.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: Transfer, into buf: inout [UInt8]) {
+        FfiConverterData.write(value.txid, into: &buf)
+        FfiConverterData.write(value.blockTx, into: &buf)
+        FfiConverterSequenceTypeCreatedOutput.write(value.outputs, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransfer_lift(_ buf: RustBuffer) throws -> Transfer {
+    return try FfiConverterTypeTransfer.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransfer_lower(_ value: Transfer) -> RustBuffer {
+    return FfiConverterTypeTransfer.lower(value)
+}
+
+
+/**
+ * One contract being spent, exactly as the indexer served it.
+ */
+public struct TransferInput: Equatable, Hashable {
+    /**
+     * The contract's published bytes.
+     */
+    public var contract: Data
+    /**
+     * Its Utreexo membership proof, valid at the tip the transfer targets.
+     */
+    public var proof: Data
+    /**
+     * The path of the key it is locked to.
+     */
+    public var path: KeyPath
+    /**
+     * Required for a confidential contract, refused for a cleartext one.
+     */
+    public var opening: Opening?
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(
+        /**
+         * The contract's published bytes.
+         */contract: Data, 
+        /**
+         * Its Utreexo membership proof, valid at the tip the transfer targets.
+         */proof: Data, 
+        /**
+         * The path of the key it is locked to.
+         */path: KeyPath, 
+        /**
+         * Required for a confidential contract, refused for a cleartext one.
+         */opening: Opening?) {
+        self.contract = contract
+        self.proof = proof
+        self.path = path
+        self.opening = opening
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension TransferInput: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTransferInput: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransferInput {
+        return
+            try TransferInput(
+                contract: FfiConverterData.read(from: &buf), 
+                proof: FfiConverterData.read(from: &buf), 
+                path: FfiConverterTypeKeyPath.read(from: &buf), 
+                opening: FfiConverterOptionTypeOpening.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: TransferInput, into buf: inout [UInt8]) {
+        FfiConverterData.write(value.contract, into: &buf)
+        FfiConverterData.write(value.proof, into: &buf)
+        FfiConverterTypeKeyPath.write(value.path, into: &buf)
+        FfiConverterOptionTypeOpening.write(value.opening, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransferInput_lift(_ buf: RustBuffer) throws -> TransferInput {
+    return try FfiConverterTypeTransferInput.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransferInput_lower(_ value: TransferInput) -> RustBuffer {
+    return FfiConverterTypeTransferInput.lower(value)
+}
+
+
+/**
+ * One contract being created.
+ */
+public struct TransferOutput: Equatable, Hashable {
+    /**
+     * The recipient's bech32f address, for the wallet's network; for
+     * change, [`crate::Wallet::address`] on the change branch.
+     */
+    public var address: String
+    public var qty: UInt64
+    /**
+     * `None` for flames.
+     */
+    public var flavor: Data?
+    /**
+     * Sealed into the output's note with the amount; only the recipient
+     * reads it. At most 8102 bytes; empty for none.
+     */
+    public var memo: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(
+        /**
+         * The recipient's bech32f address, for the wallet's network; for
+         * change, [`crate::Wallet::address`] on the change branch.
+         */address: String, qty: UInt64, 
+        /**
+         * `None` for flames.
+         */flavor: Data?, 
+        /**
+         * Sealed into the output's note with the amount; only the recipient
+         * reads it. At most 8102 bytes; empty for none.
+         */memo: Data) {
+        self.address = address
+        self.qty = qty
+        self.flavor = flavor
+        self.memo = memo
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension TransferOutput: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTransferOutput: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransferOutput {
+        return
+            try TransferOutput(
+                address: FfiConverterString.read(from: &buf), 
+                qty: FfiConverterUInt64.read(from: &buf), 
+                flavor: FfiConverterOptionData.read(from: &buf), 
+                memo: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: TransferOutput, into buf: inout [UInt8]) {
+        FfiConverterString.write(value.address, into: &buf)
+        FfiConverterUInt64.write(value.qty, into: &buf)
+        FfiConverterOptionData.write(value.flavor, into: &buf)
+        FfiConverterData.write(value.memo, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransferOutput_lift(_ buf: RustBuffer) throws -> TransferOutput {
+    return try FfiConverterTypeTransferOutput.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransferOutput_lower(_ value: TransferOutput) -> RustBuffer {
+    return FfiConverterTypeTransferOutput.lower(value)
+}
+
+
+public struct TransferRequest: Equatable, Hashable {
+    public var inputs: [TransferInput]
+    public var outputs: [TransferOutput]
+    /**
+     * In sparks. Inputs must equal outputs plus fee, per flavor.
+     */
+    public var fee: UInt64
+    /**
+     * The gas budget; the node refuses more than its block limit allows.
+     */
+    public var gas: UInt64
+    /**
+     * `0` for none; otherwise as in Bitcoin.
+     */
+    public var locktime: UInt32
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(inputs: [TransferInput], outputs: [TransferOutput], 
+        /**
+         * In sparks. Inputs must equal outputs plus fee, per flavor.
+         */fee: UInt64, 
+        /**
+         * The gas budget; the node refuses more than its block limit allows.
+         */gas: UInt64, 
+        /**
+         * `0` for none; otherwise as in Bitcoin.
+         */locktime: UInt32) {
+        self.inputs = inputs
+        self.outputs = outputs
+        self.fee = fee
+        self.gas = gas
+        self.locktime = locktime
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension TransferRequest: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeTransferRequest: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransferRequest {
+        return
+            try TransferRequest(
+                inputs: FfiConverterSequenceTypeTransferInput.read(from: &buf), 
+                outputs: FfiConverterSequenceTypeTransferOutput.read(from: &buf), 
+                fee: FfiConverterUInt64.read(from: &buf), 
+                gas: FfiConverterUInt64.read(from: &buf), 
+                locktime: FfiConverterUInt32.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: TransferRequest, into buf: inout [UInt8]) {
+        FfiConverterSequenceTypeTransferInput.write(value.inputs, into: &buf)
+        FfiConverterSequenceTypeTransferOutput.write(value.outputs, into: &buf)
+        FfiConverterUInt64.write(value.fee, into: &buf)
+        FfiConverterUInt64.write(value.gas, into: &buf)
+        FfiConverterUInt32.write(value.locktime, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransferRequest_lift(_ buf: RustBuffer) throws -> TransferRequest {
+    return try FfiConverterTypeTransferRequest.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeTransferRequest_lower(_ value: TransferRequest) -> RustBuffer {
+    return FfiConverterTypeTransferRequest.lower(value)
+}
+
+
+/**
+ * What a contract holds.
+ */
+
+public enum ContractValue: Equatable, Hashable {
+    
+    /**
+     * A cleartext token: the amount is public. A devnet genesis allocation
+     * is one.
+     */
+    case clear(qty: UInt64, flavor: Data
+    )
+    /**
+     * A confidential token: the amount is readable only with its opening.
+     */
+    case confidential
+    /**
+     * Anything that is not a bare token; no transfer spends it.
+     */
+    case other
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension ContractValue: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeContractValue: FfiConverterRustBuffer {
+    typealias SwiftType = ContractValue
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ContractValue {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .clear(qty: try FfiConverterUInt64.read(from: &buf), flavor: try FfiConverterData.read(from: &buf)
+        )
+        
+        case 2: return .confidential
+        
+        case 3: return .other
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: ContractValue, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case let .clear(qty,flavor):
+            writeInt(&buf, Int32(1))
+            FfiConverterUInt64.write(qty, into: &buf)
+            FfiConverterData.write(flavor, into: &buf)
+            
+        
+        case .confidential:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .other:
+            writeInt(&buf, Int32(3))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeContractValue_lift(_ buf: RustBuffer) throws -> ContractValue {
+    return try FfiConverterTypeContractValue.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeContractValue_lower(_ value: ContractValue) -> RustBuffer {
+    return FfiConverterTypeContractValue.lower(value)
+}
+
+
+
+/**
+ * Why a call was refused.
+ */
+public 
+enum FlameError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {
+
+    
+    
+    /**
+     * The phrase is not a valid BIP-39 mnemonic in any supported language,
+     * or the word count is not one BIP-39 defines.
+     */
+    case InvalidMnemonic(reason: String
+    )
+    /**
+     * A seed is not 64 bytes, or flamekd refused to derive from it.
+     */
+    case InvalidSeed(reason: String
+    )
+    /**
+     * An address does not parse for the wallet's network.
+     */
+    case InvalidAddress(reason: String
+    )
+    /**
+     * A branch or index is hardened; both must be normal.
+     */
+    case InvalidKeyPath(reason: String
+    )
+    /**
+     * Bytes do not decode into what they claim to be. `what` names the
+     * field: `contract`, `proof`, `predicate`, `flavor`, `blinding`.
+     */
+    case InvalidBytes(what: String, reason: String
+    )
+    /**
+     * Input `input` is not locked to the key at the path it names, so its
+     * signature could never verify.
+     */
+    case KeyMismatch(input: UInt32
+    )
+    /**
+     * A note did not open; `failure` says how, and so what the wallet does
+     * with the output.
+     */
+    case Note(failure: NoteFailure, reason: String
+    )
+    /**
+     * The transfer could not be built or signed.
+     */
+    case Transfer(reason: String
+    )
+
+    
+
+    
+
+    
+    public var errorDescription: String? {
+        String(reflecting: self)
+    }
+    
+}
+
+#if compiler(>=6)
+extension FlameError: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeFlameError: FfiConverterRustBuffer {
+    typealias SwiftType = FlameError
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FlameError {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+
+        
+
+        
+        case 1: return .InvalidMnemonic(
+            reason: try FfiConverterString.read(from: &buf)
+            )
+        case 2: return .InvalidSeed(
+            reason: try FfiConverterString.read(from: &buf)
+            )
+        case 3: return .InvalidAddress(
+            reason: try FfiConverterString.read(from: &buf)
+            )
+        case 4: return .InvalidKeyPath(
+            reason: try FfiConverterString.read(from: &buf)
+            )
+        case 5: return .InvalidBytes(
+            what: try FfiConverterString.read(from: &buf), 
+            reason: try FfiConverterString.read(from: &buf)
+            )
+        case 6: return .KeyMismatch(
+            input: try FfiConverterUInt32.read(from: &buf)
+            )
+        case 7: return .Note(
+            failure: try FfiConverterTypeNoteFailure.read(from: &buf), 
+            reason: try FfiConverterString.read(from: &buf)
+            )
+        case 8: return .Transfer(
+            reason: try FfiConverterString.read(from: &buf)
+            )
+
+         default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: FlameError, into buf: inout [UInt8]) {
+        switch value {
+
+        
+
+        
+        
+        case let .InvalidMnemonic(reason):
+            writeInt(&buf, Int32(1))
+            FfiConverterString.write(reason, into: &buf)
+            
+        
+        case let .InvalidSeed(reason):
+            writeInt(&buf, Int32(2))
+            FfiConverterString.write(reason, into: &buf)
+            
+        
+        case let .InvalidAddress(reason):
+            writeInt(&buf, Int32(3))
+            FfiConverterString.write(reason, into: &buf)
+            
+        
+        case let .InvalidKeyPath(reason):
+            writeInt(&buf, Int32(4))
+            FfiConverterString.write(reason, into: &buf)
+            
+        
+        case let .InvalidBytes(what,reason):
+            writeInt(&buf, Int32(5))
+            FfiConverterString.write(what, into: &buf)
+            FfiConverterString.write(reason, into: &buf)
+            
+        
+        case let .KeyMismatch(input):
+            writeInt(&buf, Int32(6))
+            FfiConverterUInt32.write(input, into: &buf)
+            
+        
+        case let .Note(failure,reason):
+            writeInt(&buf, Int32(7))
+            FfiConverterTypeNoteFailure.write(failure, into: &buf)
+            FfiConverterString.write(reason, into: &buf)
+            
+        
+        case let .Transfer(reason):
+            writeInt(&buf, Int32(8))
+            FfiConverterString.write(reason, into: &buf)
+            
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFlameError_lift(_ buf: RustBuffer) throws -> FlameError {
+    return try FfiConverterTypeFlameError.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeFlameError_lower(_ value: FlameError) -> RustBuffer {
+    return FfiConverterTypeFlameError.lower(value)
+}
+
+
+/**
+ * Which network addresses are encoded for: `f1…` or `tf1…`.
+ */
+
+public enum Network: Equatable, Hashable {
+    
+    case mainnet
+    case testnet
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension Network: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNetwork: FfiConverterRustBuffer {
+    typealias SwiftType = Network
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Network {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .mainnet
+        
+        case 2: return .testnet
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: Network, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .mainnet:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .testnet:
+            writeInt(&buf, Int32(2))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNetwork_lift(_ buf: RustBuffer) throws -> Network {
+    return try FfiConverterTypeNetwork.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNetwork_lower(_ value: Network) -> RustBuffer {
+    return FfiConverterTypeNetwork.lower(value)
+}
+
+
+
+/**
+ * Why a note did not open: the outcomes of `docs/payments.md`
+ * "Receiving", which a wallet treats differently.
+ */
+
+public enum NoteFailure: Equatable, Hashable {
+    
+    /**
+     * No note followed the output. The output is ours but unreadable: keep
+     * and list it, and leave it out of the balance.
+     */
+    case missing
+    /**
+     * The note is malformed. Treated as [`NoteFailure::Missing`].
+     */
+    case malformed
+    /**
+     * A note version this library does not know; a later one may open it.
+     */
+    case unknownVersion
+    /**
+     * The note does not decrypt under this address. Treated as
+     * [`NoteFailure::Missing`].
+     */
+    case undecryptable
+    /**
+     * The note decrypts but misstates its output: the sender erred or lied.
+     * Keep and flag it; never count it.
+     */
+    case openingMismatch
+    /**
+     * The contract is a cleartext token, or not a token: there is no note
+     * to open, and [`crate::decode_contract`] reads its amount.
+     */
+    case notConfidential
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension NoteFailure: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNoteFailure: FfiConverterRustBuffer {
+    typealias SwiftType = NoteFailure
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NoteFailure {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .missing
+        
+        case 2: return .malformed
+        
+        case 3: return .unknownVersion
+        
+        case 4: return .undecryptable
+        
+        case 5: return .openingMismatch
+        
+        case 6: return .notConfidential
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: NoteFailure, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .missing:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .malformed:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .unknownVersion:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .undecryptable:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .openingMismatch:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .notConfidential:
+            writeInt(&buf, Int32(6))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNoteFailure_lift(_ buf: RustBuffer) throws -> NoteFailure {
+    return try FfiConverterTypeNoteFailure.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNoteFailure_lower(_ value: NoteFailure) -> RustBuffer {
+    return FfiConverterTypeNoteFailure.lower(value)
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionData: FfiConverterRustBuffer {
+    typealias SwiftType = Data?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterData.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterData.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeKeyPath: FfiConverterRustBuffer {
+    typealias SwiftType = KeyPath?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeKeyPath.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterTypeKeyPath.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterOptionTypeOpening: FfiConverterRustBuffer {
+    typealias SwiftType = Opening?
+
+    public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
+        guard let value = value else {
+            writeInt(&buf, Int8(0))
+            return
+        }
+        writeInt(&buf, Int8(1))
+        FfiConverterTypeOpening.write(value, into: &buf)
+    }
+
+    public 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 FfiConverterTypeOpening.read(from: &buf)
+        default: throw UniffiInternalError.unexpectedOptionalTag
+        }
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeCreatedOutput: FfiConverterRustBuffer {
+    typealias SwiftType = [CreatedOutput]
+
+    public static func write(_ value: [CreatedOutput], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeCreatedOutput.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [CreatedOutput] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [CreatedOutput]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeCreatedOutput.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeTransferInput: FfiConverterRustBuffer {
+    typealias SwiftType = [TransferInput]
+
+    public static func write(_ value: [TransferInput], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeTransferInput.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [TransferInput] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [TransferInput]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeTransferInput.read(from: &buf))
+        }
+        return seq
+    }
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+fileprivate struct FfiConverterSequenceTypeTransferOutput: FfiConverterRustBuffer {
+    typealias SwiftType = [TransferOutput]
+
+    public static func write(_ value: [TransferOutput], into buf: inout [UInt8]) {
+        let len = Int32(value.count)
+        writeInt(&buf, len)
+        for item in value {
+            FfiConverterTypeTransferOutput.write(item, into: &buf)
+        }
+    }
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [TransferOutput] {
+        let len: Int32 = try readInt(&buf)
+        var seq = [TransferOutput]()
+        seq.reserveCapacity(Int(len))
+        for _ in 0 ..< len {
+            seq.append(try FfiConverterTypeTransferOutput.read(from: &buf))
+        }
+        return seq
+    }
+}
+/**
+ * Decodes a contract from its published bytes.
+ */
+public func decodeContract(bytes: Data)throws  -> ContractInfo  {
+    return try  FfiConverterTypeContractInfo_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_func_decode_contract(
+        FfiConverterData.lower(bytes),uniffiCallStatus
+    )
+})
+}
+/**
+ * Whether `opening` opens the confidential contract in `bytes`.
+ *
+ * This is how a recipient checks an opening delivered out of band before
+ * counting the payment: the same id comparison
+ * [`crate::Wallet::build_transfer`] makes, run without spending anything.
+ */
+public func openingMatches(contract: Data, opening: Opening)throws  -> Bool  {
+    return try  FfiConverterBool.lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_func_opening_matches(
+        FfiConverterData.lower(contract),
+        FfiConverterTypeOpening_lower(opening),uniffiCallStatus
+    )
+})
+}
+/**
+ * The predicate a payment to `address` is locked with: the address's
+ * spending point. Refuses an address encoded for the other network.
+ */
+public func addressToPredicate(address: String, network: Network)throws  -> Data  {
+    return try  FfiConverterData.lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_func_address_to_predicate(
+        FfiConverterString.lower(address),
+        FfiConverterTypeNetwork_lower(network),uniffiCallStatus
+    )
+})
+}
+/**
+ * A fresh English mnemonic of `word_count` words: 12, 15, 18, 21 or 24.
+ */
+public func generateMnemonic(wordCount: UInt8)throws  -> String  {
+    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_func_generate_mnemonic(
+        FfiConverterUInt8.lower(wordCount),uniffiCallStatus
+    )
+})
+}
+/**
+ * The 64-byte BIP-39 seed of `phrase` under `passphrase` (`""` for none).
+ * This seed is what [`Wallet::new`] takes and what an app stores.
+ */
+public func mnemonicToSeed(phrase: String, passphrase: String)throws  -> Data  {
+    return try  FfiConverterData.lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_func_mnemonic_to_seed(
+        FfiConverterString.lower(phrase),
+        FfiConverterString.lower(passphrase),uniffiCallStatus
+    )
+})
+}
+/**
+ * Whether `phrase` is a valid mnemonic in any BIP-39 language.
+ */
+public func validateMnemonic(phrase: String) -> Bool  {
+    return try!  FfiConverterBool.lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_func_validate_mnemonic(
+        FfiConverterString.lower(phrase),uniffiCallStatus
+    )
+})
+}
+
+private enum InitializationResult {
+    case ok
+    case contractVersionMismatch
+    case apiChecksumMismatch
+}
+// Use a global variable to perform the versioning checks. Swift ensures that
+// the code inside is only computed once.
+private let initializationResult: InitializationResult = {
+    // Get the bindings contract version from our ComponentInterface
+    let bindings_contract_version = 30
+    // Get the scaffolding contract version by calling the into the dylib
+    let scaffolding_contract_version = ffi_flamewallet_ffi_uniffi_contract_version()
+    if bindings_contract_version != scaffolding_contract_version {
+        return InitializationResult.contractVersionMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_func_decode_contract() != 9189) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_func_opening_matches() != 54400) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_func_address_to_predicate() != 27158) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_func_generate_mnemonic() != 49383) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_func_mnemonic_to_seed() != 5184) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_func_validate_mnemonic() != 36978) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_address() != 24772) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer() != 41970) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_network() != 6461) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_next_address() != 12667) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_next_index() != 50043) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_open_note() != 45629) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_owns() != 34274) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_receiving_key() != 41950) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_constructor_wallet_from_mnemonic() != 19125) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_constructor_wallet_new() != 9773) {
+        return InitializationResult.apiChecksumMismatch
+    }
+
+    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 uniffiEnsureFlamewalletFfiInitialized() {
+    switch initializationResult {
+    case .ok:
+        break
+    case .contractVersionMismatch:
+        fatalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
+    case .apiChecksumMismatch:
+        fatalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+}
+
+// swiftlint:enable all