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

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.0'
+  s.version          = '0.0.1-rc.2'
   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.0' }
+  s.source           = { :git => 'https://github.com/runflame/flame-lib.git', :tag => 'flamewallet-v0.0.1-rc.2' }
   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.0'
+    versionName '0.0.1-rc.2'
   }
 
   compileOptions {

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

@@ -697,6 +697,8 @@ internal object IntegrityCheckingUniffiLib {
     ): 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(
@@ -743,6 +745,8 @@ internal object UniffiLib {
     ): 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, 
@@ -911,6 +915,9 @@ 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) {
+        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")
     }
@@ -1390,6 +1397,14 @@ 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.
+     */
+    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
@@ -1628,6 +1643,29 @@ 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.
+     */
+    @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
@@ -1779,7 +1817,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 +1828,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 +1851,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 +2017,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 +2078,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 +2189,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 +2200,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 8102 bytes; empty for none.
+     */
+    var `memo`: kotlin.ByteArray
     
 ){
     
@@ -2125,22 +2222,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)
     }
 }
 
@@ -2390,6 +2490,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.
      */
@@ -2439,7 +2553,11 @@ public object FfiConverterTypeFlameError : FfiConverterRustBuffer<FlameException
             6 -> FlameException.KeyMismatch(
                 FfiConverterUInt.read(buf),
                 )
-            7 -> FlameException.Transfer(
+            7 -> FlameException.Note(
+                FfiConverterTypeNoteFailure.read(buf),
+                FfiConverterString.read(buf),
+                )
+            8 -> FlameException.Transfer(
                 FfiConverterString.read(buf),
                 )
             else -> throw RuntimeException("invalid error enum value, something is very wrong!!")
@@ -2479,6 +2597,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
@@ -2520,8 +2644,14 @@ public object FfiConverterTypeFlameError : FfiConverterRustBuffer<FlameException
                 FfiConverterUInt.write(value.`input`, buf)
                 Unit
             }
-            is FlameException.Transfer -> {
+            is FlameException.Note -> {
                 buf.putInt(7)
+                FfiConverterTypeNoteFailure.write(value.`failure`, buf)
+                FfiConverterString.write(value.`reason`, buf)
+                Unit
+            }
+            is FlameException.Transfer -> {
+                buf.putInt(8)
                 FfiConverterString.write(value.`reason`, buf)
                 Unit
             }
@@ -2569,6 +2699,70 @@ 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)
+    }
+}
+
+
+
+
+
 
 /**
  * @suppress