@runflame/wallet-rn 0.0.1-rc.0 → 0.0.1-rc.10

package/ios/FlameWallet.swift

@@ -604,8 +604,11 @@ fileprivate struct FfiConverterData: FfiConverterRustBuffer {
 /**
  * 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
+ * The handle holds the account key, and every child key is derived inside
+ * a call and dropped before it returns. Two calls hand key material out,
+ * and the caller must keep what they return as secret as the wallet
+ * itself: [`Wallet::view_key`] reads every amount and memo, and
+ * [`Wallet::receiving_key`] links every address. Neither can spend. 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.
@@ -625,9 +628,17 @@ public protocol WalletProtocol: AnyObject, Sendable {
      * 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.
+     *
+     * Only a spend wallet builds; the others refuse with
+     * [`FlameError::NotPermitted`] before reading the request.
      */
     func buildTransfer(request: TransferRequest) throws  -> Transfer
     
+    /**
+     * What this wallet was built from, and so what it can do.
+     */
+    func kind()  -> WalletKind
+    
     /**
      * The network this wallet's addresses are encoded for.
      */
@@ -643,6 +654,15 @@ public protocol WalletProtocol: AnyObject, Sendable {
      */
     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.
+     * A receive wallet cannot open notes.
+     */
+    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
@@ -658,12 +678,23 @@ public protocol WalletProtocol: AnyObject, Sendable {
      */
     func receivingKey()  -> String
     
+    /**
+     * The account's view key in bech32f (`view1…` / `testview1…`): what a
+     * view wallet is built from. It derives every address and opens every
+     * note, so it reads every amount and memo, but it cannot spend. Store
+     * it as a secret. A receive wallet has none to give.
+     */
+    func viewKey() throws  -> 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
+ * The handle holds the account key, and every child key is derived inside
+ * a call and dropped before it returns. Two calls hand key material out,
+ * and the caller must keep what they return as secret as the wallet
+ * itself: [`Wallet::view_key`] reads every amount and memo, and
+ * [`Wallet::receiving_key`] links every address. Neither can spend. 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.
@@ -753,6 +784,50 @@ public static func fromMnemonic(phrase: String, passphrase: String, network: Net
 })
 }
     
+    /**
+     * A receive wallet from the account's receiving key in bech32f, as
+     * [`Wallet::receiving_key`] gives it, for `network`; `next_index` as
+     * in [`Wallet::new`]. It issues addresses and finds payments;
+     * [`Wallet::view_key`], [`Wallet::open_note`] and
+     * [`Wallet::build_transfer`] refuse with [`FlameError::NotPermitted`].
+     *
+     * As with [`Wallet::from_view_key`], it must be the account node's
+     * key: one from any other node is accepted and silently owns nothing.
+     */
+public static func fromReceivingKey(receivingKey: String, network: Network, nextIndex: UInt32)throws  -> Wallet  {
+    return try  FfiConverterTypeWallet_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_constructor_wallet_from_receiving_key(
+        FfiConverterString.lower(receivingKey),
+        FfiConverterTypeNetwork_lower(network),
+        FfiConverterUInt32.lower(nextIndex),uniffiCallStatus
+    )
+})
+}
+    
+    /**
+     * A view wallet from the account's view key in bech32f, as
+     * [`Wallet::view_key`] gives it, for `network`; `next_index` as in
+     * [`Wallet::new`]. Every call works except
+     * [`Wallet::build_transfer`], which refuses with
+     * [`FlameError::NotPermitted`].
+     *
+     * It must be the key of the account node, `m/35263'/network'/0'`,
+     * exactly as [`Wallet::view_key`] exports it. The encoding carries no
+     * depth, so a key from any other node is accepted too, and that
+     * wallet silently owns nothing: every `owns` is `None`.
+     */
+public static func fromViewKey(viewKey: String, network: Network, nextIndex: UInt32)throws  -> Wallet  {
+    return try  FfiConverterTypeWallet_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_constructor_wallet_from_view_key(
+        FfiConverterString.lower(viewKey),
+        FfiConverterTypeNetwork_lower(network),
+        FfiConverterUInt32.lower(nextIndex),uniffiCallStatus
+    )
+})
+}
+    
 
     
     /**
@@ -776,6 +851,9 @@ open func address(path: KeyPath)throws  -> IssuedAddress  {
      * 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.
+     *
+     * Only a spend wallet builds; the others refuse with
+     * [`FlameError::NotPermitted`] before reading the request.
      */
 open func buildTransfer(request: TransferRequest)throws  -> Transfer  {
     return try  FfiConverterTypeTransfer_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
@@ -785,6 +863,18 @@ open func buildTransfer(request: TransferRequest)throws  -> Transfer  {
         FfiConverterTypeTransferRequest_lower(request),uniffiCallStatus
     )
 })
+}
+    
+    /**
+     * What this wallet was built from, and so what it can do.
+     */
+open func kind() -> WalletKind  {
+    return try!  FfiConverterTypeWalletKind_lift(try! rustCall() {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_kind(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
 }
     
     /**
@@ -821,6 +911,25 @@ open func nextIndex() -> UInt32  {
             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.
+     * A receive wallet cannot open notes.
+     */
+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
+    )
+})
 }
     
     /**
@@ -854,6 +963,21 @@ open func receivingKey() -> String  {
 })
 }
     
+    /**
+     * The account's view key in bech32f (`view1…` / `testview1…`): what a
+     * view wallet is built from. It derives every address and opens every
+     * note, so it reads every amount and memo, but it cannot spend. Store
+     * it as a secret. A receive wallet has none to give.
+     */
+open func viewKey()throws  -> String  {
+    return try  FfiConverterString.lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_view_key(
+            self.uniffiCloneHandle(),uniffiCallStatus
+    )
+})
+}
+    
 
     
 }
@@ -978,7 +1102,7 @@ public func FfiConverterTypeContractInfo_lower(_ value: ContractInfo) -> RustBuf
 
 
 /**
- * One contract the transfer creates, in request order.
+ * One contract the transfer creates.
  */
 public struct CreatedOutput: Equatable, Hashable {
     public var contractId: Data
@@ -987,10 +1111,11 @@ public struct CreatedOutput: Equatable, Hashable {
      */
     public var contract: Data
     /**
-     * Delivered to the recipient out of band, or kept for change: the
-     * output can be spent from this record and nothing else.
+     * 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 opening: Opening
+    public var note: Data
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
@@ -999,12 +1124,13 @@ public struct CreatedOutput: Equatable, Hashable {
          * Its published bytes, as an indexer will serve them once confirmed.
          */contract: Data, 
         /**
-         * Delivered to the recipient out of band, or kept for change: the
-         * output can be spent from this record and nothing else.
-         */opening: Opening) {
+         * 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.opening = opening
+        self.note = note
     }
 
     
@@ -1025,14 +1151,14 @@ public struct FfiConverterTypeCreatedOutput: FfiConverterRustBuffer {
             try CreatedOutput(
                 contractId: FfiConverterData.read(from: &buf), 
                 contract: FfiConverterData.read(from: &buf), 
-                opening: FfiConverterTypeOpening.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)
-        FfiConverterTypeOpening.write(value.opening, into: &buf)
+        FfiConverterData.write(value.note, into: &buf)
     }
 }
 
@@ -1250,6 +1376,75 @@ public func FfiConverterTypeOpening_lower(_ value: Opening) -> RustBuffer {
 }
 
 
+/**
+ * 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.
  */
@@ -1262,6 +1457,11 @@ public struct Transfer: Equatable, Hashable {
      * `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
@@ -1272,7 +1472,12 @@ public struct Transfer: Equatable, Hashable {
          */txid: Data, 
         /**
          * `BlockTx::to_bytes`: what a node's `submit_tx` takes.
-         */blockTx: Data, outputs: [CreatedOutput]) {
+         */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
@@ -1417,29 +1622,39 @@ public func FfiConverterTypeTransferInput_lower(_ value: TransferInput) -> RustB
  */
 public struct TransferOutput: Equatable, Hashable {
     /**
-     * The recipient's predicate: [`crate::address_to_predicate`], or
-     * [`crate::Wallet::address`] on the change branch.
+     * The recipient's bech32f address, for the wallet's network; for
+     * change, [`crate::Wallet::address`] on the change branch.
      */
-    public var predicate: Data
+    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 4006 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 predicate: [`crate::address_to_predicate`], or
-         * [`crate::Wallet::address`] on the change branch.
-         */predicate: Data, qty: UInt64, 
+         * 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?) {
-        self.predicate = predicate
+         */flavor: Data?, 
+        /**
+         * Sealed into the output's note with the amount; only the recipient
+         * reads it. At most 4006 bytes; empty for none.
+         */memo: Data) {
+        self.address = address
         self.qty = qty
         self.flavor = flavor
+        self.memo = memo
     }
 
     
@@ -1458,16 +1673,18 @@ public struct FfiConverterTypeTransferOutput: FfiConverterRustBuffer {
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransferOutput {
         return
             try TransferOutput(
-                predicate: FfiConverterData.read(from: &buf), 
+                address: FfiConverterString.read(from: &buf), 
                 qty: FfiConverterUInt64.read(from: &buf), 
-                flavor: FfiConverterOptionData.read(from: &buf)
+                flavor: FfiConverterOptionData.read(from: &buf), 
+                memo: FfiConverterData.read(from: &buf)
         )
     }
 
     public static func write(_ value: TransferOutput, into buf: inout [UInt8]) {
-        FfiConverterData.write(value.predicate, into: &buf)
+        FfiConverterString.write(value.address, into: &buf)
         FfiConverterUInt64.write(value.qty, into: &buf)
         FfiConverterOptionData.write(value.flavor, into: &buf)
+        FfiConverterData.write(value.memo, into: &buf)
     }
 }
 
@@ -1680,6 +1897,19 @@ enum FlameError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {
      */
     case InvalidSeed(reason: String
     )
+    /**
+     * A view or receiving key does not parse for the wallet's network, or
+     * flamekd refused to derive from the key a wallet holds.
+     */
+    case InvalidKey(reason: String
+    )
+    /**
+     * The wallet's key does not allow the call: a view wallet cannot
+     * spend, and a receive wallet can neither spend nor open notes.
+     * `wallet` is this wallet's kind, `needs` the least kind that could.
+     */
+    case NotPermitted(wallet: WalletKind, needs: WalletKind
+    )
     /**
      * An address does not parse for the wallet's network.
      */
@@ -1702,6 +1932,12 @@ enum FlameError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {
      */
     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.
      */
@@ -1742,20 +1978,31 @@ public struct FfiConverterTypeFlameError: FfiConverterRustBuffer {
         case 2: return .InvalidSeed(
             reason: try FfiConverterString.read(from: &buf)
             )
-        case 3: return .InvalidAddress(
+        case 3: return .InvalidKey(
+            reason: try FfiConverterString.read(from: &buf)
+            )
+        case 4: return .NotPermitted(
+            wallet: try FfiConverterTypeWalletKind.read(from: &buf), 
+            needs: try FfiConverterTypeWalletKind.read(from: &buf)
+            )
+        case 5: return .InvalidAddress(
             reason: try FfiConverterString.read(from: &buf)
             )
-        case 4: return .InvalidKeyPath(
+        case 6: return .InvalidKeyPath(
             reason: try FfiConverterString.read(from: &buf)
             )
-        case 5: return .InvalidBytes(
+        case 7: return .InvalidBytes(
             what: try FfiConverterString.read(from: &buf), 
             reason: try FfiConverterString.read(from: &buf)
             )
-        case 6: return .KeyMismatch(
+        case 8: return .KeyMismatch(
             input: try FfiConverterUInt32.read(from: &buf)
             )
-        case 7: return .Transfer(
+        case 9: return .Note(
+            failure: try FfiConverterTypeNoteFailure.read(from: &buf), 
+            reason: try FfiConverterString.read(from: &buf)
+            )
+        case 10: return .Transfer(
             reason: try FfiConverterString.read(from: &buf)
             )
 
@@ -1780,29 +2027,46 @@ public struct FfiConverterTypeFlameError: FfiConverterRustBuffer {
             FfiConverterString.write(reason, into: &buf)
             
         
-        case let .InvalidAddress(reason):
+        case let .InvalidKey(reason):
             writeInt(&buf, Int32(3))
             FfiConverterString.write(reason, into: &buf)
             
         
-        case let .InvalidKeyPath(reason):
+        case let .NotPermitted(wallet,needs):
             writeInt(&buf, Int32(4))
+            FfiConverterTypeWalletKind.write(wallet, into: &buf)
+            FfiConverterTypeWalletKind.write(needs, into: &buf)
+            
+        
+        case let .InvalidAddress(reason):
+            writeInt(&buf, Int32(5))
+            FfiConverterString.write(reason, into: &buf)
+            
+        
+        case let .InvalidKeyPath(reason):
+            writeInt(&buf, Int32(6))
             FfiConverterString.write(reason, into: &buf)
             
         
         case let .InvalidBytes(what,reason):
-            writeInt(&buf, Int32(5))
+            writeInt(&buf, Int32(7))
             FfiConverterString.write(what, into: &buf)
             FfiConverterString.write(reason, into: &buf)
             
         
         case let .KeyMismatch(input):
-            writeInt(&buf, Int32(6))
+            writeInt(&buf, Int32(8))
             FfiConverterUInt32.write(input, into: &buf)
             
         
+        case let .Note(failure,reason):
+            writeInt(&buf, Int32(9))
+            FfiConverterTypeNoteFailure.write(failure, into: &buf)
+            FfiConverterString.write(reason, into: &buf)
+            
+        
         case let .Transfer(reason):
-            writeInt(&buf, Int32(7))
+            writeInt(&buf, Int32(10))
             FfiConverterString.write(reason, into: &buf)
             
         }
@@ -1893,6 +2157,212 @@ public func FfiConverterTypeNetwork_lower(_ value: Network) -> RustBuffer {
 }
 
 
+
+/**
+ * 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)
+}
+
+
+
+/**
+ * What a [`Wallet`] was built from, and so what it can do. Each kind can
+ * do everything the next one can.
+ */
+
+public enum WalletKind: Equatable, Hashable {
+    
+    /**
+     * From a seed or mnemonic: finds, opens and spends.
+     */
+    case spend
+    /**
+     * From a view key: finds and opens every payment, cannot spend.
+     */
+    case view
+    /**
+     * From a receiving key: finds every payment, cannot open or spend.
+     */
+    case receive
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension WalletKind: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeWalletKind: FfiConverterRustBuffer {
+    typealias SwiftType = WalletKind
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> WalletKind {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .spend
+        
+        case 2: return .view
+        
+        case 3: return .receive
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: WalletKind, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .spend:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .view:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .receive:
+            writeInt(&buf, Int32(3))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWalletKind_lift(_ buf: RustBuffer) throws -> WalletKind {
+    return try FfiConverterTypeWalletKind.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeWalletKind_lower(_ value: WalletKind) -> RustBuffer {
+    return FfiConverterTypeWalletKind.lower(value)
+}
+
+
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
@@ -2151,7 +2621,10 @@ private let initializationResult: InitializationResult = {
     if (uniffi_flamewallet_ffi_checksum_method_wallet_address() != 24772) {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer() != 41970) {
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer() != 38498) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_kind() != 48257) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_flamewallet_ffi_checksum_method_wallet_network() != 6461) {
@@ -2163,15 +2636,27 @@ private let initializationResult: InitializationResult = {
     if (uniffi_flamewallet_ffi_checksum_method_wallet_next_index() != 50043) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_open_note() != 63642) {
+        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_method_wallet_view_key() != 51879) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_flamewallet_ffi_checksum_constructor_wallet_from_mnemonic() != 19125) {
         return InitializationResult.apiChecksumMismatch
     }
+    if (uniffi_flamewallet_ffi_checksum_constructor_wallet_from_receiving_key() != 30262) {
+        return InitializationResult.apiChecksumMismatch
+    }
+    if (uniffi_flamewallet_ffi_checksum_constructor_wallet_from_view_key() != 5669) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_flamewallet_ffi_checksum_constructor_wallet_new() != 9773) {
         return InitializationResult.apiChecksumMismatch
     }