@runflame/wallet-rn 0.0.1-rc.7 → 0.0.1-rc.8

package/FlameWalletNative.podspec

@@ -2,12 +2,12 @@ Pod::Spec.new do |s|
   s.name             = 'FlameWalletNative'
   # Swift code imports the bindings as `FlameWallet`.
   s.module_name      = 'FlameWallet'
-  s.version          = '0.0.1-rc.7'
+  s.version          = '0.0.1-rc.8'
   s.summary          = 'Flame wallet keys and confidential transfers, with UniFFI Swift bindings'
   s.homepage         = 'https://github.com/runflame/flame-lib'
   s.license          = { :type => 'Apache-2.0', :file => 'LICENSE.txt' }
   s.author           = 'Runflame'
-  s.source           = { :git => 'https://github.com/runflame/flame-lib.git', :tag => 'flamewallet-v0.0.1-rc.7' }
+  s.source           = { :git => 'https://github.com/runflame/flame-lib.git', :tag => 'flamewallet-v0.0.1-rc.8' }
   s.platforms        = { :ios => '15.1' }
   s.swift_version    = '5.9'
   s.source_files     = 'ios/FlameWallet.swift'

package/android/build.gradle

@@ -11,7 +11,7 @@ android {
 
   defaultConfig {
     minSdk 24
-    versionName '0.0.1-rc.7'
+    versionName '0.0.1-rc.8'
   }
 
   compileOptions {

package/android/src/main/java/com/flame/wallet/flamewallet_ffi.kt

@@ -691,6 +691,8 @@ internal object IntegrityCheckingUniffiLib {
     ): Int
     external fun uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer(
     ): Int
+    external fun uniffi_flamewallet_ffi_checksum_method_wallet_kind(
+    ): Int
     external fun uniffi_flamewallet_ffi_checksum_method_wallet_network(
     ): Int
     external fun uniffi_flamewallet_ffi_checksum_method_wallet_next_address(
@@ -707,6 +709,10 @@ internal object IntegrityCheckingUniffiLib {
     ): Int
     external fun uniffi_flamewallet_ffi_checksum_constructor_wallet_from_mnemonic(
     ): Int
+    external fun uniffi_flamewallet_ffi_checksum_constructor_wallet_from_receiving_key(
+    ): Int
+    external fun uniffi_flamewallet_ffi_checksum_constructor_wallet_from_view_key(
+    ): Int
     external fun uniffi_flamewallet_ffi_checksum_constructor_wallet_new(
     ): Int
     external fun ffi_flamewallet_ffi_uniffi_contract_version(
@@ -735,12 +741,18 @@ internal object UniffiLib {
     ): Unit
     external fun uniffi_flamewallet_ffi_fn_constructor_wallet_from_mnemonic(`phrase`: RustBuffer.ByValue,`passphrase`: RustBuffer.ByValue,`network`: RustBuffer.ByValue,`nextIndex`: Int,uniffi_out_err: UniffiRustCallStatus, 
     ): Long
+    external fun uniffi_flamewallet_ffi_fn_constructor_wallet_from_receiving_key(`receivingKey`: RustBuffer.ByValue,`network`: RustBuffer.ByValue,`nextIndex`: Int,uniffi_out_err: UniffiRustCallStatus, 
+    ): Long
+    external fun uniffi_flamewallet_ffi_fn_constructor_wallet_from_view_key(`viewKey`: RustBuffer.ByValue,`network`: RustBuffer.ByValue,`nextIndex`: Int,uniffi_out_err: UniffiRustCallStatus, 
+    ): Long
     external fun uniffi_flamewallet_ffi_fn_constructor_wallet_new(`seed`: RustBuffer.ByValue,`network`: RustBuffer.ByValue,`nextIndex`: Int,uniffi_out_err: UniffiRustCallStatus, 
     ): Long
     external fun uniffi_flamewallet_ffi_fn_method_wallet_address(`ptr`: Long,`path`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
     ): RustBuffer.ByValue
     external fun uniffi_flamewallet_ffi_fn_method_wallet_build_transfer(`ptr`: Long,`request`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
     ): RustBuffer.ByValue
+    external fun uniffi_flamewallet_ffi_fn_method_wallet_kind(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+    ): RustBuffer.ByValue
     external fun uniffi_flamewallet_ffi_fn_method_wallet_network(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
     ): RustBuffer.ByValue
     external fun uniffi_flamewallet_ffi_fn_method_wallet_next_address(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
@@ -907,7 +919,10 @@ private fun uniffiCheckApiChecksums(lib: IntegrityCheckingUniffiLib) {
     if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_address() and 0xFFFF) != 24772) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
-    if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer() and 0xFFFF) != 41970) {
+    if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer() and 0xFFFF) != 38498) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_kind() and 0xFFFF) != 48257) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
     if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_network() and 0xFFFF) != 6461) {
@@ -919,7 +934,7 @@ private fun uniffiCheckApiChecksums(lib: IntegrityCheckingUniffiLib) {
     if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_next_index() and 0xFFFF) != 50043) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
-    if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_open_note() and 0xFFFF) != 45629) {
+    if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_open_note() and 0xFFFF) != 63642) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
     if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_owns() and 0xFFFF) != 34274) {
@@ -928,12 +943,18 @@ private fun uniffiCheckApiChecksums(lib: IntegrityCheckingUniffiLib) {
     if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_receiving_key() and 0xFFFF) != 41950) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
-    if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_view_key() and 0xFFFF) != 33149) {
+    if ((lib.uniffi_flamewallet_ffi_checksum_method_wallet_view_key() and 0xFFFF) != 51879) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
     if ((lib.uniffi_flamewallet_ffi_checksum_constructor_wallet_from_mnemonic() and 0xFFFF) != 19125) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
+    if ((lib.uniffi_flamewallet_ffi_checksum_constructor_wallet_from_receiving_key() and 0xFFFF) != 30262) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
+    if ((lib.uniffi_flamewallet_ffi_checksum_constructor_wallet_from_view_key() and 0xFFFF) != 5669) {
+        throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
+    }
     if ((lib.uniffi_flamewallet_ffi_checksum_constructor_wallet_new() and 0xFFFF) != 9773) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
@@ -1365,8 +1386,11 @@ public object FfiConverterByteArray: FfiConverterRustBuffer<ByteArray> {
 /**
  * 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.
@@ -1386,9 +1410,17 @@ public interface WalletInterface {
      * 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.
      */
     fun `buildTransfer`(`request`: TransferRequest): Transfer
     
+    /**
+     * What this wallet was built from, and so what it can do.
+     */
+    fun `kind`(): WalletKind
+    
     /**
      * The network this wallet's addresses are encoded for.
      */
@@ -1409,6 +1441,7 @@ public interface WalletInterface {
      * 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.
      */
     fun `openNote`(`contract`: kotlin.ByteArray, `note`: kotlin.ByteArray?, `path`: KeyPath): ReceivedNote
     
@@ -1429,9 +1462,9 @@ public interface WalletInterface {
     
     /**
      * The account's view key in bech32f (`view1…` / `testview1…`): what a
-     * watch-only wallet is given. It derives every address and opens every
+     * 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.
+     * it as a secret. A receive wallet has none to give.
      */
     fun `viewKey`(): kotlin.String
     
@@ -1441,8 +1474,11 @@ public interface WalletInterface {
 /**
  * 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.
@@ -1593,6 +1629,9 @@ open class Wallet: Disposable, AutoCloseable, WalletInterface
      * 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.
      */
     @Throws(FlameException::class)override fun `buildTransfer`(`request`: TransferRequest): Transfer {
             return FfiConverterTypeTransfer.lift(
@@ -1609,6 +1648,22 @@ open class Wallet: Disposable, AutoCloseable, WalletInterface
     
 
     
+    /**
+     * What this wallet was built from, and so what it can do.
+     */override fun `kind`(): WalletKind {
+            return FfiConverterTypeWalletKind.lift(
+    callWithHandle {
+    uniffiRustCall() { _status ->
+    UniffiLib.uniffi_flamewallet_ffi_fn_method_wallet_kind(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    
     /**
      * The network this wallet's addresses are encoded for.
      */override fun `network`(): Network {
@@ -1663,6 +1718,7 @@ open class Wallet: Disposable, AutoCloseable, WalletInterface
      * 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.
      */
     @Throws(FlameException::class)override fun `openNote`(`contract`: kotlin.ByteArray, `note`: kotlin.ByteArray?, `path`: KeyPath): ReceivedNote {
             return FfiConverterTypeReceivedNote.lift(
@@ -1723,13 +1779,14 @@ open class Wallet: Disposable, AutoCloseable, WalletInterface
     
     /**
      * The account's view key in bech32f (`view1…` / `testview1…`): what a
-     * watch-only wallet is given. It derives every address and opens every
+     * 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.
-     */override fun `viewKey`(): kotlin.String {
+     * it as a secret. A receive wallet has none to give.
+     */
+    @Throws(FlameException::class)override fun `viewKey`(): kotlin.String {
             return FfiConverterString.lift(
     callWithHandle {
-    uniffiRustCall() { _status ->
+    uniffiRustCallWithError(FlameException) { _status ->
     UniffiLib.uniffi_flamewallet_ffi_fn_method_wallet_view_key(
         it,
         _status)
@@ -1767,6 +1824,58 @@ open class Wallet: Disposable, AutoCloseable, WalletInterface
     
 
         
+    /**
+     * 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.
+     */
+    @Throws(FlameException::class) fun `fromReceivingKey`(`receivingKey`: kotlin.String, `network`: Network, `nextIndex`: kotlin.UInt): Wallet {
+            return FfiConverterTypeWallet.lift(
+    uniffiRustCallWithError(FlameException) { _status ->
+    UniffiLib.uniffi_flamewallet_ffi_fn_constructor_wallet_from_receiving_key(
+    
+        
+        FfiConverterString.lower(`receivingKey`),
+        FfiConverterTypeNetwork.lower(`network`),
+        FfiConverterUInt.lower(`nextIndex`),_status)
+}
+    )
+    }
+    
+
+        
+    /**
+     * 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`.
+     */
+    @Throws(FlameException::class) fun `fromViewKey`(`viewKey`: kotlin.String, `network`: Network, `nextIndex`: kotlin.UInt): Wallet {
+            return FfiConverterTypeWallet.lift(
+    uniffiRustCallWithError(FlameException) { _status ->
+    UniffiLib.uniffi_flamewallet_ffi_fn_constructor_wallet_from_view_key(
+    
+        
+        FfiConverterString.lower(`viewKey`),
+        FfiConverterTypeNetwork.lower(`network`),
+        FfiConverterUInt.lower(`nextIndex`),_status)
+}
+    )
+    }
+    
+
+        
     }
     
 }
@@ -2476,6 +2585,33 @@ sealed class FlameException: kotlin.Exception() {
             get() = "reason=${ `reason` }"
     }
     
+    /**
+     * A view or receiving key does not parse for the wallet's network, or
+     * flamekd refused to derive from the key a wallet holds.
+     */
+    class InvalidKey(
+        
+        val `reason`: kotlin.String
+        ) : FlameException() {
+        override val message
+            get() = "reason=${ `reason` }"
+    }
+    
+    /**
+     * 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.
+     */
+    class NotPermitted(
+        
+        val `wallet`: WalletKind, 
+        
+        val `needs`: WalletKind
+        ) : FlameException() {
+        override val message
+            get() = "wallet=${ `wallet` }, needs=${ `needs` }"
+    }
+    
     /**
      * An address does not parse for the wallet's network.
      */
@@ -2574,24 +2710,31 @@ public object FfiConverterTypeFlameError : FfiConverterRustBuffer<FlameException
             2 -> FlameException.InvalidSeed(
                 FfiConverterString.read(buf),
                 )
-            3 -> FlameException.InvalidAddress(
+            3 -> FlameException.InvalidKey(
+                FfiConverterString.read(buf),
+                )
+            4 -> FlameException.NotPermitted(
+                FfiConverterTypeWalletKind.read(buf),
+                FfiConverterTypeWalletKind.read(buf),
+                )
+            5 -> FlameException.InvalidAddress(
                 FfiConverterString.read(buf),
                 )
-            4 -> FlameException.InvalidKeyPath(
+            6 -> FlameException.InvalidKeyPath(
                 FfiConverterString.read(buf),
                 )
-            5 -> FlameException.InvalidBytes(
+            7 -> FlameException.InvalidBytes(
                 FfiConverterString.read(buf),
                 FfiConverterString.read(buf),
                 )
-            6 -> FlameException.KeyMismatch(
+            8 -> FlameException.KeyMismatch(
                 FfiConverterUInt.read(buf),
                 )
-            7 -> FlameException.Note(
+            9 -> FlameException.Note(
                 FfiConverterTypeNoteFailure.read(buf),
                 FfiConverterString.read(buf),
                 )
-            8 -> FlameException.Transfer(
+            10 -> FlameException.Transfer(
                 FfiConverterString.read(buf),
                 )
             else -> throw RuntimeException("invalid error enum value, something is very wrong!!")
@@ -2610,6 +2753,17 @@ public object FfiConverterTypeFlameError : FfiConverterRustBuffer<FlameException
                 4UL
                 + FfiConverterString.allocationSize(value.`reason`)
             )
+            is FlameException.InvalidKey -> (
+                // Add the size for the Int that specifies the variant plus the size needed for all fields
+                4UL
+                + FfiConverterString.allocationSize(value.`reason`)
+            )
+            is FlameException.NotPermitted -> (
+                // Add the size for the Int that specifies the variant plus the size needed for all fields
+                4UL
+                + FfiConverterTypeWalletKind.allocationSize(value.`wallet`)
+                + FfiConverterTypeWalletKind.allocationSize(value.`needs`)
+            )
             is FlameException.InvalidAddress -> (
                 // Add the size for the Int that specifies the variant plus the size needed for all fields
                 4UL
@@ -2657,35 +2811,46 @@ public object FfiConverterTypeFlameError : FfiConverterRustBuffer<FlameException
                 FfiConverterString.write(value.`reason`, buf)
                 Unit
             }
-            is FlameException.InvalidAddress -> {
+            is FlameException.InvalidKey -> {
                 buf.putInt(3)
                 FfiConverterString.write(value.`reason`, buf)
                 Unit
             }
-            is FlameException.InvalidKeyPath -> {
+            is FlameException.NotPermitted -> {
                 buf.putInt(4)
+                FfiConverterTypeWalletKind.write(value.`wallet`, buf)
+                FfiConverterTypeWalletKind.write(value.`needs`, buf)
+                Unit
+            }
+            is FlameException.InvalidAddress -> {
+                buf.putInt(5)
+                FfiConverterString.write(value.`reason`, buf)
+                Unit
+            }
+            is FlameException.InvalidKeyPath -> {
+                buf.putInt(6)
                 FfiConverterString.write(value.`reason`, buf)
                 Unit
             }
             is FlameException.InvalidBytes -> {
-                buf.putInt(5)
+                buf.putInt(7)
                 FfiConverterString.write(value.`what`, buf)
                 FfiConverterString.write(value.`reason`, buf)
                 Unit
             }
             is FlameException.KeyMismatch -> {
-                buf.putInt(6)
+                buf.putInt(8)
                 FfiConverterUInt.write(value.`input`, buf)
                 Unit
             }
             is FlameException.Note -> {
-                buf.putInt(7)
+                buf.putInt(9)
                 FfiConverterTypeNoteFailure.write(value.`failure`, buf)
                 FfiConverterString.write(value.`reason`, buf)
                 Unit
             }
             is FlameException.Transfer -> {
-                buf.putInt(8)
+                buf.putInt(10)
                 FfiConverterString.write(value.`reason`, buf)
                 Unit
             }
@@ -2797,6 +2962,54 @@ public object FfiConverterTypeNoteFailure: FfiConverterRustBuffer<NoteFailure> {
 
 
 
+/**
+ * What a [`Wallet`] was built from, and so what it can do. Each kind can
+ * do everything the next one can.
+ */
+
+enum class WalletKind {
+    
+    /**
+     * From a seed or mnemonic: finds, opens and spends.
+     */
+    SPEND,
+    /**
+     * From a view key: finds and opens every payment, cannot spend.
+     */
+    VIEW,
+    /**
+     * From a receiving key: finds every payment, cannot open or spend.
+     */
+    RECEIVE;
+
+    
+
+
+    companion object
+}
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeWalletKind: FfiConverterRustBuffer<WalletKind> {
+    override fun read(buf: ByteBuffer) = try {
+        WalletKind.values()[buf.getInt() - 1]
+    } catch (e: IndexOutOfBoundsException) {
+        throw RuntimeException("invalid enum value, something is very wrong!!", e)
+    }
+
+    override fun allocationSize(value: WalletKind) = 4UL
+
+    override fun write(value: WalletKind, buf: ByteBuffer) {
+        buf.putInt(value.ordinal + 1)
+    }
+}
+
+
+
+
+
 
 /**
  * @suppress

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.
      */
@@ -648,6 +659,7 @@ public protocol WalletProtocol: AnyObject, Sendable {
      * 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
     
@@ -668,18 +680,21 @@ public protocol WalletProtocol: AnyObject, Sendable {
     
     /**
      * The account's view key in bech32f (`view1…` / `testview1…`): what a
-     * watch-only wallet is given. It derives every address and opens every
+     * 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.
+     * it as a secret. A receive wallet has none to give.
      */
-    func viewKey()  -> String
+    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.
@@ -769,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
+    )
+})
+}
+    
 
     
     /**
@@ -792,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) {
@@ -801,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
+    )
+})
 }
     
     /**
@@ -844,6 +918,7 @@ open func nextIndex() -> UInt32  {
      * 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) {
@@ -890,12 +965,12 @@ open func receivingKey() -> String  {
     
     /**
      * The account's view key in bech32f (`view1…` / `testview1…`): what a
-     * watch-only wallet is given. It derives every address and opens every
+     * 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.
+     * it as a secret. A receive wallet has none to give.
      */
-open func viewKey() -> String  {
-    return try!  FfiConverterString.lift(try! rustCall() {
+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
@@ -1822,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.
      */
@@ -1890,24 +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 .Note(
+        case 9: return .Note(
             failure: try FfiConverterTypeNoteFailure.read(from: &buf), 
             reason: try FfiConverterString.read(from: &buf)
             )
-        case 8: return .Transfer(
+        case 10: return .Transfer(
             reason: try FfiConverterString.read(from: &buf)
             )
 
@@ -1932,35 +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(7))
+            writeInt(&buf, Int32(9))
             FfiConverterTypeNoteFailure.write(failure, into: &buf)
             FfiConverterString.write(reason, into: &buf)
             
         
         case let .Transfer(reason):
-            writeInt(&buf, Int32(8))
+            writeInt(&buf, Int32(10))
             FfiConverterString.write(reason, into: &buf)
             
         }
@@ -2171,6 +2277,92 @@ public func FfiConverterTypeNoteFailure_lower(_ value: NoteFailure) -> RustBuffe
 }
 
 
+
+/**
+ * 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
@@ -2429,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) {
@@ -2441,7 +2636,7 @@ 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() != 45629) {
+    if (uniffi_flamewallet_ffi_checksum_method_wallet_open_note() != 63642) {
         return InitializationResult.apiChecksumMismatch
     }
     if (uniffi_flamewallet_ffi_checksum_method_wallet_owns() != 34274) {
@@ -2450,12 +2645,18 @@ private let initializationResult: InitializationResult = {
     if (uniffi_flamewallet_ffi_checksum_method_wallet_receiving_key() != 41950) {
         return InitializationResult.apiChecksumMismatch
     }
-    if (uniffi_flamewallet_ffi_checksum_method_wallet_view_key() != 33149) {
+    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
     }

package/ios/FlameWalletFFI.xcframework/ios-arm64/FlameWalletFFI.framework/Headers/FlameWalletFFI.h

@@ -258,6 +258,16 @@ void uniffi_flamewallet_ffi_fn_free_wallet(uint64_t handle, RustCallStatus *_Non
 uint64_t uniffi_flamewallet_ffi_fn_constructor_wallet_from_mnemonic(RustBuffer phrase, RustBuffer passphrase, RustBuffer network, uint32_t next_index, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_FROM_RECEIVING_KEY
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_FROM_RECEIVING_KEY
+uint64_t uniffi_flamewallet_ffi_fn_constructor_wallet_from_receiving_key(RustBuffer receiving_key, RustBuffer network, uint32_t next_index, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_FROM_VIEW_KEY
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_FROM_VIEW_KEY
+uint64_t uniffi_flamewallet_ffi_fn_constructor_wallet_from_view_key(RustBuffer view_key, RustBuffer network, uint32_t next_index, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_NEW
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_NEW
 uint64_t uniffi_flamewallet_ffi_fn_constructor_wallet_new(RustBuffer seed, RustBuffer network, uint32_t next_index, RustCallStatus *_Nonnull out_status
@@ -273,6 +283,11 @@ RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_address(uint64_t ptr, RustBuf
 RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_build_transfer(uint64_t ptr, RustBuffer request, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_KIND
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_KIND
+RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_kind(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_NETWORK
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_NETWORK
 RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_network(uint64_t ptr, RustCallStatus *_Nonnull out_status
@@ -644,6 +659,12 @@ uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_address(void
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_BUILD_TRANSFER
 uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_KIND
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_KIND
+uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_kind(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_NETWORK
@@ -692,6 +713,18 @@ uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_view_key(void
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_MNEMONIC
 uint16_t uniffi_flamewallet_ffi_checksum_constructor_wallet_from_mnemonic(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_RECEIVING_KEY
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_RECEIVING_KEY
+uint16_t uniffi_flamewallet_ffi_checksum_constructor_wallet_from_receiving_key(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_VIEW_KEY
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_VIEW_KEY
+uint16_t uniffi_flamewallet_ffi_checksum_constructor_wallet_from_view_key(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_NEW

package/ios/FlameWalletFFI.xcframework/ios-arm64_x86_64-simulator/FlameWalletFFI.framework/Headers/FlameWalletFFI.h

@@ -258,6 +258,16 @@ void uniffi_flamewallet_ffi_fn_free_wallet(uint64_t handle, RustCallStatus *_Non
 uint64_t uniffi_flamewallet_ffi_fn_constructor_wallet_from_mnemonic(RustBuffer phrase, RustBuffer passphrase, RustBuffer network, uint32_t next_index, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_FROM_RECEIVING_KEY
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_FROM_RECEIVING_KEY
+uint64_t uniffi_flamewallet_ffi_fn_constructor_wallet_from_receiving_key(RustBuffer receiving_key, RustBuffer network, uint32_t next_index, RustCallStatus *_Nonnull out_status
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_FROM_VIEW_KEY
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_FROM_VIEW_KEY
+uint64_t uniffi_flamewallet_ffi_fn_constructor_wallet_from_view_key(RustBuffer view_key, RustBuffer network, uint32_t next_index, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_NEW
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_CONSTRUCTOR_WALLET_NEW
 uint64_t uniffi_flamewallet_ffi_fn_constructor_wallet_new(RustBuffer seed, RustBuffer network, uint32_t next_index, RustCallStatus *_Nonnull out_status
@@ -273,6 +283,11 @@ RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_address(uint64_t ptr, RustBuf
 RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_build_transfer(uint64_t ptr, RustBuffer request, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_KIND
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_KIND
+RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_kind(uint64_t ptr, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_NETWORK
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_NETWORK
 RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_network(uint64_t ptr, RustCallStatus *_Nonnull out_status
@@ -644,6 +659,12 @@ uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_address(void
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_BUILD_TRANSFER
 uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_KIND
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_KIND
+uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_kind(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_NETWORK
@@ -692,6 +713,18 @@ uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_view_key(void
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_MNEMONIC
 uint16_t uniffi_flamewallet_ffi_checksum_constructor_wallet_from_mnemonic(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_RECEIVING_KEY
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_RECEIVING_KEY
+uint16_t uniffi_flamewallet_ffi_checksum_constructor_wallet_from_receiving_key(void
+    
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_VIEW_KEY
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_FROM_VIEW_KEY
+uint16_t uniffi_flamewallet_ffi_checksum_constructor_wallet_from_view_key(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_CONSTRUCTOR_WALLET_NEW

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runflame/wallet-rn",
-  "version": "0.0.1-rc.7",
+  "version": "0.0.1-rc.8",
   "description": "Flame wallet keys and confidential transfers for iOS and Android: prebuilt libraries with UniFFI Swift and Kotlin bindings",
   "license": "Apache-2.0",
   "repository": {

package/sbom.cdx.json

@@ -2,9 +2,9 @@
   "bomFormat": "CycloneDX",
   "specVersion": "1.3",
   "version": 1,
-  "serialNumber": "urn:uuid:d23e231b-a2eb-4711-9e9a-4a4c8fb29bc0",
+  "serialNumber": "urn:uuid:62ec18a0-f6b6-4ac4-97c3-37ec6f64c927",
   "metadata": {
-    "timestamp": "2026-10-07T17:11:15.619085000Z",
+    "timestamp": "2026-10-08T12:25:09.621829000Z",
     "tools": [
       {
         "vendor": "CycloneDX",