damus

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

Id.swift (2792B)

      1 //
      2 //  Id.swift
      3 //  damus
      4 //
      5 //  Created by William Casarin on 2023-07-26.
      6 //
      7 
      8 import Foundation
      9 
     10 struct TagRef<T>: Hashable, Equatable, Encodable {
     11     let elem: TagElem
     12 
     13     init(_ elem: TagElem) {
     14         self.elem = elem
     15     }
     16 
     17     func encode(to encoder: Encoder) throws {
     18         var container = encoder.singleValueContainer()
     19         try container.encode(elem.string())
     20     }
     21 }
     22 
     23 protocol TagKey {
     24     var keychar: AsciiCharacter { get }
     25 }
     26 
     27 protocol TagKeys {
     28     associatedtype TagKeys: TagKey
     29     var key: TagKeys { get }
     30 }
     31 
     32 protocol TagConvertible {
     33     var tag: [String] { get }
     34     static func from_tag(tag: TagSequence) -> Self?
     35 }
     36 
     37 struct QuoteId: IdType, TagKey, TagConvertible {
     38     let id: Data
     39     
     40     init(_ data: Data) {
     41         self.id = data
     42     }
     43     
     44     /// The note id being quoted
     45     var note_id: NoteId {
     46         NoteId(self.id)
     47     }
     48 
     49     var keychar: AsciiCharacter { "q" }
     50     
     51     var tag: [String] {
     52         ["q", self.hex()]
     53     }
     54     
     55     static func from_tag(tag: TagSequence) -> QuoteId? {
     56         var i = tag.makeIterator()
     57 
     58         guard tag.count >= 2,
     59               let t0 = i.next(),
     60               let key = t0.single_char,
     61               key == "q",
     62               let t1 = i.next(),
     63               let quote_id = t1.id().map(QuoteId.init)
     64         else { return nil }
     65 
     66         return quote_id
     67     }
     68 }
     69 
     70 
     71 struct Privkey: IdType {
     72     let id: Data
     73 
     74     var nsec: String {
     75         bech32_privkey(self)
     76     }
     77 
     78     init?(hex: String) {
     79         guard let id = hex_decode_id(hex) else {
     80             return nil
     81         }
     82         self.init(id)
     83     }
     84 
     85     init(_ data: Data) {
     86         self.id = data
     87     }
     88 }
     89 
     90 
     91 struct Hashtag: TagConvertible, Hashable {
     92     let hashtag: String
     93 
     94     static func from_tag(tag: TagSequence) -> Hashtag? {
     95         var i = tag.makeIterator()
     96 
     97         guard tag.count >= 2,
     98               let t0 = i.next(),
     99               let chr = t0.single_char,
    100               chr == "t",
    101               let t1 = i.next() else {
    102             return nil
    103         }
    104 
    105         return Hashtag(hashtag: t1.string())
    106     }
    107 
    108     var tag: [String] { ["t", self.hashtag] }
    109     var keychar: AsciiCharacter { "t" }
    110 }
    111 
    112 struct ReplaceableParam: TagConvertible {
    113     let param: TagElem
    114 
    115     static func from_tag(tag: TagSequence) -> ReplaceableParam? {
    116         var i = tag.makeIterator()
    117 
    118         guard tag.count >= 2,
    119               let t0 = i.next(),
    120               let chr = t0.single_char,
    121               chr == "d",
    122               let t1 = i.next() else {
    123             return nil
    124         }
    125 
    126         return ReplaceableParam(param: t1)
    127     }
    128 
    129     var tag: [String] { [self.keychar.description, self.param.string()] }
    130     var keychar: AsciiCharacter { "d" }
    131 }
    132 
    133 struct Signature: Hashable, Equatable {
    134     let data: Data
    135 
    136     init(_ p: Data) {
    137         self.data = p
    138     }
    139 }