Fixing test cases after the mega refactoring

quartz/src/androidTest/java/com/vitorpamplona/quartz/GiftWrapEventTest.kt

@@ -14,6 +14,7 @@ import com.vitorpamplona.quartz.events.GiftWrapEvent
 import com.vitorpamplona.quartz.events.Gossip
 import com.vitorpamplona.quartz.events.NIP24Factory
 import com.vitorpamplona.quartz.events.SealedGossipEvent
+import com.vitorpamplona.quartz.signers.NostrSignerInternal
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotEquals
 import org.junit.Assert.assertNotNull
@@ -22,53 +23,69 @@ import org.junit.Assert.assertTrue
 import org.junit.Assert.fail
 import org.junit.Test
 import org.junit.runner.RunWith
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import kotlin.math.sign
 
 @RunWith(AndroidJUnit4::class)
 class GiftWrapEventTest {
     @Test()
     fun testNip24Utils() {
-        val sender = KeyPair()
+        val sender = NostrSignerInternal(KeyPair())
-        val receiver = KeyPair()
+        val receiver = NostrSignerInternal(KeyPair())
         val message = "Hola, que tal?"
 
-        val events = NIP24Factory().createMsgNIP24(
+        // Requires 3 tests
+        val countDownLatch = CountDownLatch(3)
+
+        NIP24Factory().createMsgNIP24(
             message,
-            listOf(receiver.pubKey.toHexKey()),
+            listOf(receiver.pubKey),
-            sender.privKey!!
+            sender
-        )
+        ) { events ->
+            countDownLatch.countDown()
 
-        // Simulate Receiver
+            // Simulate Receiver
-        val eventsReceiverGets = events.filter { it.isTaggedUser(receiver.pubKey.toHexKey()) }
+            val eventsReceiverGets = events.wraps.filter { it.isTaggedUser(receiver.pubKey) }
-        eventsReceiverGets.forEach {
+            eventsReceiverGets.forEach {
-            val event = it.unwrap(receiver.privKey!!)
+                it.cachedGift(receiver) { event ->
-            if (event is SealedGossipEvent) {
+                    if (event is SealedGossipEvent) {
-                val innerData = event.unseal(receiver.privKey!!)
+                        event.cachedGossip(receiver) { innerData ->
-                assertEquals(message, innerData?.content)
+                            countDownLatch.countDown()
-            } else {
+                            assertEquals(message, innerData.content)
-                fail("Wrong Event")
+                        }
+                    } else {
+                        fail("Wrong Event")
+                    }
+                }
+            }
+
+            // Simulate Sender
+            val eventsSenderGets = events.wraps.filter { it.isTaggedUser(sender.pubKey) }
+            eventsSenderGets.forEach {
+                it.cachedGift(sender) { event ->
+                    if (event is SealedGossipEvent) {
+                        event.cachedGossip(sender) { innerData ->
+                            countDownLatch.countDown()
+                            assertEquals(message, innerData.content)
+                        }
+                    } else {
+                        fail("Wrong Event")
+                    }
+                }
             }
         }
 
-        // Simulate Sender
+        assertTrue(countDownLatch.await(1, TimeUnit.SECONDS))
-        val eventsSenderGets = events.filter { it.isTaggedUser(sender.pubKey.toHexKey()) }
-        eventsSenderGets.forEach {
-            val event = it.unwrap(sender.privKey!!)
-            if (event is SealedGossipEvent) {
-                val innerData = event.unseal(sender.privKey!!)
-                assertEquals(message, innerData?.content)
-            } else {
-                fail("Wrong Event")
-            }
-        }
     }
 
     @Test()
     fun testNip24UtilsForGroups() {
-        val sender = KeyPair()
+        val sender = NostrSignerInternal(KeyPair())
-        val receiver1 = KeyPair()
+        val receiver1 = NostrSignerInternal(KeyPair())
-        val receiver2 = KeyPair()
+        val receiver2 = NostrSignerInternal(KeyPair())
-        val receiver3 = KeyPair()
+        val receiver3 = NostrSignerInternal(KeyPair())
-        val receiver4 = KeyPair()
+        val receiver4 = NostrSignerInternal(KeyPair())
         val message = "Hola, que tal?"
 
         val receivers = listOf(
@@ -78,321 +95,393 @@ class GiftWrapEventTest {
             receiver4
         )
 
-        val events = NIP24Factory().createMsgNIP24(
+        val countDownLatch = CountDownLatch(receivers.size + 2)
-            message,
-            receivers.map { it.pubKey.toHexKey() },
-            sender.privKey!!
-        )
 
-        // Simulate Receiver
+        NIP24Factory().createMsgNIP24(
-        receivers.forEach { receiver ->
+            message,
-            val eventsReceiverGets = events.filter { it.isTaggedUser(receiver.pubKey.toHexKey()) }
+            receivers.map { it.pubKey },
-            eventsReceiverGets.forEach {
+            sender
-                val event = it.unwrap(receiver.privKey!!)
+        ) { events ->
-                if (event is SealedGossipEvent) {
+            countDownLatch.countDown()
-                    val innerData = event.unseal(receiver.privKey!!)
+
-                    assertEquals(message, innerData?.content)
+            // Simulate Receiver
-                } else {
+            receivers.forEach { receiver ->
-                    fail("Wrong Event")
+                val eventsReceiverGets = events.wraps.filter { it.isTaggedUser(receiver.pubKey) }
+                eventsReceiverGets.forEach {
+                    it.cachedGift(receiver) { event ->
+                        if (event is SealedGossipEvent) {
+                            event.cachedGossip(receiver) { innerData ->
+                                countDownLatch.countDown()
+                                assertEquals(message, innerData.content)
+                            }
+                        } else {
+                            fail("Wrong Event")
+                        }
+                    }
+                }
+            }
+
+            // Simulate Sender
+            val eventsSenderGets = events.wraps.filter { it.isTaggedUser(sender.pubKey) }
+            eventsSenderGets.forEach {
+                it.cachedGift(sender) { event ->
+                    if (event is SealedGossipEvent) {
+                        event.cachedGossip(sender) { innerData ->
+                            countDownLatch.countDown()
+                            assertEquals(message, innerData.content)
+                        }
+                    } else {
+                        fail("Wrong Event")
+                    }
                 }
             }
         }
 
-        // Simulate Sender
+        assertTrue(countDownLatch.await(1, TimeUnit.SECONDS))
-        val eventsSenderGets = events.filter { it.isTaggedUser(sender.pubKey.toHexKey()) }
-        eventsSenderGets.forEach {
-            val event = it.unwrap(sender.privKey!!)
-            if (event is SealedGossipEvent) {
-                val innerData = event.unseal(sender.privKey!!)
-                assertEquals(message, innerData?.content)
-            } else {
-                fail("Wrong Event")
-            }
-        }
     }
 
     @Test()
     fun testInternalsSimpleMessage() {
-        val sender = KeyPair()
+        val sender = NostrSignerInternal(KeyPair())
-        val receiver = KeyPair()
+        val receiver = NostrSignerInternal(KeyPair())
 
-        val senderMessage = ChatMessageEvent.create(
+        val countDownLatch = CountDownLatch(2)
+
+        var giftWrapEventToSender: GiftWrapEvent? = null
+        var giftWrapEventToReceiver: GiftWrapEvent? = null
+
+        ChatMessageEvent.create(
             msg = "Hi There!",
-            to = listOf(receiver.pubKey.toHexKey()),
+            to = listOf(receiver.pubKey),
-            privateKey = sender.privKey!!
+            signer = sender
-        )
+        ) { senderMessage ->
+            // MsgFor the Receiver
 
-        // MsgFor the Receiver
+            SealedGossipEvent.create(
+                event = senderMessage,
+                encryptTo = receiver.pubKey,
+                signer = sender
+            ) { encMsgFromSenderToReceiver ->
+                // Should expose sender
+                assertEquals(encMsgFromSenderToReceiver.pubKey, sender.pubKey)
+                // Should not expose receiver
+                assertTrue(encMsgFromSenderToReceiver.tags.isEmpty())
 
-        val encMsgFromSenderToReceiver = SealedGossipEvent.create(
+                GiftWrapEvent.create(
-            event = senderMessage,
+                    event = encMsgFromSenderToReceiver,
-            encryptTo = receiver.pubKey.toHexKey(),
+                    recipientPubKey = receiver.pubKey
-            privateKey = sender.privKey!!
+                ) { giftWrapToReceiver ->
-        )
+                    // Should not be signed by neither sender nor receiver
+                    assertNotEquals(giftWrapToReceiver.pubKey, sender.pubKey)
+                    assertNotEquals(giftWrapToReceiver.pubKey, receiver.pubKey)
 
-        // Should expose sender
+                    // Should not include sender as recipient
-        assertEquals(encMsgFromSenderToReceiver.pubKey, sender.pubKey.toHexKey())
+                    assertNotEquals(giftWrapToReceiver.recipientPubKey(), sender.pubKey)
-        // Should not expose receiver
-        assertTrue(encMsgFromSenderToReceiver.tags.isEmpty())
 
-        val giftWrapEventToReceiver = GiftWrapEvent.create(
+                    // Should be addressed to the receiver
-            event = encMsgFromSenderToReceiver,
+                    assertEquals(giftWrapToReceiver.recipientPubKey(), receiver.pubKey)
-            recipientPubKey = receiver.pubKey.toHexKey()
-        )
 
-        // Should not be signed by neither sender nor receiver
+                    giftWrapEventToReceiver = giftWrapToReceiver
-        assertNotEquals(giftWrapEventToReceiver.pubKey, sender.pubKey.toHexKey())
-        assertNotEquals(giftWrapEventToReceiver.pubKey, receiver.pubKey.toHexKey())
 
-        // Should not include sender as recipient
+                    countDownLatch.countDown()
-        assertNotEquals(giftWrapEventToReceiver.recipientPubKey(), sender.pubKey.toHexKey())
+                }
+            }
 
-        // Should be addressed to the receiver
-        assertEquals(giftWrapEventToReceiver.recipientPubKey(), receiver.pubKey.toHexKey())
 
-        // MsgFor the Sender
+            // MsgFor the Sender
+            SealedGossipEvent.create(
+                event = senderMessage,
+                encryptTo = sender.pubKey,
+                signer = sender
+            ) { encMsgFromSenderToSender ->
+                // Should expose sender
+                assertEquals(encMsgFromSenderToSender.pubKey, sender.pubKey)
+                // Should not expose receiver
+                assertTrue(encMsgFromSenderToSender.tags.isEmpty())
 
-        val encMsgFromSenderToSender = SealedGossipEvent.create(
+                GiftWrapEvent.create(
-            event = senderMessage,
+                    event = encMsgFromSenderToSender,
-            encryptTo = sender.pubKey.toHexKey(),
+                    recipientPubKey = sender.pubKey
-            privateKey = sender.privKey!!
+                ) { giftWrapToSender ->
-        )
+                    // Should not be signed by neither the sender, not the receiver
+                    assertNotEquals(giftWrapToSender.pubKey, sender.pubKey)
+                    assertNotEquals(giftWrapToSender.pubKey, receiver.pubKey)
 
-        // Should expose sender
+                    // Should not be addressed to the receiver
-        assertEquals(encMsgFromSenderToSender.pubKey, sender.pubKey.toHexKey())
+                    assertNotEquals(giftWrapToSender.recipientPubKey(), receiver.pubKey)
-        // Should not expose receiver
+                    // Should be addressed to the sender
-        assertTrue(encMsgFromSenderToSender.tags.isEmpty())
+                    assertEquals(giftWrapToSender.recipientPubKey(), sender.pubKey)
 
-        val giftWrapEventToSender = GiftWrapEvent.create(
+                    giftWrapEventToSender = giftWrapToSender
-            event = encMsgFromSenderToSender,
-            recipientPubKey = sender.pubKey.toHexKey()
-        )
 
-        // Should not be signed by neither the sender, not the receiver
+                    countDownLatch.countDown()
-        assertNotEquals(giftWrapEventToSender.pubKey, sender.pubKey.toHexKey())
+                }
-        assertNotEquals(giftWrapEventToSender.pubKey, receiver.pubKey.toHexKey())
+            }
-
+        }
-        // Should not be addressed to the receiver
-        assertNotEquals(giftWrapEventToSender.recipientPubKey(), receiver.pubKey.toHexKey())
-        // Should be addressed to the sender
-        assertEquals(giftWrapEventToSender.recipientPubKey(), sender.pubKey.toHexKey())
 
         // Done
-
+        assertTrue(countDownLatch.await(1, TimeUnit.SECONDS))
-        println(senderMessage.toJson())
-        println(encMsgFromSenderToReceiver.toJson())
-        println(giftWrapEventToReceiver.toJson())
-        println(giftWrapEventToSender.toJson())
 
         // Receiver's side
-        // Unwrapping
+        // Makes sure it can only be decrypted by the target user
 
-        val unwrappedMsgForSenderBySender = giftWrapEventToSender.unwrap(sender.privKey!!)
+        assertNotNull(giftWrapEventToSender)
-        val unwrappedMsgForReceiverBySender = giftWrapEventToReceiver.unwrap(sender.privKey!!)
+        assertNotNull(giftWrapEventToReceiver)
 
-        assertNotNull(unwrappedMsgForSenderBySender)
+        val countDownDecryptLatch = CountDownLatch(2)
-        assertNull(unwrappedMsgForReceiverBySender)
 
-        val unwrappedMsgForSenderByReceiver = giftWrapEventToSender.unwrap(receiver.privKey!!)
+        giftWrapEventToSender!!.cachedGift(sender) { unwrappedMsgForSenderBySender ->
-        val unwrappedMsgForReceiverByReceiver = giftWrapEventToReceiver.unwrap(receiver.privKey!!)
+            assertEquals(SealedGossipEvent.kind, unwrappedMsgForSenderBySender.kind)
+            assertTrue(unwrappedMsgForSenderBySender is SealedGossipEvent)
 
-        assertNull(unwrappedMsgForSenderByReceiver)
+            if (unwrappedMsgForSenderBySender is SealedGossipEvent) {
-        assertNotNull(unwrappedMsgForReceiverByReceiver)
+                unwrappedMsgForSenderBySender.cachedGossip(sender) { unwrappedGossipToSenderBySender ->
+                    assertEquals("Hi There!", unwrappedGossipToSenderBySender.content)
+                    countDownDecryptLatch.countDown()
+                }
 
-        assertEquals(SealedGossipEvent.kind, unwrappedMsgForSenderBySender?.kind)
+                unwrappedMsgForSenderBySender.cachedGossip(receiver) { _ ->
-        assertEquals(SealedGossipEvent.kind, unwrappedMsgForReceiverByReceiver?.kind)
+                    fail("Should not be able to decrypt msg for the sender by the sender but decrypted with receiver")
-
+                }
-        assertTrue(unwrappedMsgForSenderBySender is SealedGossipEvent)
+            }
-        assertTrue(unwrappedMsgForReceiverByReceiver is SealedGossipEvent)
-
-        if (unwrappedMsgForSenderBySender is SealedGossipEvent &&
-            unwrappedMsgForReceiverByReceiver is SealedGossipEvent
-        ) {
-            val unwrappedGossipToSenderByReceiver = unwrappedMsgForSenderBySender.unseal(receiver.privKey!!)
-            val unwrappedGossipToReceiverByReceiver = unwrappedMsgForReceiverByReceiver.unseal(receiver.privKey!!)
-
-            assertNull(unwrappedGossipToSenderByReceiver)
-            assertNotNull(unwrappedGossipToReceiverByReceiver)
-
-            val unwrappedGossipToSenderBySender = unwrappedMsgForSenderBySender.unseal(sender.privKey!!)
-            val unwrappedGossipToReceiverBySender = unwrappedMsgForReceiverByReceiver.unseal(sender.privKey!!)
-
-            assertNotNull(unwrappedGossipToSenderBySender)
-            assertNull(unwrappedGossipToReceiverBySender)
-
-            assertEquals("Hi There!", unwrappedGossipToReceiverByReceiver?.content)
-            assertEquals("Hi There!", unwrappedGossipToSenderBySender?.content)
-        } else {
-            fail()
         }
+
+        giftWrapEventToReceiver!!.cachedGift(sender) { _ ->
+            fail("Should not be able to decrypt msg for the receiver decrypted by the sender")
+        }
+
+        giftWrapEventToSender!!.cachedGift(receiver) { _ ->
+            fail("Should not be able to decrypt msg for the sender decrypted by the receiver")
+        }
+
+        giftWrapEventToReceiver!!.cachedGift(receiver) { unwrappedMsgForReceiverByReceiver ->
+            assertEquals(SealedGossipEvent.kind, unwrappedMsgForReceiverByReceiver.kind)
+            assertTrue(unwrappedMsgForReceiverByReceiver is SealedGossipEvent)
+
+            if (unwrappedMsgForReceiverByReceiver is SealedGossipEvent) {
+                unwrappedMsgForReceiverByReceiver.cachedGossip(receiver) { unwrappedGossipToReceiverByReceiver ->
+                    assertEquals("Hi There!", unwrappedGossipToReceiverByReceiver?.content)
+                    countDownDecryptLatch.countDown()
+                }
+
+                unwrappedMsgForReceiverByReceiver.cachedGossip(sender) { unwrappedGossipToReceiverBySender ->
+                    fail("Should not be able to decrypt msg for the receiver by the receiver but decrypted with the sender")
+                }
+            }
+        }
+
+        countDownDecryptLatch.await(1, TimeUnit.SECONDS)
     }
 
     @Test()
     fun testInternalsGroupMessage() {
-        val sender = KeyPair()
+        val sender = NostrSignerInternal(KeyPair())
-        val receiverA = KeyPair()
+        val receiverA = NostrSignerInternal(KeyPair())
-        val receiverB = KeyPair()
+        val receiverB = NostrSignerInternal(KeyPair())
 
-        val senderMessage = ChatMessageEvent.create(
+        val countDownLatch = CountDownLatch(3)
+
+        var giftWrapEventToSender: GiftWrapEvent? = null
+        var giftWrapEventToReceiverA: GiftWrapEvent? = null
+        var giftWrapEventToReceiverB: GiftWrapEvent? = null
+
+        ChatMessageEvent.create(
             msg = "Who is going to the party tonight?",
-            to = listOf(receiverA.pubKey.toHexKey(), receiverB.pubKey.toHexKey()),
+            to = listOf(receiverA.pubKey, receiverB.pubKey),
-            privateKey = sender.privKey!!
+            signer = sender
-        )
+        ) { senderMessage ->
+            SealedGossipEvent.create(
+                event = senderMessage,
+                encryptTo = receiverA.pubKey,
+                signer = sender
+            ) { msgFromSenderToReceiverA ->
+                // Should expose sender
+                assertEquals(msgFromSenderToReceiverA.pubKey, sender.pubKey)
+                // Should not expose receiver
+                assertTrue(msgFromSenderToReceiverA.tags.isEmpty())
 
-        val encMsgFromSenderToReceiverA = SealedGossipEvent.create(
+                GiftWrapEvent.create(
-            event = senderMessage,
+                    event = msgFromSenderToReceiverA,
-            encryptTo = receiverA.pubKey.toHexKey(),
+                    recipientPubKey = receiverA.pubKey
-            privateKey = sender.privKey!!
+                ) { giftWrapForReceiverA ->
-        )
+                    // Should not be signed by neither sender nor receiver
+                    assertNotEquals(giftWrapForReceiverA.pubKey, sender.pubKey)
+                    assertNotEquals(giftWrapForReceiverA.pubKey, receiverA.pubKey)
+                    assertNotEquals(giftWrapForReceiverA.pubKey, receiverB.pubKey)
 
-        val encMsgFromSenderToReceiverB = SealedGossipEvent.create(
+                    // Should not include sender as recipient
-            event = senderMessage,
+                    assertNotEquals(giftWrapForReceiverA.recipientPubKey(), sender.pubKey)
-            encryptTo = receiverB.pubKey.toHexKey(),
-            privateKey = sender.privKey!!
-        )
 
-        val encMsgFromSenderToSender = SealedGossipEvent.create(
+                    // Should be addressed to the receiver
-            event = senderMessage,
+                    assertEquals(giftWrapForReceiverA.recipientPubKey(), receiverA.pubKey)
-            encryptTo = sender.pubKey.toHexKey(),
-            privateKey = sender.privKey!!
-        )
 
-        // Should expose sender
+                    giftWrapEventToReceiverA = giftWrapForReceiverA
-        assertEquals(encMsgFromSenderToReceiverA.pubKey, sender.pubKey.toHexKey())
-        // Should not expose receiver
-        assertTrue(encMsgFromSenderToReceiverA.tags.isEmpty())
 
-        // Should expose sender
+                    countDownLatch.countDown()
-        assertEquals(encMsgFromSenderToReceiverB.pubKey, sender.pubKey.toHexKey())
+                }
-        // Should not expose receiver
+            }
-        assertTrue(encMsgFromSenderToReceiverB.tags.isEmpty())
 
-        // Should expose sender
+            SealedGossipEvent.create(
-        assertEquals(encMsgFromSenderToSender.pubKey, sender.pubKey.toHexKey())
+                event = senderMessage,
-        // Should not expose receiver
+                encryptTo = receiverB.pubKey,
-        assertTrue(encMsgFromSenderToSender.tags.isEmpty())
+                signer = sender
+            ) { msgFromSenderToReceiverB ->
+                // Should expose sender
+                assertEquals(msgFromSenderToReceiverB.pubKey, sender.pubKey)
+                // Should not expose receiver
+                assertTrue(msgFromSenderToReceiverB.tags.isEmpty())
 
-        val giftWrapEventForReceiverA = GiftWrapEvent.create(
+                GiftWrapEvent.create(
-            event = encMsgFromSenderToReceiverA,
+                    event = msgFromSenderToReceiverB,
-            recipientPubKey = receiverA.pubKey.toHexKey()
+                    recipientPubKey = receiverB.pubKey
-        )
+                ) { giftWrapForReceiverB ->
+                    // Should not be signed by neither sender nor receiver
+                    assertNotEquals(giftWrapForReceiverB.pubKey, sender.pubKey)
+                    assertNotEquals(giftWrapForReceiverB.pubKey, receiverA.pubKey)
+                    assertNotEquals(giftWrapForReceiverB.pubKey, receiverB.pubKey)
 
-        val giftWrapEventForReceiverB = GiftWrapEvent.create(
+                    // Should not include sender as recipient
-            event = encMsgFromSenderToReceiverB,
+                    assertNotEquals(giftWrapForReceiverB.recipientPubKey(), sender.pubKey)
-            recipientPubKey = receiverB.pubKey.toHexKey()
-        )
 
-        // Should not be signed by neither sender nor receiver
+                    // Should be addressed to the receiver
-        assertNotEquals(giftWrapEventForReceiverA.pubKey, sender.pubKey.toHexKey())
+                    assertEquals(giftWrapForReceiverB.recipientPubKey(), receiverB.pubKey)
-        assertNotEquals(giftWrapEventForReceiverA.pubKey, receiverA.pubKey.toHexKey())
-        assertNotEquals(giftWrapEventForReceiverA.pubKey, receiverB.pubKey.toHexKey())
 
-        // Should not include sender as recipient
+                    giftWrapEventToReceiverB = giftWrapForReceiverB
-        assertNotEquals(giftWrapEventForReceiverA.recipientPubKey(), sender.pubKey.toHexKey())
 
-        // Should be addressed to the receiver
+                    countDownLatch.countDown()
-        assertEquals(giftWrapEventForReceiverA.recipientPubKey(), receiverA.pubKey.toHexKey())
+                }
+            }
 
-        // Should not be signed by neither sender nor receiver
+            SealedGossipEvent.create(
-        assertNotEquals(giftWrapEventForReceiverB.pubKey, sender.pubKey.toHexKey())
+                event = senderMessage,
-        assertNotEquals(giftWrapEventForReceiverB.pubKey, receiverA.pubKey.toHexKey())
+                encryptTo = sender.pubKey,
-        assertNotEquals(giftWrapEventForReceiverB.pubKey, receiverB.pubKey.toHexKey())
+                signer = sender
+            ) { msgFromSenderToSender ->
+                // Should expose sender
+                assertEquals(msgFromSenderToSender.pubKey, sender.pubKey)
+                // Should not expose receiver
+                assertTrue(msgFromSenderToSender.tags.isEmpty())
 
-        // Should not include sender as recipient
+                GiftWrapEvent.create(
-        assertNotEquals(giftWrapEventForReceiverB.recipientPubKey(), sender.pubKey.toHexKey())
+                    event = msgFromSenderToSender,
+                    recipientPubKey = sender.pubKey
+                ) { giftWrapToSender ->
+                    // Should not be signed by neither the sender, not the receiver
+                    assertNotEquals(giftWrapToSender.pubKey, sender.pubKey)
+                    assertNotEquals(giftWrapToSender.pubKey, receiverA.pubKey)
+                    assertNotEquals(giftWrapToSender.pubKey, receiverB.pubKey)
 
-        // Should be addressed to the receiver
+                    // Should not be addressed to the receiver
-        assertEquals(giftWrapEventForReceiverB.recipientPubKey(), receiverB.pubKey.toHexKey())
+                    assertNotEquals(giftWrapToSender.recipientPubKey(), receiverA.pubKey)
+                    assertNotEquals(giftWrapToSender.recipientPubKey(), receiverB.pubKey)
+                    // Should be addressed to the sender
+                    assertEquals(giftWrapToSender.recipientPubKey(), sender.pubKey)
 
-        val giftWrapEventToSender = GiftWrapEvent.create(
+                    giftWrapEventToSender = giftWrapToSender
-            event = encMsgFromSenderToSender,
-            recipientPubKey = sender.pubKey.toHexKey()
-        )
 
-        // Should not be signed by neither the sender, not the receiver
+                    countDownLatch.countDown()
-        assertNotEquals(giftWrapEventToSender.pubKey, sender.pubKey.toHexKey())
+                }
-        assertNotEquals(giftWrapEventToSender.pubKey, receiverA.pubKey.toHexKey())
+            }
-        assertNotEquals(giftWrapEventToSender.pubKey, receiverB.pubKey.toHexKey())
-
-        // Should not be addressed to the receiver
-        assertNotEquals(giftWrapEventToSender.recipientPubKey(), receiverA.pubKey.toHexKey())
-        assertNotEquals(giftWrapEventToSender.recipientPubKey(), receiverB.pubKey.toHexKey())
-        // Should be addressed to the sender
-        assertEquals(giftWrapEventToSender.recipientPubKey(), sender.pubKey.toHexKey())
-
-        println(senderMessage.toJson())
-        println(encMsgFromSenderToReceiverA.toJson())
-        println(encMsgFromSenderToReceiverB.toJson())
-        println(giftWrapEventForReceiverA.toJson())
-        println(giftWrapEventForReceiverB.toJson())
-        println(giftWrapEventToSender.toJson())
-
-        val unwrappedMsgForSenderBySender = giftWrapEventToSender.unwrap(sender.privKey!!)
-        val unwrappedMsgForReceiverBySenderA = giftWrapEventForReceiverA.unwrap(sender.privKey!!)
-        val unwrappedMsgForReceiverBySenderB = giftWrapEventForReceiverB.unwrap(sender.privKey!!)
-
-        assertNotNull(unwrappedMsgForSenderBySender)
-        assertNull(unwrappedMsgForReceiverBySenderA)
-        assertNull(unwrappedMsgForReceiverBySenderB)
-
-        val unwrappedMsgForSenderByReceiverA = giftWrapEventToSender.unwrap(receiverA.privKey!!)
-        val unwrappedMsgForReceiverAByReceiverA = giftWrapEventForReceiverA.unwrap(receiverA.privKey!!)
-        val unwrappedMsgForReceiverBByReceiverA = giftWrapEventForReceiverB.unwrap(receiverA.privKey!!)
-
-        assertNull(unwrappedMsgForSenderByReceiverA)
-        assertNotNull(unwrappedMsgForReceiverAByReceiverA)
-        assertNull(unwrappedMsgForReceiverBByReceiverA)
-
-        val unwrappedMsgForSenderByReceiverB = giftWrapEventToSender.unwrap(receiverB.privKey!!)
-        val unwrappedMsgForReceiverAByReceiverB = giftWrapEventForReceiverA.unwrap(receiverB.privKey!!)
-        val unwrappedMsgForReceiverBByReceiverB = giftWrapEventForReceiverB.unwrap(receiverB.privKey!!)
-
-        assertNull(unwrappedMsgForSenderByReceiverB)
-        assertNull(unwrappedMsgForReceiverAByReceiverB)
-        assertNotNull(unwrappedMsgForReceiverBByReceiverB)
-
-        assertEquals(SealedGossipEvent.kind, unwrappedMsgForSenderBySender?.kind)
-        assertEquals(SealedGossipEvent.kind, unwrappedMsgForReceiverAByReceiverA?.kind)
-        assertEquals(SealedGossipEvent.kind, unwrappedMsgForReceiverBByReceiverB?.kind)
-
-        assertTrue(unwrappedMsgForSenderBySender is SealedGossipEvent)
-        assertTrue(unwrappedMsgForReceiverAByReceiverA is SealedGossipEvent)
-        assertTrue(unwrappedMsgForReceiverBByReceiverB is SealedGossipEvent)
-
-        if (unwrappedMsgForSenderBySender is SealedGossipEvent &&
-            unwrappedMsgForReceiverAByReceiverA is SealedGossipEvent &&
-            unwrappedMsgForReceiverBByReceiverB is SealedGossipEvent
-        ) {
-            val unwrappedGossipToSenderByReceiverA = unwrappedMsgForSenderBySender.unseal(receiverA.privKey!!)
-            val unwrappedGossipToReceiverAByReceiverA = unwrappedMsgForReceiverAByReceiverA.unseal(receiverA.privKey!!)
-            val unwrappedGossipToReceiverBByReceiverA = unwrappedMsgForReceiverBByReceiverB.unseal(receiverA.privKey!!)
-
-            assertNull(unwrappedGossipToSenderByReceiverA)
-            assertNotNull(unwrappedGossipToReceiverAByReceiverA)
-            assertNull(unwrappedGossipToReceiverBByReceiverA)
-
-            val unwrappedGossipToSenderByReceiverB = unwrappedMsgForSenderBySender.unseal(receiverB.privKey!!)
-            val unwrappedGossipToReceiverAByReceiverB = unwrappedMsgForReceiverAByReceiverA.unseal(receiverB.privKey!!)
-            val unwrappedGossipToReceiverBByReceiverB = unwrappedMsgForReceiverBByReceiverB.unseal(receiverB.privKey!!)
-
-            assertNull(unwrappedGossipToSenderByReceiverB)
-            assertNull(unwrappedGossipToReceiverAByReceiverB)
-            assertNotNull(unwrappedGossipToReceiverBByReceiverB)
-
-            val unwrappedGossipToSenderBySender = unwrappedMsgForSenderBySender.unseal(sender.privKey!!)
-            val unwrappedGossipToReceiverABySender = unwrappedMsgForReceiverAByReceiverA.unseal(sender.privKey!!)
-            val unwrappedGossipToReceiverBBySender = unwrappedMsgForReceiverBByReceiverB.unseal(sender.privKey!!)
-
-            assertNotNull(unwrappedGossipToSenderBySender)
-            assertNull(unwrappedGossipToReceiverABySender)
-            assertNull(unwrappedGossipToReceiverBBySender)
-
-            assertEquals("Who is going to the party tonight?", unwrappedGossipToReceiverAByReceiverA?.content)
-            assertEquals("Who is going to the party tonight?", unwrappedGossipToReceiverBByReceiverB?.content)
-            assertEquals("Who is going to the party tonight?", unwrappedGossipToSenderBySender?.content)
-        } else {
-            fail()
         }
+
+        // Done
+        assertTrue(countDownLatch.await(1, TimeUnit.SECONDS))
+
+        // Receiver's side
+        // Makes sure it can only be decrypted by the target user
+
+        assertNotNull(giftWrapEventToSender)
+        assertNotNull(giftWrapEventToReceiverA)
+        assertNotNull(giftWrapEventToReceiverB)
+
+        val countDownDecryptLatch = CountDownLatch(3)
+
+        giftWrapEventToSender?.cachedGift(sender) { unwrappedMsgForSenderBySender ->
+            assertEquals(SealedGossipEvent.kind, unwrappedMsgForSenderBySender.kind)
+
+            if (unwrappedMsgForSenderBySender is SealedGossipEvent) {
+                unwrappedMsgForSenderBySender.cachedGossip(receiverA) { unwrappedGossipToSenderByReceiverA ->
+                    fail()
+                }
+
+                unwrappedMsgForSenderBySender.cachedGossip(receiverB) { unwrappedGossipToSenderByReceiverB ->
+                    fail()
+                }
+
+                unwrappedMsgForSenderBySender.cachedGossip(sender) { unwrappedGossipToSenderBySender ->
+                    assertEquals("Who is going to the party tonight?", unwrappedGossipToSenderBySender.content)
+                }
+            }
+
+            countDownDecryptLatch.countDown()
+        }
+
+        giftWrapEventToReceiverA!!.cachedGift(sender) { unwrappedMsgForReceiverBySenderA ->
+            fail("Should not be able to decode msg to the receiver A with the sender's key")
+        }
+
+        giftWrapEventToReceiverB!!.cachedGift(sender) { unwrappedMsgForReceiverBySenderB ->
+            fail("Should not be able to decode msg to the receiver B with the sender's key")
+        }
+
+
+
+        giftWrapEventToSender!!.cachedGift(receiverA) {
+            fail("Should not be able to decode msg to sender with the receiver A's key")
+        }
+
+        giftWrapEventToReceiverA!!.cachedGift(receiverA) { unwrappedMsgForReceiverAByReceiverA ->
+            assertEquals(SealedGossipEvent.kind, unwrappedMsgForReceiverAByReceiverA.kind)
+
+            if (unwrappedMsgForReceiverAByReceiverA is SealedGossipEvent) {
+                unwrappedMsgForReceiverAByReceiverA.cachedGossip(receiverA) { unwrappedGossipToReceiverAByReceiverA ->
+                    assertEquals("Who is going to the party tonight?", unwrappedGossipToReceiverAByReceiverA.content)
+                }
+
+                unwrappedMsgForReceiverAByReceiverA.cachedGossip(sender) { unwrappedGossipToReceiverABySender ->
+                    fail()
+                }
+
+                unwrappedMsgForReceiverAByReceiverA.cachedGossip(receiverB) { unwrappedGossipToReceiverAByReceiverB ->
+                    fail()
+                }
+            }
+
+            countDownDecryptLatch.countDown()
+        }
+
+        giftWrapEventToReceiverB!!.cachedGift(receiverA) {
+            fail("Should not be able to decode msg to sender with the receiver A's key")
+        }
+
+
+        giftWrapEventToSender!!.cachedGift(receiverB) { unwrappedMsgForSenderByReceiverB ->
+            fail("Should not be able to decode msg to sender with the receiver B's key")
+        }
+        giftWrapEventToReceiverA!!.cachedGift(receiverB) { unwrappedMsgForReceiverAByReceiverB ->
+            fail("Should not be able to decode msg to receiver A with the receiver B's key")
+        }
+        giftWrapEventToReceiverB!!.cachedGift(receiverB) { unwrappedMsgForReceiverBByReceiverB ->
+            assertEquals(SealedGossipEvent.kind, unwrappedMsgForReceiverBByReceiverB.kind)
+
+            if (unwrappedMsgForReceiverBByReceiverB is SealedGossipEvent) {
+                unwrappedMsgForReceiverBByReceiverB.cachedGossip(receiverA) { unwrappedGossipToReceiverBByReceiverA ->
+                    fail()
+                }
+
+                unwrappedMsgForReceiverBByReceiverB.cachedGossip(receiverB) { unwrappedGossipToReceiverBByReceiverB ->
+                    assertEquals("Who is going to the party tonight?", unwrappedGossipToReceiverBByReceiverB.content)
+
+                    countDownDecryptLatch.countDown()
+                }
+
+                unwrappedMsgForReceiverBByReceiverB.cachedGossip(sender) { unwrappedGossipToReceiverBBySender ->
+                    fail()
+                }
+            }
+        }
+
+        assertTrue(countDownDecryptLatch.await(1, TimeUnit.SECONDS))
     }
 
     @Test
@@ -414,8 +503,15 @@ class GiftWrapEventTest {
  }
         """.trimIndent()
 
-        val privateKey = "de6152a85a0dea3b09a08a6f8139a314d498a7b52f7e5c28858b64270abd4c70"
+        var gossip: Event? = null
-        val gossip = unwrapUnsealGossip(json, privateKey)
+
+        wait1SecondForResult { onDone ->
+            val privateKey = "de6152a85a0dea3b09a08a6f8139a314d498a7b52f7e5c28858b64270abd4c70"
+            unwrapUnsealGossip(json, privateKey) {
+                gossip = it
+                onDone()
+            }
+        }
 
         assertNotNull(gossip)
         assertEquals("Hola, que tal?", gossip?.content)
@@ -441,7 +537,15 @@ class GiftWrapEventTest {
         """.trimIndent()
 
         val privateKey = "409ff7654141eaa16cd2161fe5bd127aeaef71f270c67587474b78998a8e3533"
-        val gossip = unwrapUnsealGossip(json, privateKey)
+
+        var gossip: Event? = null
+
+        wait1SecondForResult { onDone ->
+            unwrapUnsealGossip(json, privateKey) {
+                gossip = it
+                onDone()
+            }
+        }
 
         assertNotNull(gossip)
         assertEquals("Hola, que tal?", gossip?.content)
@@ -470,7 +574,14 @@ class GiftWrapEventTest {
         """.trimIndent()
 
         val privateKey = "09e0051fdf5fdd9dd7a54713583006442cbdbf87bdcdab1a402f26e527d56771"
-        val gossip = unwrapUnsealGossip(json, privateKey)
+        var gossip: Event? = null
+
+        wait1SecondForResult { onDone ->
+            unwrapUnsealGossip(json, privateKey) {
+                gossip = it
+                onDone()
+            }
+        }
 
         assertNotNull(gossip)
         assertEquals("test", gossip?.content)
@@ -497,7 +608,14 @@ class GiftWrapEventTest {
 
         val privateKey = "09e0051fdf5fdd9dd7a54713583006442cbdbf87bdcdab1a402f26e527d56771"
 
-        val gossip = unwrapUnsealGossip(json, privateKey)
+        var gossip: Event? = null
+
+        wait1SecondForResult { onDone ->
+            unwrapUnsealGossip(json, privateKey) {
+                gossip = it
+                onDone()
+            }
+        }
 
         assertEquals("asdfasdfasdf", gossip?.content)
         assertEquals(1690659269L, gossip?.createdAt)
@@ -528,7 +646,14 @@ class GiftWrapEventTest {
 
         val privateKey = "7dd22cafc512c0bc363a259f6dcda515b13ae3351066d7976fd0bb79cbd0d700"
 
-        val gossip = unwrapUnsealGossip(json, privateKey)
+        var gossip: Event? = null
+
+        wait1SecondForResult { onDone ->
+            unwrapUnsealGossip(json, privateKey) {
+                gossip = it
+                onDone()
+            }
+        }
 
         assertEquals("8d1a56008d4e31dae2fb8bef36b3efea519eff75f57033107e2aa16702466ef2", gossip?.id)
         assertEquals("Howdy", gossip?.content)
@@ -540,29 +665,27 @@ class GiftWrapEventTest {
         assertEquals("Stuff", gossip?.tags?.getOrNull(1)?.get(1))
     }
 
-    fun unwrapUnsealGossip(json: String, privateKey: HexKey): Gossip? {
+    fun unwrapUnsealGossip(json: String, privateKey: HexKey, onReady: (Event) -> Unit) {
-        val pkBytes = privateKey.hexToByteArray()
+        val pkBytes = NostrSignerInternal(KeyPair(privateKey.hexToByteArray()))
 
         val wrap = Event.fromJson(json) as GiftWrapEvent
         wrap.checkSignature()
 
-        assertEquals(CryptoUtils.pubkeyCreate(pkBytes).toHexKey(), wrap.recipientPubKey())
+        assertEquals(pkBytes.pubKey, wrap.recipientPubKey())
 
-        val event = wrap.unwrap(pkBytes)
+        wrap.cachedGift(pkBytes) { event ->
-        assertNotNull(event)
+            if (event is SealedGossipEvent) {
-
+                event.cachedGossip(pkBytes, onReady)
-        return if (event is SealedGossipEvent) {
+            } else {
-            return event.unseal(pkBytes)
+                println(event.toJson())
-        } else {
+                fail("Event is not a Sealed Gossip")
-            println(event?.toJson())
+            }
-            fail("Event is not a Sealed Gossip")
-            null
         }
     }
 
     @Test
     fun decryptMsgFromNostrTools() {
-        val receiversPrivateKey = Hex.decode("df51ec558372612918a83446d279d683039bece79b7a721274b1d3cb612dc6af")
+        val receiversPrivateKey = NostrSignerInternal(KeyPair(Hex.decode("df51ec558372612918a83446d279d683039bece79b7a721274b1d3cb612dc6af")))
         val msg = """            
             {
               "tags": [],
@@ -578,9 +701,27 @@ class GiftWrapEventTest {
         val wrap = Event.fromJson(msg) as GiftWrapEvent
         wrap.checkSignature()
 
-        val event = wrap.unwrap(receiversPrivateKey)
+        var event: Event? = null
-        assertNotNull(event)
 
-        println(event)
+        wait1SecondForResult { onDone ->
+            wrap.cachedGift(receiversPrivateKey) {
+                event = it
+                onDone()
+            }
+        }
+
+        assertNotNull(event)
     }
 }
+
+fun wait1SecondForResult(
+    run: (onDone: () -> Unit) -> Unit
+) {
+    val countDownLatch = CountDownLatch(1)
+
+    run {
+        countDownLatch.countDown()
+    }
+
+    assertTrue(countDownLatch.await(1, TimeUnit.SECONDS))
+}

quartz/src/androidTest/java/com/vitorpamplona/quartz/PrivateZapTests.kt

@@ -1,12 +1,14 @@
 package com.vitorpamplona.quartz
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.vitorpamplona.quartz.crypto.KeyPair
 import com.vitorpamplona.quartz.encoders.toHexKey
 import com.vitorpamplona.quartz.events.Event
 import com.vitorpamplona.quartz.events.LnZapEvent
 import com.vitorpamplona.quartz.events.LnZapRequestEvent
 import com.vitorpamplona.quartz.events.LnZapRequestEvent.Companion.createEncryptionPrivateKey
 import com.vitorpamplona.quartz.encoders.Hex
+import com.vitorpamplona.quartz.signers.NostrSignerInternal
 import junit.framework.TestCase.assertNotNull
 import junit.framework.TestCase.fail
 import org.junit.Test
@@ -59,30 +61,44 @@ class PrivateZapTests {
 }
 """)
 
-        val loggedIn = Hex.decode("e8e7197ccc53c9ed4cf9b1c8dce085475fa1ffdd71f2c14e44fe23d0bdf77598")
+        val loggedIn = NostrSignerInternal(KeyPair(Hex.decode("e8e7197ccc53c9ed4cf9b1c8dce085475fa1ffdd71f2c14e44fe23d0bdf77598")))
 
-        val privateZapRequest = LnZapRequestEvent.create(
+        var resultPrivateZap: Event? = null
-            poll,
-            setOf("wss://relay.damus.io/"),
-            loggedIn,
-            0,
-            "",
-            LnZapEvent.ZapType.PRIVATE
-        )
 
-        val recepientPK = privateZapRequest.zappedAuthor().firstOrNull()
+        wait1SecondForResult { onDone ->
-        val recepientPost = privateZapRequest.zappedPost().firstOrNull()
+            LnZapRequestEvent.create(
+                originalNote = poll,
+                relays = setOf("wss://relay.damus.io/"),
+                signer = loggedIn,
+                pollOption = 0,
+                message = "",
+                zapType = LnZapEvent.ZapType.PRIVATE,
+                toUserPubHex = null
+            ) { privateZapRequest ->
+                val recepientPK = privateZapRequest.zappedAuthor().firstOrNull()
+                val recepientPost = privateZapRequest.zappedPost().firstOrNull()
 
-        if (recepientPK != null && recepientPost != null) {
+                if (recepientPK != null && recepientPost != null) {
-            val privateKey = createEncryptionPrivateKey(loggedIn.toHexKey(), recepientPost, privateZapRequest.createdAt)
+                    val privateKey = createEncryptionPrivateKey(
-            val decodedPrivateZap =
+                        loggedIn.keyPair.privKey!!.toHexKey(),
-                privateZapRequest.getPrivateZapEvent(privateKey, recepientPK)
+                        recepientPost,
+                        privateZapRequest.createdAt
+                    )
+                    val decodedPrivateZap =
+                        privateZapRequest.getPrivateZapEvent(privateKey, recepientPK)
 
-            println(decodedPrivateZap?.toJson())
+                    println(decodedPrivateZap?.toJson())
-            assertNotNull(decodedPrivateZap)
+
-        } else {
+                    resultPrivateZap = decodedPrivateZap
-            fail("Should not be null")
+
+                    onDone()
+                } else {
+                    fail("Should not be null")
+                }
+            }
         }
+
+        assertNotNull(resultPrivateZap)
     }
 
     @Test
@@ -107,28 +123,43 @@ class PrivateZapTests {
 }
 """)
 
-        val loggedIn = Hex.decode("e8e7197ccc53c9ed4cf9b1c8dce085475fa1ffdd71f2c14e44fe23d0bdf77598")
+        val loggedIn = NostrSignerInternal(KeyPair(Hex.decode("e8e7197ccc53c9ed4cf9b1c8dce085475fa1ffdd71f2c14e44fe23d0bdf77598")))
 
-        val privateZapRequest = LnZapRequestEvent.create(
+        var resultPrivateZap: Event? = null
-            textNote,
-            setOf("wss://relay.damus.io/", "wss://relay.damus2.io/", "wss://relay.damus3.io/"),
-            loggedIn,
-            null,
-            "test",
-            LnZapEvent.ZapType.PRIVATE
-        )
 
-        val recepientPK = privateZapRequest.zappedAuthor().firstOrNull()
+        wait1SecondForResult { onDone ->
-        val recepientPost = privateZapRequest.zappedPost().firstOrNull()
+            LnZapRequestEvent.create(
+                originalNote = textNote,
+                relays = setOf("wss://relay.damus.io/", "wss://relay.damus2.io/", "wss://relay.damus3.io/"),
+                signer = loggedIn,
+                pollOption = null,
+                message = "test",
+                zapType = LnZapEvent.ZapType.PRIVATE,
+                toUserPubHex = null
+            ) { privateZapRequest ->
+                val recepientPK = privateZapRequest.zappedAuthor().firstOrNull()
+                val recepientPost = privateZapRequest.zappedPost().firstOrNull()
 
-        if (recepientPK != null && recepientPost != null) {
+                if (recepientPK != null && recepientPost != null) {
-            val privateKey = createEncryptionPrivateKey(loggedIn.toHexKey(), recepientPost, privateZapRequest.createdAt)
+                    val privateKey = createEncryptionPrivateKey(
-            val decodedPrivateZap = privateZapRequest.getPrivateZapEvent(privateKey, recepientPK)
+                        loggedIn.keyPair.privKey!!.toHexKey(),
+                        recepientPost,
+                        privateZapRequest.createdAt
+                    )
+                    val decodedPrivateZap =
+                        privateZapRequest.getPrivateZapEvent(privateKey, recepientPK)
 
-            println(decodedPrivateZap?.toJson())
+                    println(decodedPrivateZap?.toJson())
-            assertNotNull(decodedPrivateZap)
+
-        } else {
+                    resultPrivateZap = decodedPrivateZap
-            fail("Should not be null")
+
+                    onDone()
+                } else {
+                    fail("Should not be null")
+                }
+            }
         }
+
+        assertNotNull(resultPrivateZap)
     }
 }