damus

nostr ios client
git clone git://jb55.com/damus
Log | Files | Refs | README | LICENSE

DamusState.swift (4867B)

      1 //
      2 //  DamusState.swift
      3 //  damus
      4 //
      5 //  Created by William Casarin on 2022-04-30.
      6 //
      7 
      8 import Foundation
      9 import LinkPresentation
     10 
     11 class DamusState: HeadlessDamusState {
     12     let pool: RelayPool
     13     let keypair: Keypair
     14     let likes: EventCounter
     15     let boosts: EventCounter
     16     let quote_reposts: EventCounter
     17     let contacts: Contacts
     18     let mutelist_manager: MutelistManager
     19     let profiles: Profiles
     20     let dms: DirectMessagesModel
     21     let previews: PreviewCache
     22     let zaps: Zaps
     23     let lnurls: LNUrls
     24     let settings: UserSettingsStore
     25     let relay_filters: RelayFilters
     26     let relay_model_cache: RelayModelCache
     27     let drafts: Drafts
     28     let events: EventCache
     29     let bookmarks: BookmarksManager
     30     let postbox: PostBox
     31     let bootstrap_relays: [RelayURL]
     32     let replies: ReplyCounter
     33     let wallet: WalletModel
     34     let nav: NavigationCoordinator
     35     let music: MusicController?
     36     let video: VideoController
     37     let ndb: Ndb
     38     var purple: DamusPurple
     39 
     40     init(pool: RelayPool, keypair: Keypair, likes: EventCounter, boosts: EventCounter, contacts: Contacts, mutelist_manager: MutelistManager, profiles: Profiles, dms: DirectMessagesModel, previews: PreviewCache, zaps: Zaps, lnurls: LNUrls, settings: UserSettingsStore, relay_filters: RelayFilters, relay_model_cache: RelayModelCache, drafts: Drafts, events: EventCache, bookmarks: BookmarksManager, postbox: PostBox, bootstrap_relays: [RelayURL], replies: ReplyCounter, wallet: WalletModel, nav: NavigationCoordinator, music: MusicController?, video: VideoController, ndb: Ndb, purple: DamusPurple? = nil, quote_reposts: EventCounter) {
     41         self.pool = pool
     42         self.keypair = keypair
     43         self.likes = likes
     44         self.boosts = boosts
     45         self.contacts = contacts
     46         self.mutelist_manager = mutelist_manager
     47         self.profiles = profiles
     48         self.dms = dms
     49         self.previews = previews
     50         self.zaps = zaps
     51         self.lnurls = lnurls
     52         self.settings = settings
     53         self.relay_filters = relay_filters
     54         self.relay_model_cache = relay_model_cache
     55         self.drafts = drafts
     56         self.events = events
     57         self.bookmarks = bookmarks
     58         self.postbox = postbox
     59         self.bootstrap_relays = bootstrap_relays
     60         self.replies = replies
     61         self.wallet = wallet
     62         self.nav = nav
     63         self.music = music
     64         self.video = video
     65         self.ndb = ndb
     66         self.purple = purple ?? DamusPurple(
     67             settings: settings,
     68             keypair: keypair
     69         )
     70         self.quote_reposts = quote_reposts
     71     }
     72 
     73     @discardableResult
     74     func add_zap(zap: Zapping) -> Bool {
     75         // store generic zap mapping
     76         self.zaps.add_zap(zap: zap)
     77         let stored = self.events.store_zap(zap: zap)
     78         
     79         // thread zaps
     80         if let ev = zap.event, !settings.nozaps, zap.is_in_thread {
     81             // [nozaps]: thread zaps are only available outside of the app store
     82             replies.count_replies(ev, keypair: self.keypair)
     83             events.add_replies(ev: ev, keypair: self.keypair)
     84         }
     85 
     86         // associate with events as well
     87         return stored
     88     }
     89     
     90     var pubkey: Pubkey {
     91         return keypair.pubkey
     92     }
     93     
     94     var is_privkey_user: Bool {
     95         keypair.privkey != nil
     96     }
     97 
     98     func close() {
     99         print("txn: damus close")
    100         pool.close()
    101         ndb.close()
    102     }
    103 
    104     static var empty: DamusState {
    105         let empty_pub: Pubkey = .empty
    106         let empty_sec: Privkey = .empty
    107         let kp = Keypair(pubkey: empty_pub, privkey: nil)
    108         
    109         return DamusState.init(
    110             pool: RelayPool(ndb: .empty),
    111             keypair: Keypair(pubkey: empty_pub, privkey: empty_sec),
    112             likes: EventCounter(our_pubkey: empty_pub),
    113             boosts: EventCounter(our_pubkey: empty_pub),
    114             contacts: Contacts(our_pubkey: empty_pub),
    115             mutelist_manager: MutelistManager(),
    116             profiles: Profiles(ndb: .empty),
    117             dms: DirectMessagesModel(our_pubkey: empty_pub),
    118             previews: PreviewCache(),
    119             zaps: Zaps(our_pubkey: empty_pub),
    120             lnurls: LNUrls(),
    121             settings: UserSettingsStore(),
    122             relay_filters: RelayFilters(our_pubkey: empty_pub),
    123             relay_model_cache: RelayModelCache(),
    124             drafts: Drafts(),
    125             events: EventCache(ndb: .empty),
    126             bookmarks: BookmarksManager(pubkey: empty_pub),
    127             postbox: PostBox(pool: RelayPool(ndb: .empty)),
    128             bootstrap_relays: [],
    129             replies: ReplyCounter(our_pubkey: empty_pub),
    130             wallet: WalletModel(settings: UserSettingsStore()),
    131             nav: NavigationCoordinator(),
    132             music: nil,
    133             video: VideoController(),
    134             ndb: .empty,
    135             quote_reposts: .init(our_pubkey: empty_pub)
    136         )
    137     }
    138 }