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

package/ios/FlameWallet.swift

@@ -643,6 +643,14 @@ public protocol WalletProtocol: AnyObject, Sendable {
      */
     func nextIndex()  -> UInt32
     
+    /**
+     * Opens the note that followed `contract` in its log, as a scan serves
+     * the pair; `note` is `None` when the scan served none. `path` is what
+     * [`Wallet::owns`] found for the contract's predicate. The opening it
+     * gives is what a later [`crate::TransferInput`] spends the output with.
+     */
+    func openNote(contract: Data, note: Data?, path: KeyPath) throws  -> ReceivedNote
+    
     /**
      * Which path below `next_index + gap`, on either branch, owns
      * `predicate`; `None` if none does. The scan re-derives every address
@@ -821,6 +829,24 @@ open func nextIndex() -> UInt32  {
             self.uniffiCloneHandle(),uniffiCallStatus
     )
 })
+}
+    
+    /**
+     * Opens the note that followed `contract` in its log, as a scan serves
+     * the pair; `note` is `None` when the scan served none. `path` is what
+     * [`Wallet::owns`] found for the contract's predicate. The opening it
+     * gives is what a later [`crate::TransferInput`] spends the output with.
+     */
+open func openNote(contract: Data, note: Data?, path: KeyPath)throws  -> ReceivedNote  {
+    return try  FfiConverterTypeReceivedNote_lift(try rustCallWithError(FfiConverterTypeFlameError_lift) {
+        uniffiCallStatus in
+    uniffi_flamewallet_ffi_fn_method_wallet_open_note(
+            self.uniffiCloneHandle(),
+        FfiConverterData.lower(contract),
+        FfiConverterOptionData.lower(note),
+        FfiConverterTypeKeyPath_lower(path),uniffiCallStatus
+    )
+})
 }
     
     /**
@@ -978,7 +1004,7 @@ public func FfiConverterTypeContractInfo_lower(_ value: ContractInfo) -> RustBuf
 
 
 /**
- * One contract the transfer creates, in request order.
+ * One contract the transfer creates.
  */
 public struct CreatedOutput: Equatable, Hashable {
     public var contractId: Data
@@ -987,10 +1013,11 @@ public struct CreatedOutput: Equatable, Hashable {
      */
     public var contract: Data
     /**
-     * Delivered to the recipient out of band, or kept for change: the
-     * output can be spent from this record and nothing else.
+     * The encrypted note that follows it on chain, as an indexer's scan
+     * serves it. Its recipient opens it with [`crate::Wallet::open_note`];
+     * so does this wallet, for its change.
      */
-    public var opening: Opening
+    public var note: Data
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
@@ -999,12 +1026,13 @@ public struct CreatedOutput: Equatable, Hashable {
          * Its published bytes, as an indexer will serve them once confirmed.
          */contract: Data, 
         /**
-         * Delivered to the recipient out of band, or kept for change: the
-         * output can be spent from this record and nothing else.
-         */opening: Opening) {
+         * The encrypted note that follows it on chain, as an indexer's scan
+         * serves it. Its recipient opens it with [`crate::Wallet::open_note`];
+         * so does this wallet, for its change.
+         */note: Data) {
         self.contractId = contractId
         self.contract = contract
-        self.opening = opening
+        self.note = note
     }
 
     
@@ -1025,14 +1053,14 @@ public struct FfiConverterTypeCreatedOutput: FfiConverterRustBuffer {
             try CreatedOutput(
                 contractId: FfiConverterData.read(from: &buf), 
                 contract: FfiConverterData.read(from: &buf), 
-                opening: FfiConverterTypeOpening.read(from: &buf)
+                note: FfiConverterData.read(from: &buf)
         )
     }
 
     public static func write(_ value: CreatedOutput, into buf: inout [UInt8]) {
         FfiConverterData.write(value.contractId, into: &buf)
         FfiConverterData.write(value.contract, into: &buf)
-        FfiConverterTypeOpening.write(value.opening, into: &buf)
+        FfiConverterData.write(value.note, into: &buf)
     }
 }
 
@@ -1250,6 +1278,75 @@ public func FfiConverterTypeOpening_lower(_ value: Opening) -> RustBuffer {
 }
 
 
+/**
+ * What an opened note gives its recipient.
+ */
+public struct ReceivedNote: Equatable, Hashable {
+    /**
+     * What a [`crate::TransferInput`] spends the output with.
+     */
+    public var opening: Opening
+    /**
+     * The memo, as the sender wrote it.
+     */
+    public var memo: Data
+
+    // Default memberwise initializers are never public by default, so we
+    // declare one manually.
+    public init(
+        /**
+         * What a [`crate::TransferInput`] spends the output with.
+         */opening: Opening, 
+        /**
+         * The memo, as the sender wrote it.
+         */memo: Data) {
+        self.opening = opening
+        self.memo = memo
+    }
+
+    
+
+    
+}
+
+#if compiler(>=6)
+extension ReceivedNote: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeReceivedNote: FfiConverterRustBuffer {
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ReceivedNote {
+        return
+            try ReceivedNote(
+                opening: FfiConverterTypeOpening.read(from: &buf), 
+                memo: FfiConverterData.read(from: &buf)
+        )
+    }
+
+    public static func write(_ value: ReceivedNote, into buf: inout [UInt8]) {
+        FfiConverterTypeOpening.write(value.opening, into: &buf)
+        FfiConverterData.write(value.memo, into: &buf)
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeReceivedNote_lift(_ buf: RustBuffer) throws -> ReceivedNote {
+    return try FfiConverterTypeReceivedNote.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeReceivedNote_lower(_ value: ReceivedNote) -> RustBuffer {
+    return FfiConverterTypeReceivedNote.lower(value)
+}
+
+
 /**
  * A signed transfer, ready to publish.
  */
@@ -1262,6 +1359,11 @@ public struct Transfer: Equatable, Hashable {
      * `BlockTx::to_bytes`: what a node's `submit_tx` takes.
      */
     public var blockTx: Data
+    /**
+     * In the order they are published, which is not request order: the
+     * builder sorts them so that position says nothing about which one is
+     * the change. Match one to its request by its predicate.
+     */
     public var outputs: [CreatedOutput]
 
     // Default memberwise initializers are never public by default, so we
@@ -1272,7 +1374,12 @@ public struct Transfer: Equatable, Hashable {
          */txid: Data, 
         /**
          * `BlockTx::to_bytes`: what a node's `submit_tx` takes.
-         */blockTx: Data, outputs: [CreatedOutput]) {
+         */blockTx: Data, 
+        /**
+         * In the order they are published, which is not request order: the
+         * builder sorts them so that position says nothing about which one is
+         * the change. Match one to its request by its predicate.
+         */outputs: [CreatedOutput]) {
         self.txid = txid
         self.blockTx = blockTx
         self.outputs = outputs
@@ -1417,29 +1524,39 @@ public func FfiConverterTypeTransferInput_lower(_ value: TransferInput) -> RustB
  */
 public struct TransferOutput: Equatable, Hashable {
     /**
-     * The recipient's predicate: [`crate::address_to_predicate`], or
-     * [`crate::Wallet::address`] on the change branch.
+     * The recipient's bech32f address, for the wallet's network; for
+     * change, [`crate::Wallet::address`] on the change branch.
      */
-    public var predicate: Data
+    public var address: String
     public var qty: UInt64
     /**
      * `None` for flames.
      */
     public var flavor: Data?
+    /**
+     * Sealed into the output's note with the amount; only the recipient
+     * reads it. At most 8102 bytes; empty for none.
+     */
+    public var memo: Data
 
     // Default memberwise initializers are never public by default, so we
     // declare one manually.
     public init(
         /**
-         * The recipient's predicate: [`crate::address_to_predicate`], or
-         * [`crate::Wallet::address`] on the change branch.
-         */predicate: Data, qty: UInt64, 
+         * The recipient's bech32f address, for the wallet's network; for
+         * change, [`crate::Wallet::address`] on the change branch.
+         */address: String, qty: UInt64, 
         /**
          * `None` for flames.
-         */flavor: Data?) {
-        self.predicate = predicate
+         */flavor: Data?, 
+        /**
+         * Sealed into the output's note with the amount; only the recipient
+         * reads it. At most 8102 bytes; empty for none.
+         */memo: Data) {
+        self.address = address
         self.qty = qty
         self.flavor = flavor
+        self.memo = memo
     }
 
     
@@ -1458,16 +1575,18 @@ public struct FfiConverterTypeTransferOutput: FfiConverterRustBuffer {
     public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> TransferOutput {
         return
             try TransferOutput(
-                predicate: FfiConverterData.read(from: &buf), 
+                address: FfiConverterString.read(from: &buf), 
                 qty: FfiConverterUInt64.read(from: &buf), 
-                flavor: FfiConverterOptionData.read(from: &buf)
+                flavor: FfiConverterOptionData.read(from: &buf), 
+                memo: FfiConverterData.read(from: &buf)
         )
     }
 
     public static func write(_ value: TransferOutput, into buf: inout [UInt8]) {
-        FfiConverterData.write(value.predicate, into: &buf)
+        FfiConverterString.write(value.address, into: &buf)
         FfiConverterUInt64.write(value.qty, into: &buf)
         FfiConverterOptionData.write(value.flavor, into: &buf)
+        FfiConverterData.write(value.memo, into: &buf)
     }
 }
 
@@ -1702,6 +1821,12 @@ enum FlameError: Swift.Error, Equatable, Hashable, Foundation.LocalizedError {
      */
     case KeyMismatch(input: UInt32
     )
+    /**
+     * A note did not open; `failure` says how, and so what the wallet does
+     * with the output.
+     */
+    case Note(failure: NoteFailure, reason: String
+    )
     /**
      * The transfer could not be built or signed.
      */
@@ -1755,7 +1880,11 @@ public struct FfiConverterTypeFlameError: FfiConverterRustBuffer {
         case 6: return .KeyMismatch(
             input: try FfiConverterUInt32.read(from: &buf)
             )
-        case 7: return .Transfer(
+        case 7: return .Note(
+            failure: try FfiConverterTypeNoteFailure.read(from: &buf), 
+            reason: try FfiConverterString.read(from: &buf)
+            )
+        case 8: return .Transfer(
             reason: try FfiConverterString.read(from: &buf)
             )
 
@@ -1801,8 +1930,14 @@ public struct FfiConverterTypeFlameError: FfiConverterRustBuffer {
             FfiConverterUInt32.write(input, into: &buf)
             
         
-        case let .Transfer(reason):
+        case let .Note(failure,reason):
             writeInt(&buf, Int32(7))
+            FfiConverterTypeNoteFailure.write(failure, into: &buf)
+            FfiConverterString.write(reason, into: &buf)
+            
+        
+        case let .Transfer(reason):
+            writeInt(&buf, Int32(8))
             FfiConverterString.write(reason, into: &buf)
             
         }
@@ -1893,6 +2028,126 @@ public func FfiConverterTypeNetwork_lower(_ value: Network) -> RustBuffer {
 }
 
 
+
+/**
+ * Why a note did not open: the outcomes of `docs/payments.md`
+ * "Receiving", which a wallet treats differently.
+ */
+
+public enum NoteFailure: Equatable, Hashable {
+    
+    /**
+     * No note followed the output. The output is ours but unreadable: keep
+     * and list it, and leave it out of the balance.
+     */
+    case missing
+    /**
+     * The note is malformed. Treated as [`NoteFailure::Missing`].
+     */
+    case malformed
+    /**
+     * A note version this library does not know; a later one may open it.
+     */
+    case unknownVersion
+    /**
+     * The note does not decrypt under this address. Treated as
+     * [`NoteFailure::Missing`].
+     */
+    case undecryptable
+    /**
+     * The note decrypts but misstates its output: the sender erred or lied.
+     * Keep and flag it; never count it.
+     */
+    case openingMismatch
+    /**
+     * The contract is a cleartext token, or not a token: there is no note
+     * to open, and [`crate::decode_contract`] reads its amount.
+     */
+    case notConfidential
+
+
+
+
+
+}
+
+#if compiler(>=6)
+extension NoteFailure: Sendable {}
+#endif
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public struct FfiConverterTypeNoteFailure: FfiConverterRustBuffer {
+    typealias SwiftType = NoteFailure
+
+    public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NoteFailure {
+        let variant: Int32 = try readInt(&buf)
+        switch variant {
+        
+        case 1: return .missing
+        
+        case 2: return .malformed
+        
+        case 3: return .unknownVersion
+        
+        case 4: return .undecryptable
+        
+        case 5: return .openingMismatch
+        
+        case 6: return .notConfidential
+        
+        default: throw UniffiInternalError.unexpectedEnumCase
+        }
+    }
+
+    public static func write(_ value: NoteFailure, into buf: inout [UInt8]) {
+        switch value {
+        
+        
+        case .missing:
+            writeInt(&buf, Int32(1))
+        
+        
+        case .malformed:
+            writeInt(&buf, Int32(2))
+        
+        
+        case .unknownVersion:
+            writeInt(&buf, Int32(3))
+        
+        
+        case .undecryptable:
+            writeInt(&buf, Int32(4))
+        
+        
+        case .openingMismatch:
+            writeInt(&buf, Int32(5))
+        
+        
+        case .notConfidential:
+            writeInt(&buf, Int32(6))
+        
+        }
+    }
+}
+
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNoteFailure_lift(_ buf: RustBuffer) throws -> NoteFailure {
+    return try FfiConverterTypeNoteFailure.lift(buf)
+}
+
+#if swift(>=5.8)
+@_documentation(visibility: private)
+#endif
+public func FfiConverterTypeNoteFailure_lower(_ value: NoteFailure) -> RustBuffer {
+    return FfiConverterTypeNoteFailure.lower(value)
+}
+
+
 #if swift(>=5.8)
 @_documentation(visibility: private)
 #endif
@@ -2163,6 +2418,9 @@ 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) {
+        return InitializationResult.apiChecksumMismatch
+    }
     if (uniffi_flamewallet_ffi_checksum_method_wallet_owns() != 34274) {
         return InitializationResult.apiChecksumMismatch
     }

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

@@ -288,6 +288,11 @@ RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_next_address(uint64_t ptr, Ru
 uint32_t uniffi_flamewallet_ffi_fn_method_wallet_next_index(uint64_t ptr, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_OPEN_NOTE
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_OPEN_NOTE
+RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_open_note(uint64_t ptr, RustBuffer contract, RustBuffer note, RustBuffer path, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_OWNS
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_OWNS
 RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_owns(uint64_t ptr, RustBuffer predicate, uint32_t gap, RustCallStatus *_Nonnull out_status
@@ -652,6 +657,12 @@ uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_next_address(void
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_NEXT_INDEX
 uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_next_index(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_OPEN_NOTE
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_OPEN_NOTE
+uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_open_note(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_OWNS

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

@@ -288,6 +288,11 @@ RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_next_address(uint64_t ptr, Ru
 uint32_t uniffi_flamewallet_ffi_fn_method_wallet_next_index(uint64_t ptr, RustCallStatus *_Nonnull out_status
 );
 #endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_OPEN_NOTE
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_OPEN_NOTE
+RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_open_note(uint64_t ptr, RustBuffer contract, RustBuffer note, RustBuffer path, RustCallStatus *_Nonnull out_status
+);
+#endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_OWNS
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_FN_METHOD_WALLET_OWNS
 RustBuffer uniffi_flamewallet_ffi_fn_method_wallet_owns(uint64_t ptr, RustBuffer predicate, uint32_t gap, RustCallStatus *_Nonnull out_status
@@ -652,6 +657,12 @@ uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_next_address(void
 #define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_NEXT_INDEX
 uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_next_index(void
     
+);
+#endif
+#ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_OPEN_NOTE
+#define UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_OPEN_NOTE
+uint16_t uniffi_flamewallet_ffi_checksum_method_wallet_open_note(void
+    
 );
 #endif
 #ifndef UNIFFI_FFIDEF_UNIFFI_FLAMEWALLET_FFI_CHECKSUM_METHOD_WALLET_OWNS

package/package.json

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