kopia lustrzana https://github.com/vitorpamplona/amethyst
544 wiersze
19 KiB
Kotlin
544 wiersze
19 KiB
Kotlin
/**
|
|
* Copyright (c) 2024 Vitor Pamplona
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
* this software and associated documentation files (the "Software"), to deal in
|
|
* the Software without restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
|
|
* Software, and to permit persons to whom the Software is furnished to do so,
|
|
* subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
|
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
package com.vitorpamplona.quartz.events
|
|
|
|
import android.util.Log
|
|
import androidx.compose.runtime.Immutable
|
|
import com.fasterxml.jackson.annotation.JsonProperty
|
|
import com.fasterxml.jackson.core.JsonGenerator
|
|
import com.fasterxml.jackson.core.JsonParser
|
|
import com.fasterxml.jackson.core.json.JsonReadFeature
|
|
import com.fasterxml.jackson.databind.DeserializationContext
|
|
import com.fasterxml.jackson.databind.DeserializationFeature
|
|
import com.fasterxml.jackson.databind.JsonNode
|
|
import com.fasterxml.jackson.databind.SerializerProvider
|
|
import com.fasterxml.jackson.databind.deser.std.StdDeserializer
|
|
import com.fasterxml.jackson.databind.module.SimpleModule
|
|
import com.fasterxml.jackson.databind.ser.std.StdSerializer
|
|
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
|
|
import com.vitorpamplona.quartz.crypto.CryptoUtils
|
|
import com.vitorpamplona.quartz.encoders.ATag
|
|
import com.vitorpamplona.quartz.encoders.Hex
|
|
import com.vitorpamplona.quartz.encoders.HexKey
|
|
import com.vitorpamplona.quartz.encoders.Nip19Bech32
|
|
import com.vitorpamplona.quartz.encoders.toHexKey
|
|
import com.vitorpamplona.quartz.signers.NostrSigner
|
|
import com.vitorpamplona.quartz.utils.TimeUtils
|
|
import java.math.BigDecimal
|
|
|
|
@Immutable
|
|
open class Event(
|
|
val id: HexKey,
|
|
@JsonProperty("pubkey") val pubKey: HexKey,
|
|
@JsonProperty("created_at") val createdAt: Long,
|
|
val kind: Int,
|
|
val tags: Array<Array<String>>,
|
|
val content: String,
|
|
val sig: HexKey,
|
|
) : EventInterface {
|
|
override fun isContentEncoded() = false
|
|
|
|
override fun countMemory(): Long {
|
|
return 12L +
|
|
id.bytesUsedInMemory() +
|
|
pubKey.bytesUsedInMemory() +
|
|
tags.sumOf { it.sumOf { it.bytesUsedInMemory() } } +
|
|
content.bytesUsedInMemory() +
|
|
sig.bytesUsedInMemory()
|
|
}
|
|
|
|
override fun id(): HexKey = id
|
|
|
|
override fun pubKey(): HexKey = pubKey
|
|
|
|
override fun createdAt(): Long = createdAt
|
|
|
|
override fun kind(): Int = kind
|
|
|
|
override fun tags(): Array<Array<String>> = tags
|
|
|
|
override fun content(): String = content
|
|
|
|
override fun sig(): HexKey = sig
|
|
|
|
override fun toJson(): String = mapper.writeValueAsString(toJsonObject())
|
|
|
|
override fun hasAnyTaggedUser() = hasTagWithContent("p")
|
|
|
|
override fun hasTagWithContent(tagName: String) = tags.any { it.size > 1 && it[0] == tagName }
|
|
|
|
override fun taggedUsers() = tags.filter { it.size > 1 && it[0] == "p" }.map { it[1] }
|
|
|
|
override fun taggedEvents() = tags.filter { it.size > 1 && it[0] == "e" }.map { it[1] }
|
|
|
|
override fun taggedUrls() = tags.filter { it.size > 1 && it[0] == "r" }.map { it[1] }
|
|
|
|
override fun firstTaggedUser() = tags.firstOrNull { it.size > 1 && it[0] == "p" }?.let { it[1] }
|
|
|
|
override fun firstTaggedEvent() = tags.firstOrNull { it.size > 1 && it[0] == "e" }?.let { it[1] }
|
|
|
|
override fun firstTaggedUrl() = tags.firstOrNull { it.size > 1 && it[0] == "r" }?.let { it[1] }
|
|
|
|
override fun firstTaggedK() = tags.firstOrNull { it.size > 1 && it[0] == "k" }?.let { it[1].toIntOrNull() }
|
|
|
|
override fun firstTaggedAddress() =
|
|
tags
|
|
.firstOrNull { it.size > 1 && it[0] == "a" }
|
|
?.let {
|
|
val aTagValue = it[1]
|
|
val relay = it.getOrNull(2)
|
|
|
|
ATag.parse(aTagValue, relay)
|
|
}
|
|
|
|
override fun taggedEmojis() = tags.filter { it.size > 2 && it[0] == "emoji" }.map { EmojiUrl(it[1], it[2]) }
|
|
|
|
override fun isSensitive() =
|
|
tags.any {
|
|
(it.size > 0 && it[0].equals("content-warning", true)) ||
|
|
(it.size > 1 && it[0] == "t" && it[1].equals("nsfw", true)) ||
|
|
(it.size > 1 && it[0] == "t" && it[1].equals("nude", true))
|
|
}
|
|
|
|
override fun subject() = tags.firstOrNull { it.size > 1 && it[0] == "subject" }?.get(1)
|
|
|
|
override fun zapraiserAmount() = tags.firstOrNull { (it.size > 1 && it[0] == "zapraiser") }?.get(1)?.toLongOrNull()
|
|
|
|
override fun hasZapSplitSetup() = tags.any { it.size > 1 && it[0] == "zap" }
|
|
|
|
override fun zapSplitSetup(): List<ZapSplitSetup> {
|
|
return tags
|
|
.filter { it.size > 1 && it[0] == "zap" }
|
|
.mapNotNull {
|
|
val isLnAddress = it[0].contains("@") || it[0].startsWith("LNURL", true)
|
|
val weight = if (isLnAddress) 1.0 else (it.getOrNull(3)?.toDoubleOrNull() ?: 0.0)
|
|
|
|
if (weight > 0) {
|
|
ZapSplitSetup(
|
|
it[1],
|
|
it.getOrNull(2),
|
|
weight,
|
|
isLnAddress,
|
|
)
|
|
} else {
|
|
null
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun taggedAddresses() =
|
|
tags
|
|
.filter { it.size > 1 && it[0] == "a" }
|
|
.mapNotNull {
|
|
val aTagValue = it[1]
|
|
val relay = it.getOrNull(2)
|
|
|
|
ATag.parse(aTagValue, relay)
|
|
}
|
|
|
|
override fun hasHashtags() = tags.any { it.size > 1 && it[0] == "t" }
|
|
|
|
override fun hasGeohashes() = tags.any { it.size > 1 && it[0] == "g" }
|
|
|
|
override fun hashtags() = tags.filter { it.size > 1 && it[0] == "t" }.map { it[1] }
|
|
|
|
override fun geohashes() = tags.filter { it.size > 1 && it[0] == "g" }.map { it[1] }
|
|
|
|
override fun matchTag1With(text: String) = tags.any { it.size > 1 && it[1].contains(text, true) }
|
|
|
|
override fun isTagged(
|
|
key: String,
|
|
tag: String,
|
|
) = tags.any { it.size > 1 && it[0] == key && it[1] == tag }
|
|
|
|
override fun isAnyTagged(
|
|
key: String,
|
|
tags: Set<String>,
|
|
) = this.tags.any { it.size > 1 && it[0] == key && it[1] in tags }
|
|
|
|
override fun isTaggedWord(word: String) = isTagged("word", word)
|
|
|
|
override fun isTaggedUser(idHex: String) = isTagged("p", idHex)
|
|
|
|
override fun isTaggedUsers(idHexes: Set<String>) = isAnyTagged("p", idHexes)
|
|
|
|
override fun isTaggedEvent(idHex: String) = isTagged("e", idHex)
|
|
|
|
override fun isTaggedAddressableNote(idHex: String) = isTagged("a", idHex)
|
|
|
|
override fun isTaggedAddressableNotes(idHexes: Set<String>) = isAnyTagged("a", idHexes)
|
|
|
|
override fun isTaggedHash(hashtag: String) = tags.any { it.size > 1 && it[0] == "t" && it[1].equals(hashtag, true) }
|
|
|
|
override fun isTaggedGeoHash(hashtag: String) = tags.any { it.size > 1 && it[0] == "g" && it[1].startsWith(hashtag, true) }
|
|
|
|
override fun isTaggedHashes(hashtags: Set<String>) = tags.any { it.size > 1 && it[0] == "t" && it[1].lowercase() in hashtags }
|
|
|
|
override fun isTaggedGeoHashes(hashtags: Set<String>) = tags.any { it.size > 1 && it[0] == "g" && it[1].lowercase() in hashtags }
|
|
|
|
override fun firstIsTaggedHashes(hashtags: Set<String>) = tags.firstOrNull { it.size > 1 && it[0] == "t" && it[1].lowercase() in hashtags }?.getOrNull(1)
|
|
|
|
override fun firstIsTaggedAddressableNote(addressableNotes: Set<String>) = tags.firstOrNull { it.size > 1 && it[0] == "a" && it[1] in addressableNotes }?.getOrNull(1)
|
|
|
|
override fun isTaggedAddressableKind(kind: Int): Boolean {
|
|
val kindStr = kind.toString()
|
|
return tags.any { it.size > 1 && it[0] == "a" && it[1].startsWith(kindStr) }
|
|
}
|
|
|
|
override fun expiration() =
|
|
try {
|
|
tags.firstOrNull { it.size > 1 && it[0] == "expiration" }?.get(1)?.toLongOrNull()
|
|
} catch (_: Exception) {
|
|
null
|
|
}
|
|
|
|
override fun isExpired() = (expiration() ?: Long.MAX_VALUE) < TimeUtils.now()
|
|
|
|
override fun isExpirationBefore(time: Long) = (expiration() ?: Long.MAX_VALUE) < time
|
|
|
|
override fun getTagOfAddressableKind(kind: Int): ATag? {
|
|
val kindStr = kind.toString()
|
|
val aTag =
|
|
tags.firstOrNull { it.size > 1 && it[0] == "a" && it[1].startsWith(kindStr) }?.getOrNull(1)
|
|
?: return null
|
|
|
|
return ATag.parse(aTag, null)
|
|
}
|
|
|
|
override fun getPoWRank(): Int {
|
|
var rank = 0
|
|
for (i in 0..id.length) {
|
|
if (id[i] == '0') {
|
|
rank += 4
|
|
} else if (id[i] in '4'..'7') {
|
|
rank += 1
|
|
break
|
|
} else if (id[i] in '2'..'3') {
|
|
rank += 2
|
|
break
|
|
} else if (id[i] == '1') {
|
|
rank += 3
|
|
break
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
return rank
|
|
}
|
|
|
|
override fun getGeoHash(): String? {
|
|
return tags.firstOrNull { it.size > 1 && it[0] == "g" }?.get(1)?.ifBlank { null }
|
|
}
|
|
|
|
override fun getReward(): BigDecimal? {
|
|
return try {
|
|
tags.firstOrNull { it.size > 1 && it[0] == "reward" }?.get(1)?.let { BigDecimal(it) }
|
|
} catch (e: Exception) {
|
|
null
|
|
}
|
|
}
|
|
|
|
open fun toNIP19(): String {
|
|
return if (this is AddressableEvent) {
|
|
ATag(kind, pubKey, dTag(), null).toNAddr()
|
|
} else {
|
|
Nip19Bech32.createNEvent(id, pubKey, kind, null)
|
|
}
|
|
}
|
|
|
|
fun toNostrUri(): String {
|
|
return "nostr:${toNIP19()}"
|
|
}
|
|
|
|
fun hasCorrectIDHash(): Boolean {
|
|
if (id.isEmpty()) return false
|
|
return id.equals(generateId())
|
|
}
|
|
|
|
fun hasVerifiedSignature(): Boolean {
|
|
if (id.isEmpty() || sig.isEmpty()) return false
|
|
return CryptoUtils.verifySignature(Hex.decode(sig), Hex.decode(id), Hex.decode(pubKey))
|
|
}
|
|
|
|
/** Checks if the ID is correct and then if the pubKey's secret key signed the event. */
|
|
override fun checkSignature() {
|
|
if (!hasCorrectIDHash()) {
|
|
throw Exception(
|
|
"""
|
|
|Unexpected ID.
|
|
| Event: ${toJson()}
|
|
| Actual ID: $id
|
|
| Generated: ${generateId()}
|
|
"""
|
|
.trimIndent(),
|
|
)
|
|
}
|
|
if (!hasVerifiedSignature()) {
|
|
throw Exception("""Bad signature!""")
|
|
}
|
|
}
|
|
|
|
override fun hasValidSignature(): Boolean {
|
|
return try {
|
|
hasCorrectIDHash() && hasVerifiedSignature()
|
|
} catch (e: Exception) {
|
|
Log.w("Event", "Event $id does not have a valid signature: ${toJson()}", e)
|
|
false
|
|
}
|
|
}
|
|
|
|
fun makeJsonForId(): String {
|
|
return makeJsonForId(pubKey, createdAt, kind, tags, content)
|
|
}
|
|
|
|
private fun generateId(): String {
|
|
return CryptoUtils.sha256(makeJsonForId().toByteArray()).toHexKey()
|
|
}
|
|
|
|
private class EventDeserializer : StdDeserializer<Event>(Event::class.java) {
|
|
override fun deserialize(
|
|
jp: JsonParser,
|
|
ctxt: DeserializationContext,
|
|
): Event {
|
|
return fromJson(jp.codec.readTree(jp))
|
|
}
|
|
}
|
|
|
|
private class GossipDeserializer : StdDeserializer<Gossip>(Gossip::class.java) {
|
|
override fun deserialize(
|
|
jp: JsonParser,
|
|
ctxt: DeserializationContext,
|
|
): Gossip {
|
|
val jsonObject: JsonNode = jp.codec.readTree(jp)
|
|
return Gossip(
|
|
id = jsonObject.get("id")?.asText()?.intern(),
|
|
pubKey = jsonObject.get("pubkey")?.asText()?.intern(),
|
|
createdAt = jsonObject.get("created_at")?.asLong(),
|
|
kind = jsonObject.get("kind")?.asInt(),
|
|
tags =
|
|
jsonObject.get("tags").toTypedArray {
|
|
it.toTypedArray { s -> if (s.isNull) "" else s.asText().intern() }
|
|
},
|
|
content = jsonObject.get("content")?.asText(),
|
|
)
|
|
}
|
|
}
|
|
|
|
private class EventSerializer : StdSerializer<Event>(Event::class.java) {
|
|
override fun serialize(
|
|
event: Event,
|
|
gen: JsonGenerator,
|
|
provider: SerializerProvider,
|
|
) {
|
|
gen.writeStartObject()
|
|
gen.writeStringField("id", event.id)
|
|
gen.writeStringField("pubkey", event.pubKey)
|
|
gen.writeNumberField("created_at", event.createdAt)
|
|
gen.writeNumberField("kind", event.kind)
|
|
gen.writeArrayFieldStart("tags")
|
|
event.tags.forEach { tag -> gen.writeArray(tag, 0, tag.size) }
|
|
gen.writeEndArray()
|
|
gen.writeStringField("content", event.content)
|
|
gen.writeStringField("sig", event.sig)
|
|
gen.writeEndObject()
|
|
}
|
|
}
|
|
|
|
private class GossipSerializer : StdSerializer<Gossip>(Gossip::class.java) {
|
|
override fun serialize(
|
|
event: Gossip,
|
|
gen: JsonGenerator,
|
|
provider: SerializerProvider,
|
|
) {
|
|
gen.writeStartObject()
|
|
event.id?.let { gen.writeStringField("id", it) }
|
|
event.pubKey?.let { gen.writeStringField("pubkey", it) }
|
|
event.createdAt?.let { gen.writeNumberField("created_at", it) }
|
|
event.kind?.let { gen.writeNumberField("kind", it) }
|
|
event.tags?.let {
|
|
gen.writeArrayFieldStart("tags")
|
|
event.tags.forEach { tag -> gen.writeArray(tag, 0, tag.size) }
|
|
gen.writeEndArray()
|
|
}
|
|
event.content?.let { gen.writeStringField("content", it) }
|
|
gen.writeEndObject()
|
|
}
|
|
}
|
|
|
|
fun toJsonObject(): JsonNode {
|
|
val factory = mapper.nodeFactory
|
|
|
|
return factory.objectNode().apply {
|
|
put("id", id)
|
|
put("pubkey", pubKey)
|
|
put("created_at", createdAt)
|
|
put("kind", kind)
|
|
replace(
|
|
"tags",
|
|
factory.arrayNode(tags.size).apply {
|
|
tags.forEach { tag ->
|
|
add(
|
|
factory.arrayNode(tag.size).apply { tag.forEach { add(it) } },
|
|
)
|
|
}
|
|
},
|
|
)
|
|
put("content", content)
|
|
put("sig", sig)
|
|
}
|
|
}
|
|
|
|
companion object {
|
|
val mapper =
|
|
jacksonObjectMapper()
|
|
.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
|
|
.enable(JsonReadFeature.ALLOW_UNESCAPED_CONTROL_CHARS.mappedFeature())
|
|
.registerModule(
|
|
SimpleModule()
|
|
.addSerializer(Event::class.java, EventSerializer())
|
|
.addDeserializer(Event::class.java, EventDeserializer())
|
|
.addSerializer(Gossip::class.java, GossipSerializer())
|
|
.addDeserializer(Gossip::class.java, GossipDeserializer())
|
|
.addDeserializer(Response::class.java, ResponseDeserializer())
|
|
.addDeserializer(Request::class.java, RequestDeserializer()),
|
|
)
|
|
|
|
fun fromJson(jsonObject: JsonNode): Event {
|
|
return EventFactory.create(
|
|
id = jsonObject.get("id").asText().intern(),
|
|
pubKey = jsonObject.get("pubkey").asText().intern(),
|
|
createdAt = jsonObject.get("created_at").asLong(),
|
|
kind = jsonObject.get("kind").asInt(),
|
|
tags =
|
|
jsonObject.get("tags").toTypedArray {
|
|
it.toTypedArray { s -> if (s.isNull) "" else s.asText().intern() }
|
|
},
|
|
content = jsonObject.get("content").asText(),
|
|
sig = jsonObject.get("sig").asText(),
|
|
)
|
|
}
|
|
|
|
private inline fun <reified R> JsonNode.toTypedArray(transform: (JsonNode) -> R): Array<R> {
|
|
return Array(size()) { transform(get(it)) }
|
|
}
|
|
|
|
fun fromJson(json: String): Event = mapper.readValue(json, Event::class.java)
|
|
|
|
fun toJson(event: Event): String = mapper.writeValueAsString(event)
|
|
|
|
fun makeJsonForId(
|
|
pubKey: HexKey,
|
|
createdAt: Long,
|
|
kind: Int,
|
|
tags: Array<Array<String>>,
|
|
content: String,
|
|
): String {
|
|
val factory = mapper.nodeFactory
|
|
val rawEvent =
|
|
factory.arrayNode(6).apply {
|
|
add(0)
|
|
add(pubKey)
|
|
add(createdAt)
|
|
add(kind)
|
|
add(
|
|
factory.arrayNode(tags.size).apply {
|
|
tags.forEach { tag ->
|
|
add(
|
|
factory.arrayNode(tag.size).apply { tag.forEach { add(it) } },
|
|
)
|
|
}
|
|
},
|
|
)
|
|
add(content)
|
|
}
|
|
|
|
return mapper.writeValueAsString(rawEvent)
|
|
}
|
|
|
|
fun generateId(
|
|
pubKey: HexKey,
|
|
createdAt: Long,
|
|
kind: Int,
|
|
tags: Array<Array<String>>,
|
|
content: String,
|
|
): ByteArray {
|
|
return CryptoUtils.sha256(makeJsonForId(pubKey, createdAt, kind, tags, content).toByteArray())
|
|
}
|
|
|
|
fun create(
|
|
signer: NostrSigner,
|
|
kind: Int,
|
|
tags: Array<Array<String>> = emptyArray(),
|
|
content: String = "",
|
|
createdAt: Long = TimeUtils.now(),
|
|
onReady: (Event) -> Unit,
|
|
) {
|
|
return signer.sign(createdAt, kind, tags, content, onReady)
|
|
}
|
|
}
|
|
}
|
|
|
|
@Immutable
|
|
open class WrappedEvent(
|
|
id: HexKey,
|
|
@JsonProperty("pubkey") pubKey: HexKey,
|
|
@JsonProperty("created_at") createdAt: Long,
|
|
kind: Int,
|
|
tags: Array<Array<String>>,
|
|
content: String,
|
|
sig: HexKey,
|
|
) : Event(id, pubKey, createdAt, kind, tags, content, sig) {
|
|
@Transient var host: Event? = null // host event to broadcast when needed
|
|
}
|
|
|
|
@Immutable
|
|
interface AddressableEvent {
|
|
fun dTag(): String
|
|
|
|
fun address(): ATag
|
|
}
|
|
|
|
@Immutable
|
|
open class BaseAddressableEvent(
|
|
id: HexKey,
|
|
pubKey: HexKey,
|
|
createdAt: Long,
|
|
kind: Int,
|
|
tags: Array<Array<String>>,
|
|
content: String,
|
|
sig: HexKey,
|
|
) : Event(id, pubKey, createdAt, kind, tags, content, sig), AddressableEvent {
|
|
override fun dTag() = tags.firstOrNull { it.size > 1 && it[0] == "d" }?.get(1) ?: ""
|
|
|
|
override fun address() = ATag(kind, pubKey, dTag(), null)
|
|
}
|
|
|
|
fun String.bytesUsedInMemory(): Int {
|
|
return (8 * ((((this.length) * 2) + 45) / 8))
|
|
}
|
|
|
|
data class ZapSplitSetup(
|
|
val lnAddressOrPubKeyHex: String,
|
|
val relay: String?,
|
|
val weight: Double,
|
|
val isLnAddress: Boolean,
|
|
)
|