Fix broken DM rendering

Currently NostrDB does not seem to handle encryption/decryption of DMs.
Since NostrDB now controls the block parsing process and fetches note
contents directly from the database, we have to add a specific condition
that injects decrypted content directly to the ndb content parser.

This is done in conjunction with some minor refactoring to `NdbBlocks`
and associated structs, as in C those are separated between the content
string and the offsets for each block, but in Swift this is more
ergonomically represented as a standalone/self-containing object.

No changelog entry is added because the previously broken version was
never released to the public, and therefore this fix produces no
user-facing changes compared to the last released version.

Changelog-None
Closes: https://github.com/damus-io/damus/issues/3106
Signed-off-by: Daniel D’Aquino <daniel@daquino.me>

nostrdb/NdbTxn.swift

@@ -12,7 +12,7 @@ fileprivate var txn_count: Int = 0
 #endif
 
 // Would use struct and ~Copyable but generics aren't supported well
-class NdbTxn<T> {
+class NdbTxn<T>: RawNdbTxnAccessible {
     var txn: ndb_txn
     private var val: T!
     var moved: Bool
@@ -117,6 +117,129 @@ class NdbTxn<T> {
     }
 }
 
+protocol RawNdbTxnAccessible: AnyObject {
+    var txn: ndb_txn { get set }
+}
+
+class PlaceholderNdbTxn: RawNdbTxnAccessible {
+    var txn: ndb_txn
+    
+    init(txn: ndb_txn) {
+        self.txn = txn
+    }
+}
+
+class SafeNdbTxn<T: ~Copyable> {
+    var txn: ndb_txn
+    var val: T!
+    var moved: Bool
+    var inherited: Bool
+    var ndb: Ndb
+    var generation: Int
+    var name: String
+
+    static func pure(ndb: Ndb, val: consuming T) -> SafeNdbTxn<T> {
+        .init(ndb: ndb, txn: ndb_txn(), val: val, generation: ndb.generation, inherited: true, name: "pure_txn")
+    }
+    
+    static func new(on ndb: Ndb, with valueGetter: (PlaceholderNdbTxn) -> T? = { _ in () }, name: String = "txn") -> SafeNdbTxn<T>? {
+        guard !ndb.is_closed else { return nil }
+        var generation = ndb.generation
+        var txn: ndb_txn
+        let inherited: Bool
+        if let active_txn = Thread.current.threadDictionary["ndb_txn"] as? ndb_txn {
+            // some parent thread is active, use that instead
+            print("txn: inherited txn")
+            txn = active_txn
+            inherited = true
+            generation = Thread.current.threadDictionary["txn_generation"] as! Int
+        } else {
+            txn = ndb_txn()
+            guard !ndb.is_closed else { return nil }
+            generation = ndb.generation
+            #if TXNDEBUG
+            txn_count += 1
+            #endif
+            let ok = ndb_begin_query(ndb.ndb.ndb, &txn) != 0
+            if !ok {
+                return nil
+            }
+            generation = ndb.generation
+            Thread.current.threadDictionary["ndb_txn"] = txn
+            Thread.current.threadDictionary["txn_generation"] = ndb.generation
+            inherited = false
+        }
+        #if TXNDEBUG
+        print("txn: open  gen\(self.generation) '\(self.name)' \(txn_count)")
+        #endif
+        let moved = false
+        let placeholderTxn = PlaceholderNdbTxn(txn: txn)
+        guard let val = valueGetter(placeholderTxn) else { return nil }
+        return SafeNdbTxn<T>(ndb: ndb, txn: txn, val: val, generation: generation, inherited: inherited, name: name)
+    }
+
+    private init(ndb: Ndb, txn: ndb_txn, val: consuming T, generation: Int, inherited: Bool, name: String) {
+        self.txn = txn
+        self.val = consume val
+        self.moved = false
+        self.inherited = inherited
+        self.ndb = ndb
+        self.generation = generation
+        self.name = name
+    }
+
+    deinit {
+        if self.generation != ndb.generation {
+            print("txn: OLD GENERATION (\(self.generation) != \(ndb.generation)), IGNORING")
+            return
+        }
+        if inherited {
+            print("txn: not closing. inherited ")
+            return
+        }
+        if moved {
+            //print("txn: not closing. moved")
+            return
+        }
+        if ndb.is_closed {
+            print("txn: not closing. db closed")
+            return
+        }
+
+        #if TXNDEBUG
+        txn_count -= 1;
+        print("txn: close gen\(generation) '\(name)' \(txn_count)")
+        #endif
+        ndb_end_query(&self.txn)
+        //self.skip_close = true
+        Thread.current.threadDictionary.removeObject(forKey: "ndb_txn")
+    }
+
+    // functor
+    func map<Y>(_ transform: (borrowing T) -> Y) -> SafeNdbTxn<Y> {
+        self.moved = true
+        return .init(ndb: self.ndb, txn: self.txn, val: transform(val), generation: generation, inherited: inherited, name: self.name)
+    }
+
+    // comonad!?
+    // useful for moving ownership of a transaction to another value
+    func extend<Y>(_ with: (SafeNdbTxn<T>) -> Y) -> SafeNdbTxn<Y> {
+        self.moved = true
+        return .init(ndb: self.ndb, txn: self.txn, val: with(self), generation: generation, inherited: inherited, name: self.name)
+    }
+    
+    consuming func maybeExtend<Y>(_ with: (consuming SafeNdbTxn<T>) -> Y?) -> SafeNdbTxn<Y>? where Y: ~Copyable {
+        self.moved = true
+        let ndb = self.ndb
+        let txn = self.txn
+        let generation = self.generation
+        let inherited = self.inherited
+        let name = self.name
+        guard let newVal = with(consume self) else { return nil }
+        return .init(ndb: ndb, txn: txn, val: newVal, generation: generation, inherited: inherited, name: name)
+    }
+}
+
 protocol OptionalType {
     associatedtype Wrapped
     var optional: Wrapped? { get }