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

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

@@ -691,18 +691,28 @@ 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(
     ): Int
     external fun uniffi_flamewallet_ffi_checksum_method_wallet_next_index(
     ): Int
+    external fun uniffi_flamewallet_ffi_checksum_method_wallet_open_note(
+    ): Int
     external fun uniffi_flamewallet_ffi_checksum_method_wallet_owns(
     ): Int
     external fun uniffi_flamewallet_ffi_checksum_method_wallet_receiving_key(
     ): Int
+    external fun uniffi_flamewallet_ffi_checksum_method_wallet_view_key(
+    ): 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(
@@ -731,22 +741,32 @@ 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, 
     ): RustBuffer.ByValue
     external fun uniffi_flamewallet_ffi_fn_method_wallet_next_index(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
     ): Int
+    external fun uniffi_flamewallet_ffi_fn_method_wallet_open_note(`ptr`: Long,`contract`: RustBuffer.ByValue,`note`: RustBuffer.ByValue,`path`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
+    ): RustBuffer.ByValue
     external fun uniffi_flamewallet_ffi_fn_method_wallet_owns(`ptr`: Long,`predicate`: RustBuffer.ByValue,`gap`: Int,uniffi_out_err: UniffiRustCallStatus, 
     ): RustBuffer.ByValue
     external fun uniffi_flamewallet_ffi_fn_method_wallet_receiving_key(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
     ): RustBuffer.ByValue
+    external fun uniffi_flamewallet_ffi_fn_method_wallet_view_key(`ptr`: Long,uniffi_out_err: UniffiRustCallStatus, 
+    ): RustBuffer.ByValue
     external fun uniffi_flamewallet_ffi_fn_func_decode_contract(`bytes`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
     ): RustBuffer.ByValue
     external fun uniffi_flamewallet_ffi_fn_func_opening_matches(`contract`: RustBuffer.ByValue,`opening`: RustBuffer.ByValue,uniffi_out_err: UniffiRustCallStatus, 
@@ -899,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) {
@@ -911,15 +934,27 @@ 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) != 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) {
         throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     }
     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) != 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")
     }
@@ -1351,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.
@@ -1372,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.
      */
@@ -1390,6 +1436,15 @@ public interface WalletInterface {
      */
     fun `nextIndex`(): kotlin.UInt
     
+    /**
+     * 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.
+     */
+    fun `openNote`(`contract`: kotlin.ByteArray, `note`: kotlin.ByteArray?, `path`: KeyPath): ReceivedNote
+    
     /**
      * Which path below `next_index + gap`, on either branch, owns
      * `predicate`; `None` if none does. The scan re-derives every address
@@ -1405,14 +1460,25 @@ public interface WalletInterface {
      */
     fun `receivingKey`(): kotlin.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.
+     */
+    fun `viewKey`(): kotlin.String
+    
     companion object
 }
 
 /**
  * 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.
@@ -1563,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(
@@ -1579,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 {
@@ -1628,6 +1713,30 @@ open class Wallet: Disposable, AutoCloseable, WalletInterface
     
 
     
+    /**
+     * 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.
+     */
+    @Throws(FlameException::class)override fun `openNote`(`contract`: kotlin.ByteArray, `note`: kotlin.ByteArray?, `path`: KeyPath): ReceivedNote {
+            return FfiConverterTypeReceivedNote.lift(
+    callWithHandle {
+    uniffiRustCallWithError(FlameException) { _status ->
+    UniffiLib.uniffi_flamewallet_ffi_fn_method_wallet_open_note(
+        it,
+        
+        FfiConverterByteArray.lower(`contract`),
+        FfiConverterOptionalByteArray.lower(`note`),
+        FfiConverterTypeKeyPath.lower(`path`),_status)
+}
+    }
+    )
+    }
+    
+
+    
     /**
      * Which path below `next_index + gap`, on either branch, owns
      * `predicate`; `None` if none does. The scan re-derives every address
@@ -1668,6 +1777,26 @@ open class Wallet: Disposable, AutoCloseable, WalletInterface
     
 
     
+    /**
+     * 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.
+     */
+    @Throws(FlameException::class)override fun `viewKey`(): kotlin.String {
+            return FfiConverterString.lift(
+    callWithHandle {
+    uniffiRustCallWithError(FlameException) { _status ->
+    UniffiLib.uniffi_flamewallet_ffi_fn_method_wallet_view_key(
+        it,
+        _status)
+}
+    }
+    )
+    }
+    
+
+    
 
     
 
@@ -1695,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)
+}
+    )
+    }
+    
+
+        
     }
     
 }
@@ -1779,7 +1960,7 @@ public object FfiConverterTypeContractInfo: FfiConverterRustBuffer<ContractInfo>
 
 
 /**
- * One contract the transfer creates, in request order.
+ * One contract the transfer creates.
  */
 data class CreatedOutput (
     var `contractId`: kotlin.ByteArray
@@ -1790,10 +1971,11 @@ data class CreatedOutput (
     var `contract`: kotlin.ByteArray
     , 
     /**
-     * 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.
      */
-    var `opening`: Opening
+    var `note`: kotlin.ByteArray
     
 ){
     
@@ -1812,20 +1994,20 @@ public object FfiConverterTypeCreatedOutput: FfiConverterRustBuffer<CreatedOutpu
         return CreatedOutput(
             FfiConverterByteArray.read(buf),
             FfiConverterByteArray.read(buf),
-            FfiConverterTypeOpening.read(buf),
+            FfiConverterByteArray.read(buf),
         )
     }
 
     override fun allocationSize(value: CreatedOutput) = (
             FfiConverterByteArray.allocationSize(value.`contractId`) +
             FfiConverterByteArray.allocationSize(value.`contract`) +
-            FfiConverterTypeOpening.allocationSize(value.`opening`)
+            FfiConverterByteArray.allocationSize(value.`note`)
     )
 
     override fun write(value: CreatedOutput, buf: ByteBuffer) {
             FfiConverterByteArray.write(value.`contractId`, buf)
             FfiConverterByteArray.write(value.`contract`, buf)
-            FfiConverterTypeOpening.write(value.`opening`, buf)
+            FfiConverterByteArray.write(value.`note`, buf)
     }
 }
 
@@ -1978,6 +2160,53 @@ public object FfiConverterTypeOpening: FfiConverterRustBuffer<Opening> {
 
 
 
+/**
+ * What an opened note gives its recipient.
+ */
+data class ReceivedNote (
+    /**
+     * What a [`crate::TransferInput`] spends the output with.
+     */
+    var `opening`: Opening
+    , 
+    /**
+     * The memo, as the sender wrote it.
+     */
+    var `memo`: kotlin.ByteArray
+    
+){
+    
+
+    
+
+    
+    companion object
+}
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeReceivedNote: FfiConverterRustBuffer<ReceivedNote> {
+    override fun read(buf: ByteBuffer): ReceivedNote {
+        return ReceivedNote(
+            FfiConverterTypeOpening.read(buf),
+            FfiConverterByteArray.read(buf),
+        )
+    }
+
+    override fun allocationSize(value: ReceivedNote) = (
+            FfiConverterTypeOpening.allocationSize(value.`opening`) +
+            FfiConverterByteArray.allocationSize(value.`memo`)
+    )
+
+    override fun write(value: ReceivedNote, buf: ByteBuffer) {
+            FfiConverterTypeOpening.write(value.`opening`, buf)
+            FfiConverterByteArray.write(value.`memo`, buf)
+    }
+}
+
+
+
 /**
  * A signed transfer, ready to publish.
  */
@@ -1992,6 +2221,11 @@ data class Transfer (
      */
     var `blockTx`: kotlin.ByteArray
     , 
+    /**
+     * 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.
+     */
     var `outputs`: List<CreatedOutput>
     
 ){
@@ -2098,10 +2332,10 @@ public object FfiConverterTypeTransferInput: FfiConverterRustBuffer<TransferInpu
  */
 data class TransferOutput (
     /**
-     * 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.
      */
-    var `predicate`: kotlin.ByteArray
+    var `address`: kotlin.String
     , 
     var `qty`: kotlin.ULong
     , 
@@ -2109,6 +2343,12 @@ data class TransferOutput (
      * `None` for flames.
      */
     var `flavor`: kotlin.ByteArray?
+    , 
+    /**
+     * Sealed into the output's note with the amount; only the recipient
+     * reads it. At most 4006 bytes; empty for none.
+     */
+    var `memo`: kotlin.ByteArray
     
 ){
     
@@ -2125,22 +2365,25 @@ data class TransferOutput (
 public object FfiConverterTypeTransferOutput: FfiConverterRustBuffer<TransferOutput> {
     override fun read(buf: ByteBuffer): TransferOutput {
         return TransferOutput(
-            FfiConverterByteArray.read(buf),
+            FfiConverterString.read(buf),
             FfiConverterULong.read(buf),
             FfiConverterOptionalByteArray.read(buf),
+            FfiConverterByteArray.read(buf),
         )
     }
 
     override fun allocationSize(value: TransferOutput) = (
-            FfiConverterByteArray.allocationSize(value.`predicate`) +
+            FfiConverterString.allocationSize(value.`address`) +
             FfiConverterULong.allocationSize(value.`qty`) +
-            FfiConverterOptionalByteArray.allocationSize(value.`flavor`)
+            FfiConverterOptionalByteArray.allocationSize(value.`flavor`) +
+            FfiConverterByteArray.allocationSize(value.`memo`)
     )
 
     override fun write(value: TransferOutput, buf: ByteBuffer) {
-            FfiConverterByteArray.write(value.`predicate`, buf)
+            FfiConverterString.write(value.`address`, buf)
             FfiConverterULong.write(value.`qty`, buf)
             FfiConverterOptionalByteArray.write(value.`flavor`, buf)
+            FfiConverterByteArray.write(value.`memo`, buf)
     }
 }
 
@@ -2342,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.
      */
@@ -2390,6 +2660,20 @@ sealed class FlameException: kotlin.Exception() {
             get() = "input=${ `input` }"
     }
     
+    /**
+     * A note did not open; `failure` says how, and so what the wallet does
+     * with the output.
+     */
+    class Note(
+        
+        val `failure`: NoteFailure, 
+        
+        val `reason`: kotlin.String
+        ) : FlameException() {
+        override val message
+            get() = "failure=${ `failure` }, reason=${ `reason` }"
+    }
+    
     /**
      * The transfer could not be built or signed.
      */
@@ -2426,20 +2710,31 @@ public object FfiConverterTypeFlameError : FfiConverterRustBuffer<FlameException
             2 -> FlameException.InvalidSeed(
                 FfiConverterString.read(buf),
                 )
-            3 -> FlameException.InvalidAddress(
+            3 -> FlameException.InvalidKey(
                 FfiConverterString.read(buf),
                 )
-            4 -> FlameException.InvalidKeyPath(
+            4 -> FlameException.NotPermitted(
+                FfiConverterTypeWalletKind.read(buf),
+                FfiConverterTypeWalletKind.read(buf),
+                )
+            5 -> FlameException.InvalidAddress(
                 FfiConverterString.read(buf),
                 )
-            5 -> FlameException.InvalidBytes(
+            6 -> FlameException.InvalidKeyPath(
+                FfiConverterString.read(buf),
+                )
+            7 -> FlameException.InvalidBytes(
                 FfiConverterString.read(buf),
                 FfiConverterString.read(buf),
                 )
-            6 -> FlameException.KeyMismatch(
+            8 -> FlameException.KeyMismatch(
                 FfiConverterUInt.read(buf),
                 )
-            7 -> FlameException.Transfer(
+            9 -> FlameException.Note(
+                FfiConverterTypeNoteFailure.read(buf),
+                FfiConverterString.read(buf),
+                )
+            10 -> FlameException.Transfer(
                 FfiConverterString.read(buf),
                 )
             else -> throw RuntimeException("invalid error enum value, something is very wrong!!")
@@ -2458,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
@@ -2479,6 +2785,12 @@ public object FfiConverterTypeFlameError : FfiConverterRustBuffer<FlameException
                 4UL
                 + FfiConverterUInt.allocationSize(value.`input`)
             )
+            is FlameException.Note -> (
+                // Add the size for the Int that specifies the variant plus the size needed for all fields
+                4UL
+                + FfiConverterTypeNoteFailure.allocationSize(value.`failure`)
+                + FfiConverterString.allocationSize(value.`reason`)
+            )
             is FlameException.Transfer -> (
                 // Add the size for the Int that specifies the variant plus the size needed for all fields
                 4UL
@@ -2499,29 +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(9)
+                FfiConverterTypeNoteFailure.write(value.`failure`, buf)
+                FfiConverterString.write(value.`reason`, buf)
+                Unit
+            }
             is FlameException.Transfer -> {
-                buf.putInt(7)
+                buf.putInt(10)
                 FfiConverterString.write(value.`reason`, buf)
                 Unit
             }
@@ -2569,6 +2898,118 @@ public object FfiConverterTypeNetwork: FfiConverterRustBuffer<Network> {
 
 
 
+/**
+ * Why a note did not open: the outcomes of `docs/payments.md`
+ * "Receiving", which a wallet treats differently.
+ */
+
+enum class NoteFailure {
+    
+    /**
+     * No note followed the output. The output is ours but unreadable: keep
+     * and list it, and leave it out of the balance.
+     */
+    MISSING,
+    /**
+     * The note is malformed. Treated as [`NoteFailure::Missing`].
+     */
+    MALFORMED,
+    /**
+     * A note version this library does not know; a later one may open it.
+     */
+    UNKNOWN_VERSION,
+    /**
+     * The note does not decrypt under this address. Treated as
+     * [`NoteFailure::Missing`].
+     */
+    UNDECRYPTABLE,
+    /**
+     * The note decrypts but misstates its output: the sender erred or lied.
+     * Keep and flag it; never count it.
+     */
+    OPENING_MISMATCH,
+    /**
+     * The contract is a cleartext token, or not a token: there is no note
+     * to open, and [`crate::decode_contract`] reads its amount.
+     */
+    NOT_CONFIDENTIAL;
+
+    
+
+
+    companion object
+}
+
+
+/**
+ * @suppress
+ */
+public object FfiConverterTypeNoteFailure: FfiConverterRustBuffer<NoteFailure> {
+    override fun read(buf: ByteBuffer) = try {
+        NoteFailure.values()[buf.getInt() - 1]
+    } catch (e: IndexOutOfBoundsException) {
+        throw RuntimeException("invalid enum value, something is very wrong!!", e)
+    }
+
+    override fun allocationSize(value: NoteFailure) = 4UL
+
+    override fun write(value: NoteFailure, buf: ByteBuffer) {
+        buf.putInt(value.ordinal + 1)
+    }
+}
+
+
+
+
+
+/**
+ * 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