highperfocused/amethyst
1
0
Fork 0
mirror of https://github.com/vitorpamplona/amethyst.git synced 2025-09-28 22:03:01 +02:00
Code Issues Packages Projects Releases Wiki Activity

Removing deprecated functions

Browse Source
This commit is contained in:
Vitor Pamplona
2025-05-16 14:11:12 -04:00
parent 780a1ef65e
commit d35e3f8daf
4 changed files with 41 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
benchmark/src/androidTest/java/com/vitorpamplona/quartz/benchmark/GiftWrapBenchmark.kt
View File

@@ -89,11 +89,11 @@ class GiftWrapBenchmark {
val keyToUse = if (it.recipientPubKey() == sender.pubKey) sender else receiver
it.cachedGift(keyToUse) { event ->
it.unwrap(keyToUse) { event ->
event.checkSignature()
if (event is SealedRumorEvent) {
event.cachedRumor(keyToUse) { innerData ->
event.unseal(keyToUse) { innerData ->
Assert.assertEquals(message, innerData.content)
countDownLatch2.countDown()
}
@@ -136,11 +136,11 @@ class GiftWrapBenchmark {
val wrap = Event.fromJson(giftWrapJson) as GiftWrapEvent
wrap.checkSignature()
wrap.cachedGift(keyToUse) { seal ->
wrap.unwrap(keyToUse) { seal ->
seal.checkSignature()
if (seal is SealedRumorEvent) {
seal.cachedRumor(keyToUse) { innerData ->
seal.unseal(keyToUse) { innerData ->
Assert.assertEquals(message, innerData.content)
counter.countDown()
}

74
quartz/src/androidTest/java/com/vitorpamplona/quartz/nip59GiftWraps/GiftWrapEventTest.kt
View File

@@ -67,9 +67,9 @@ class GiftWrapEventTest {
// Simulate Receiver
val eventsReceiverGets = events.wraps.filter { it.isTaggedUser(receiver.pubKey) }
eventsReceiverGets.forEach {
it.cachedGift(receiver) { event ->
it.unwrap(receiver) { event ->
if (event is SealedRumorEvent) {
event.cachedRumor(receiver) { innerData ->
event.unseal(receiver) { innerData ->
countDownLatch.countDown()
assertEquals(message, innerData.content)
}
@@ -82,9 +82,9 @@ class GiftWrapEventTest {
// Simulate Sender
val eventsSenderGets = events.wraps.filter { it.isTaggedUser(sender.pubKey) }
eventsSenderGets.forEach {
it.cachedGift(sender) { event ->
it.unwrap(sender) { event ->
if (event is SealedRumorEvent) {
event.cachedRumor(sender) { innerData ->
event.unseal(sender) { innerData ->
countDownLatch.countDown()
assertEquals(message, innerData.content)
}
@@ -130,9 +130,9 @@ class GiftWrapEventTest {
receivers.forEach { receiver ->
val eventsReceiverGets = events.wraps.filter { it.isTaggedUser(receiver.pubKey) }
eventsReceiverGets.forEach {
it.cachedGift(receiver) { event ->
it.unwrap(receiver) { event ->
if (event is SealedRumorEvent) {
event.cachedRumor(receiver) { innerData ->
event.unseal(receiver) { innerData ->
countDownLatch.countDown()
assertEquals(message, innerData.content)
}
@@ -146,9 +146,9 @@ class GiftWrapEventTest {
// Simulate Sender
val eventsSenderGets = events.wraps.filter { it.isTaggedUser(sender.pubKey) }
eventsSenderGets.forEach {
it.cachedGift(sender) { event ->
it.unwrap(sender) { event ->
if (event is SealedRumorEvent) {
event.cachedRumor(sender) { innerData ->
event.unseal(sender) { innerData ->
countDownLatch.countDown()
assertEquals(message, innerData.content)
}
@@ -252,17 +252,17 @@ class GiftWrapEventTest {
val countDownDecryptLatch = CountDownLatch(2)
giftWrapEventToSender!!.cachedGift(sender) { unwrappedMsgForSenderBySender ->
giftWrapEventToSender!!.unwrap(sender) { unwrappedMsgForSenderBySender ->
assertEquals(SealedRumorEvent.KIND, unwrappedMsgForSenderBySender.kind)
assertTrue(unwrappedMsgForSenderBySender is SealedRumorEvent)
if (unwrappedMsgForSenderBySender is SealedRumorEvent) {
unwrappedMsgForSenderBySender.cachedRumor(sender) { unwrappedRumorToSenderBySender ->
unwrappedMsgForSenderBySender.unseal(sender) { unwrappedRumorToSenderBySender ->
assertEquals("Hi There!", unwrappedRumorToSenderBySender.content)
countDownDecryptLatch.countDown()
}
unwrappedMsgForSenderBySender.cachedRumor(receiver) { _ ->
unwrappedMsgForSenderBySender.unseal(receiver) { _ ->
fail(
"Should not be able to decrypt msg for the sender by the sender but decrypted with receiver",
)
@@ -270,25 +270,25 @@ class GiftWrapEventTest {
}
}
giftWrapEventToReceiver!!.cachedGift(sender) { _ ->
giftWrapEventToReceiver!!.unwrap(sender) { _ ->
fail("Should not be able to decrypt msg for the receiver decrypted by the sender")
}
giftWrapEventToSender!!.cachedGift(receiver) { _ ->
giftWrapEventToSender!!.unwrap(receiver) { _ ->
fail("Should not be able to decrypt msg for the sender decrypted by the receiver")
}
giftWrapEventToReceiver!!.cachedGift(receiver) { unwrappedMsgForReceiverByReceiver ->
giftWrapEventToReceiver!!.unwrap(receiver) { unwrappedMsgForReceiverByReceiver ->
assertEquals(SealedRumorEvent.KIND, unwrappedMsgForReceiverByReceiver.kind)
assertTrue(unwrappedMsgForReceiverByReceiver is SealedRumorEvent)
if (unwrappedMsgForReceiverByReceiver is SealedRumorEvent) {
unwrappedMsgForReceiverByReceiver.cachedRumor(receiver) { unwrappedRumorToReceiverByReceiver ->
unwrappedMsgForReceiverByReceiver.unseal(receiver) { unwrappedRumorToReceiverByReceiver ->
assertEquals("Hi There!", unwrappedRumorToReceiverByReceiver?.content)
countDownDecryptLatch.countDown()
}
unwrappedMsgForReceiverByReceiver.cachedRumor(sender) { unwrappedRumorToReceiverBySender ->
unwrappedMsgForReceiverByReceiver.unseal(sender) { unwrappedRumorToReceiverBySender ->
fail(
"Should not be able to decrypt msg for the receiver by the receiver but decrypted with the sender",
)
@@ -423,19 +423,19 @@ class GiftWrapEventTest {
val countDownDecryptLatch = CountDownLatch(3)
giftWrapEventToSender?.cachedGift(sender) { unwrappedMsgForSenderBySender ->
giftWrapEventToSender?.unwrap(sender) { unwrappedMsgForSenderBySender ->
assertEquals(SealedRumorEvent.KIND, unwrappedMsgForSenderBySender.kind)
if (unwrappedMsgForSenderBySender is SealedRumorEvent) {
unwrappedMsgForSenderBySender.cachedRumor(receiverA) { unwrappedRumorToSenderByReceiverA ->
unwrappedMsgForSenderBySender.unseal(receiverA) { unwrappedRumorToSenderByReceiverA ->
fail()
}
unwrappedMsgForSenderBySender.cachedRumor(receiverB) { unwrappedRumorToSenderByReceiverB ->
unwrappedMsgForSenderBySender.unseal(receiverB) { unwrappedRumorToSenderByReceiverB ->
fail()
}
unwrappedMsgForSenderBySender.cachedRumor(sender) { unwrappedRumorToSenderBySender ->
unwrappedMsgForSenderBySender.unseal(sender) { unwrappedRumorToSenderBySender ->
assertEquals(
"Who is going to the party tonight?",
unwrappedRumorToSenderBySender.content,
@@ -446,34 +446,34 @@ class GiftWrapEventTest {
countDownDecryptLatch.countDown()
}
giftWrapEventToReceiverA!!.cachedGift(sender) { unwrappedMsgForReceiverBySenderA ->
giftWrapEventToReceiverA!!.unwrap(sender) { unwrappedMsgForReceiverBySenderA ->
fail("Should not be able to decode msg to the receiver A with the sender's key")
}
giftWrapEventToReceiverB!!.cachedGift(sender) { unwrappedMsgForReceiverBySenderB ->
giftWrapEventToReceiverB!!.unwrap(sender) { unwrappedMsgForReceiverBySenderB ->
fail("Should not be able to decode msg to the receiver B with the sender's key")
}
giftWrapEventToSender!!.cachedGift(receiverA) {
giftWrapEventToSender!!.unwrap(receiverA) {
fail("Should not be able to decode msg to sender with the receiver A's key")
}
giftWrapEventToReceiverA!!.cachedGift(receiverA) { unwrappedMsgForReceiverAByReceiverA ->
giftWrapEventToReceiverA!!.unwrap(receiverA) { unwrappedMsgForReceiverAByReceiverA ->
assertEquals(SealedRumorEvent.KIND, unwrappedMsgForReceiverAByReceiverA.kind)
if (unwrappedMsgForReceiverAByReceiverA is SealedRumorEvent) {
unwrappedMsgForReceiverAByReceiverA.cachedRumor(receiverA) { unwrappedRumorToReceiverAByReceiverA ->
unwrappedMsgForReceiverAByReceiverA.unseal(receiverA) { unwrappedRumorToReceiverAByReceiverA ->
assertEquals(
"Who is going to the party tonight?",
unwrappedRumorToReceiverAByReceiverA.content,
)
}
unwrappedMsgForReceiverAByReceiverA.cachedRumor(sender) { unwrappedRumorToReceiverABySender ->
unwrappedMsgForReceiverAByReceiverA.unseal(sender) { unwrappedRumorToReceiverABySender ->
fail()
}
unwrappedMsgForReceiverAByReceiverA.cachedRumor(receiverB) { unwrappedRumorToReceiverAByReceiverB ->
unwrappedMsgForReceiverAByReceiverA.unseal(receiverB) { unwrappedRumorToReceiverAByReceiverB ->
fail()
}
}
@@ -481,25 +481,25 @@ class GiftWrapEventTest {
countDownDecryptLatch.countDown()
}
giftWrapEventToReceiverB!!.cachedGift(receiverA) {
giftWrapEventToReceiverB!!.unwrap(receiverA) {
fail("Should not be able to decode msg to sender with the receiver A's key")
}
giftWrapEventToSender!!.cachedGift(receiverB) { unwrappedMsgForSenderByReceiverB ->
giftWrapEventToSender!!.unwrap(receiverB) { unwrappedMsgForSenderByReceiverB ->
fail("Should not be able to decode msg to sender with the receiver B's key")
}
giftWrapEventToReceiverA!!.cachedGift(receiverB) { unwrappedMsgForReceiverAByReceiverB ->
giftWrapEventToReceiverA!!.unwrap(receiverB) { unwrappedMsgForReceiverAByReceiverB ->
fail("Should not be able to decode msg to receiver A with the receiver B's key")
}
giftWrapEventToReceiverB!!.cachedGift(receiverB) { unwrappedMsgForReceiverBByReceiverB ->
giftWrapEventToReceiverB!!.unwrap(receiverB) { unwrappedMsgForReceiverBByReceiverB ->
assertEquals(SealedRumorEvent.KIND, unwrappedMsgForReceiverBByReceiverB.kind)
if (unwrappedMsgForReceiverBByReceiverB is SealedRumorEvent) {
unwrappedMsgForReceiverBByReceiverB.cachedRumor(receiverA) { unwrappedRumorToReceiverBByReceiverA ->
unwrappedMsgForReceiverBByReceiverB.unseal(receiverA) { unwrappedRumorToReceiverBByReceiverA ->
fail()
}
unwrappedMsgForReceiverBByReceiverB.cachedRumor(receiverB) { unwrappedRumorToReceiverBByReceiverB ->
unwrappedMsgForReceiverBByReceiverB.unseal(receiverB) { unwrappedRumorToReceiverBByReceiverB ->
assertEquals(
"Who is going to the party tonight?",
unwrappedRumorToReceiverBByReceiverB.content,
@@ -508,7 +508,7 @@ class GiftWrapEventTest {
countDownDecryptLatch.countDown()
}
unwrappedMsgForReceiverBByReceiverB.cachedRumor(sender) { unwrappedRumorToReceiverBBySender ->
unwrappedMsgForReceiverBByReceiverB.unseal(sender) { unwrappedRumorToReceiverBBySender ->
fail()
}
}
@@ -718,9 +718,9 @@ class GiftWrapEventTest {
assertEquals(pkBytes.pubKey, wrap.recipientPubKey())
wrap.cachedGift(pkBytes) { event ->
wrap.unwrap(pkBytes) { event ->
if (event is SealedRumorEvent) {
event.cachedRumor(pkBytes, onReady)
event.unseal(pkBytes, onReady)
} else {
println(event.toJson())
fail("Event is not a Sealed Rumor")
@@ -753,7 +753,7 @@ class GiftWrapEventTest {
var event: Event? = null
wait1SecondForResult { onDone ->
wrap.cachedGift(receiversPrivateKey) {
wrap.unwrap(receiversPrivateKey) {
event = it
onDone()
}

9
quartz/src/main/java/com/vitorpamplona/quartz/nip59Giftwrap/seals/SealedRumorEvent.kt
View File

@@ -66,15 +66,6 @@ class SealedRumorEvent(
override fun isContentEncoded() = true
@Deprecated(
message = "Heavy caching was removed from this class due to high memory use. Cache it separatedly",
replaceWith = ReplaceWith("unseal"),
)
fun cachedRumor(
signer: NostrSigner,
onReady: (Event) -> Unit,
) = unseal(signer, onReady)
fun unseal(
signer: NostrSigner,
onReady: (Event) -> Unit,

9
quartz/src/main/java/com/vitorpamplona/quartz/nip59Giftwrap/wraps/GiftWrapEvent.kt
View File

@@ -68,15 +68,6 @@ class GiftWrapEvent(
override fun isContentEncoded() = true
@Deprecated(
message = "Heavy caching was removed from this class due to high memory use. Cache it separatedly",
replaceWith = ReplaceWith("unwrap"),
)
fun cachedGift(
signer: NostrSigner,
onReady: (Event) -> Unit,
) = unwrap(signer, onReady)
fun unwrapThrowing(
signer: NostrSigner,
onReady: (Event) -> Unit,