pakstr 0.19.3 → 0.21.0

package/android-template/app/src/main/res/layout/dialog_picker.xml

@@ -1,16 +1,15 @@
 <?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:app="http://android.com"
-    xmlns:android="http://schemas.android.com/apk/res/android"
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
     android:background="@drawable/bg_bottom_sheet"
     android:orientation="vertical"
-    android:paddingBottom="32dp"
-    android:paddingEnd="24dp"
     android:paddingStart="24dp"
-    android:paddingTop="16dp">
+    android:paddingTop="16dp"
+    android:paddingEnd="24dp"
+    android:paddingBottom="32dp">
 
-    <!-- Handle Indicator (Modern Pill) -->
     <View
         android:layout_width="48dp"
         android:layout_height="5dp"
@@ -18,34 +17,30 @@
         android:layout_marginBottom="28dp"
         android:background="#E5E7EB" />
 
-    <!-- Header Title -->
     <TextView
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:text="Welcome"
+        android:fontFamily="sans-serif-medium"
+        android:text="@string/signer_picker_title"
         android:textColor="#1F2937"
         android:textSize="24sp"
-        android:fontFamily="sans-serif-medium"
         android:textStyle="bold" />
 
-    <!-- Header Subtitle -->
     <TextView
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:layout_marginBottom="24dp"
         android:layout_marginTop="6dp"
-        android:text="Please select one of the options to continue:"
+        android:layout_marginBottom="24dp"
+        android:text="@string/signer_picker_subtitle"
         android:textColor="#4B5563"
         android:textSize="15sp" />
 
-    <!-- RadioGroup za selekciju opcija -->
     <RadioGroup
         android:id="@+id/options_radio_group"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:orientation="vertical">
 
-        <!-- OPCIJA 1: Launch Web Application -->
         <RadioButton
             android:id="@+id/radio_option_one"
             android:layout_width="match_parent"
@@ -54,48 +49,82 @@
             android:background="@drawable/selector_radio_card"
             android:button="@null"
             android:checked="true"
-            android:drawableEnd="@drawable/selector_radio_checkmark"
             android:drawableStart="@drawable/ic_menu_browser"
+            android:drawableEnd="@drawable/selector_radio_checkmark"
             android:drawablePadding="16dp"
             android:drawableTint="@drawable/selector_radio_tint"
-            android:paddingEnd="20dp"
+            android:fontFamily="sans-serif-medium"
             android:paddingStart="20dp"
-            android:text="Continue with Amber"
+            android:paddingEnd="20dp"
+            android:text="@string/signer_picker_amber"
             android:textColor="#1F2937"
-            android:textSize="16sp"
-            android:fontFamily="sans-serif-medium" />
+            android:textSize="16sp" />
 
-        <!-- OPCIJA 2: Bunker -->
         <RadioButton
             android:id="@+id/radio_option_two"
             android:layout_width="match_parent"
             android:layout_height="64dp"
-            android:layout_marginBottom="24dp"
+            android:layout_marginBottom="12dp"
             android:background="@drawable/selector_radio_card"
             android:button="@null"
-            android:drawableEnd="@drawable/selector_radio_checkmark"
             android:drawableStart="@drawable/ic_menu_browser"
+            android:drawableEnd="@drawable/selector_radio_checkmark"
             android:drawablePadding="16dp"
             android:drawableTint="@drawable/selector_radio_tint"
-            android:paddingEnd="20dp"
+            android:fontFamily="sans-serif-medium"
             android:paddingStart="20dp"
-            android:text="Connect to remote signer (Bunker)"
+            android:paddingEnd="20dp"
+            android:text="@string/signer_picker_bunker"
             android:textColor="#1F2937"
-            android:textSize="16sp"
-            android:fontFamily="sans-serif-medium" />
-
+            android:textSize="16sp" />
     </RadioGroup>
 
-    <!-- Glavno akciono dugme na dnu -->
+    <com.google.android.material.textfield.TextInputLayout
+        android:id="@+id/bunker_uri_container"
+        style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="12dp"
+        android:hint="@string/signer_picker_bunker_hint"
+        android:visibility="gone">
+
+        <com.google.android.material.textfield.TextInputEditText
+            android:id="@+id/bunker_uri"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:inputType="textUri"
+            android:maxLines="4" />
+    </com.google.android.material.textfield.TextInputLayout>
+
+    <com.google.android.material.button.MaterialButton
+        android:id="@+id/button_share_pairing"
+        style="@style/Widget.MaterialComponents.Button.OutlinedButton"
+        android:layout_width="match_parent"
+        android:layout_height="48dp"
+        android:layout_marginBottom="12dp"
+        android:text="@string/signer_picker_share_pairing"
+        android:textAllCaps="false"
+        android:visibility="gone" />
+
+    <com.google.android.material.button.MaterialButton
+        android:id="@+id/button_logout_bunker"
+        style="@style/Widget.MaterialComponents.Button.TextButton"
+        android:layout_width="match_parent"
+        android:layout_height="48dp"
+        android:layout_marginBottom="12dp"
+        android:text="@string/signer_picker_logout_bunker"
+        android:textAllCaps="false"
+        android:visibility="gone" />
+
     <com.google.android.material.button.MaterialButton
         android:id="@+id/button_confirm"
         android:layout_width="match_parent"
         android:layout_height="56dp"
-        android:text="Continue"
+        android:backgroundTint="#2563EB"
+        android:text="@string/signer_picker_continue"
         android:textAllCaps="false"
-        android:textSize="16sp"
         android:textColor="@android:color/white"
-        android:backgroundTint="#2563EB"
+        android:textSize="16sp"
         app:cornerRadius="16dp" />
 
 </LinearLayout>

package/android-template/app/src/main/res/values/strings.xml

@@ -44,4 +44,31 @@
 
     <string name="developer_tools">Open Developer Tools</string>
     <string name="diagnostics_mode_enabled">Diagnostics mode enabled</string>
+
+    <string name="signer_settings">Signer settings</string>
+    <string name="signer_picker_title">Choose a signer</string>
+    <string name="signer_picker_subtitle">Use Amber or connect to a NIP-46 remote signer.</string>
+    <string name="signer_picker_amber">Continue with Amber</string>
+    <string name="signer_picker_bunker">Connect to remote signer (Bunker)</string>
+    <string name="signer_picker_bunker_hint">Paste a bunker:// connection</string>
+    <string name="signer_picker_share_pairing">Share a nostrconnect:// pairing</string>
+    <string name="signer_picker_logout_bunker">Disconnect remote signer</string>
+    <string name="signer_picker_continue">Continue</string>
+    <string name="signer_picker_invalid_bunker">Enter a valid bunker:// connection.</string>
+    <string name="signer_picker_pairing_relays">Pairing relays (wss://, one per line)</string>
+    <string name="signer_picker_pairing_relays_default">wss://nos.lol\nwss://relay.primal.net\nwss://offchain.pub</string>
+    <string name="signer_picker_pairing_share_title">Pair with remote signer</string>
+    <string name="signer_picker_pairing_qr_title">Scan with Amber</string>
+    <string name="signer_picker_pairing_qr_instructions">In Amber, choose “Scan a QR code”, then scan this code. You can also copy or share the exact pairing URI.</string>
+    <string name="signer_picker_pairing_qr_content_description">QR code containing the nostrconnect pairing URI</string>
+    <string name="signer_picker_pairing_copy">Copy pairing URI</string>
+    <string name="signer_picker_pairing_share">Share pairing URI</string>
+    <string name="signer_picker_pairing_clip_label">Nostrconnect pairing URI</string>
+    <string name="signer_picker_pairing_copied">Pairing URI copied.</string>
+    <string name="signer_picker_pairing_waiting">Waiting for the remote signer to connect…</string>
+    <string name="signer_picker_pairing_connected">Remote signer connected.</string>
+    <string name="signer_picker_pairing_failed">Remote signer pairing timed out.</string>
+    <string name="signer_picker_connection_failed">Unable to configure the remote signer.</string>
+    <string name="signer_picker_disconnected">Remote signer disconnected.</string>
+    <string name="signer_auth_browser_unavailable">No browser is available for signer authorization.</string>
 </resources>

package/android-template/app/src/test/java/com/pakstr/app/LocalServerQueryKeepAliveTest.kt

@@ -0,0 +1,118 @@
+package com.pakstr.app
+
+import fi.iki.elonen.NanoHTTPD
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.BufferedInputStream
+import java.io.ByteArrayOutputStream
+import java.io.InputStream
+import java.net.Socket
+import java.nio.charset.StandardCharsets
+import java.util.Collections
+
+class LocalServerQueryKeepAliveTest {
+
+    @Test
+    fun queryDoesNotLeakToNextRequestOnKeepAliveSession() {
+        val requests = Collections.synchronizedList(mutableListOf<CapturedRequest>())
+        val server = object : NanoHTTPD(0) {
+            override fun serve(session: IHTTPSession): Response {
+                val query = currentRawQueryString(session)
+                requests += CapturedRequest(
+                    uri = session.uri,
+                    rawQuery = session.queryParameterString,
+                    query = query,
+                    localUrl = localRequestUrl(session.uri, query).toString()
+                )
+                return newFixedLengthResponse("ok")
+            }
+        }
+        val encodedEvent = "%7B%22content%22%3A%22${"event".repeat(512)}%22%7D"
+        val callbackQuery = "nip55_event=$encodedEvent"
+
+        server.start()
+        try {
+            Socket("127.0.0.1", server.listeningPort).use { socket ->
+                socket.soTimeout = 5000
+                val input = BufferedInputStream(socket.getInputStream())
+                val output = socket.getOutputStream()
+
+                output.write(
+                    (
+                        "GET /?$callbackQuery HTTP/1.1\r\n" +
+                                "Host: 127.0.0.1\r\n\r\n"
+                    ).toByteArray(StandardCharsets.ISO_8859_1)
+                )
+                output.flush()
+                readResponse(input)
+
+                output.write(
+                    (
+                        "POST /api/auth/login HTTP/1.1\r\n" +
+                                "Host: 127.0.0.1\r\n" +
+                                "Content-Length: 0\r\n\r\n"
+                    ).toByteArray(StandardCharsets.ISO_8859_1)
+                )
+                output.flush()
+                readResponse(input)
+            }
+        } finally {
+            server.stop()
+        }
+
+        assertEquals(2, requests.size)
+        assertEquals(callbackQuery, requests[0].query)
+
+        val loginRequest = requests[1]
+        assertEquals("/api/auth/login", loginRequest.uri)
+        assertEquals(callbackQuery, loginRequest.rawQuery)
+        assertNull(loginRequest.query)
+        assertEquals(
+            "http://127.0.0.1:${Config.PORT}/api/auth/login",
+            loginRequest.localUrl
+        )
+        assertFalse(loginRequest.localUrl.contains("nip55_event"))
+        assertFalse(loginRequest.localUrl.contains(encodedEvent))
+    }
+
+    private fun readResponse(input: InputStream) {
+        val headers = mutableMapOf<String, String>()
+        assertTrue(readLine(input).startsWith("HTTP/1.1 200"))
+        while (true) {
+            val line = readLine(input)
+            if (line.isEmpty()) break
+            val separator = line.indexOf(':')
+            assertTrue(separator > 0)
+            headers[line.substring(0, separator).lowercase()] =
+                line.substring(separator + 1).trim()
+        }
+
+        val contentLength = headers["content-length"]?.toInt() ?: 0
+        repeat(contentLength) {
+            assertTrue(input.read() != -1)
+        }
+    }
+
+    private fun readLine(input: InputStream): String {
+        val bytes = ByteArrayOutputStream()
+        while (true) {
+            val value = input.read()
+            assertTrue(value != -1)
+            if (value == '\r'.code) {
+                assertEquals('\n'.code, input.read())
+                return bytes.toString(StandardCharsets.ISO_8859_1.name())
+            }
+            bytes.write(value)
+        }
+    }
+
+    private data class CapturedRequest(
+        val uri: String,
+        val rawQuery: String?,
+        val query: String?,
+        val localUrl: String
+    )
+}

package/android-template/app/src/test/java/com/pakstr/app/crypto/Bip340SignerTest.kt

@@ -0,0 +1,133 @@
+package com.pakstr.app.crypto
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class Bip340SignerTest {
+
+    @Test
+    fun matches_official_signing_vectors() {
+        VECTORS.forEach { vector ->
+            val privateKey = Bip340Hash.hexToBytes(vector.privateKey)
+            val message = Bip340Hash.hexToBytes(vector.message)
+            val auxiliaryRandom =
+                Bip340Hash.hexToBytes(vector.auxiliaryRandom)
+
+            val signature =
+                Bip340Signer.sign(
+                    privateKey,
+                    message,
+                    auxiliaryRandom
+                )
+
+            assertEquals(
+                vector.publicKey.lowercase(),
+                Bip340Hash.bytesToHex(
+                    Secp256k1.xOnlyPublicKey(privateKey)
+                )
+            )
+            assertEquals(
+                vector.signature.lowercase(),
+                Bip340Hash.bytesToHex(signature)
+            )
+            assertTrue(
+                Bip340Verifier.verify(
+                    vector.publicKey,
+                    vector.message,
+                    vector.signature
+                )
+            )
+        }
+    }
+
+    @Test
+    fun rejects_invalid_signing_inputs() {
+        val validKey = ByteArray(32).also { it[31] = 1 }
+
+        assertThrows(IllegalArgumentException::class.java) {
+            Bip340Signer.sign(
+                ByteArray(32),
+                ByteArray(32),
+                ByteArray(32)
+            )
+        }
+        assertThrows(IllegalArgumentException::class.java) {
+            Bip340Signer.sign(
+                validKey,
+                ByteArray(31),
+                ByteArray(32)
+            )
+        }
+        assertThrows(IllegalArgumentException::class.java) {
+            Bip340Signer.sign(
+                validKey,
+                ByteArray(32),
+                ByteArray(31)
+            )
+        }
+    }
+
+    @Test
+    fun x_only_public_key_is_defensive_copy() {
+        val key =
+            Nip46ClientKey.fromPrivateKey(
+                ByteArray(32).also { it[31] = 3 }
+            )
+
+        key.use {
+            val first = key.publicKey
+            first.fill(0)
+
+            assertArrayEquals(
+                Bip340Hash.hexToBytes(VECTORS.first().publicKey),
+                key.publicKey
+            )
+        }
+    }
+
+    private data class Vector(
+        val privateKey: String,
+        val publicKey: String,
+        val auxiliaryRandom: String,
+        val message: String,
+        val signature: String
+    )
+
+    companion object {
+        // https://github.com/bitcoin/bips/blob/master/bip-0340/test-vectors.csv
+        private val VECTORS =
+            listOf(
+                Vector(
+                    "0000000000000000000000000000000000000000000000000000000000000003",
+                    "F9308A019258C31049344F85F89D5229B531C845836F99B08601F113BCE036F9",
+                    "0000000000000000000000000000000000000000000000000000000000000000",
+                    "0000000000000000000000000000000000000000000000000000000000000000",
+                    "E907831F80848D1069A5371B402410364BDF1C5F8307B0084C55F1CE2DCA821525F66A4A85EA8B71E482A74F382D2CE5EBEEE8FDB2172F477DF4900D310536C0"
+                ),
+                Vector(
+                    "B7E151628AED2A6ABF7158809CF4F3C762E7160F38B4DA56A784D9045190CFEF",
+                    "DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659",
+                    "0000000000000000000000000000000000000000000000000000000000000001",
+                    "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89",
+                    "6896BD60EEAE296DB48A229FF71DFE071BDE413E6D43F917DC8DCF8C78DE33418906D11AC976ABCCB20B091292BFF4EA897EFCB639EA871CFA95F6DE339E4B0A"
+                ),
+                Vector(
+                    "C90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B14E5C9",
+                    "DD308AFEC5777E13121FA72B9CC1B7CC0139715309B086C960E18FD969774EB8",
+                    "C87AA53824B4D7AE2EB035A2B5BBBCCC080E76CDC6D1692C4B0B62D798E6D906",
+                    "7E2D58D8B3BCDF1ABADEC7829054F90DDA9805AAB56C77333024B9D0A508B75C",
+                    "5831AAEED7B44BB74E5EAB94BA9D4294C49BCF2A60728D8B4C200F50DD313C1BAB745879A5AD954A72C45A91C3A51D3C7ADEA98D82F8481E0E1E03674A6F3FB7"
+                ),
+                Vector(
+                    "0B432B2677937381AEF05BB02A66ECD012773062CF3FA2549E44F58ED2401710",
+                    "25D1DFF95105F5253C4022F628A996AD3A0D95FBF21D468A1B33F8C160D8F517",
+                    "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
+                    "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
+                    "7EB0509757E246F19449885651611CB965ECC1A187DD51B64FDA1EDC9637D5EC97582B9CB13DB3933705B32BA982AF5AF25FD78881EBB32771FC5922EFC66EA3"
+                )
+            )
+    }
+}

package/android-template/app/src/test/java/com/pakstr/app/crypto/Nip44CryptoTest.kt

@@ -0,0 +1,199 @@
+package com.pakstr.app.crypto
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import java.util.Base64
+
+class Nip44CryptoTest {
+
+    @Test
+    fun matches_official_conversation_key_vector() {
+        val conversationKey =
+            Nip44Crypto.deriveConversationKey(
+                hex("315e59ff51cb9209768cf7da80791ddcaae56ac9775eb25b6dee1234bc5d2268"),
+                hex("c2f9d9948dc8c7c38321e4b85c8558872eafa0641cd269db76848a6073e69133")
+            )
+
+        assertEquals(
+            "3dfef0ce2a4d80a25e7a328accf73448ef67096f65f79588e358d9a0eb9013f1",
+            Bip340Hash.bytesToHex(conversationKey)
+        )
+    }
+
+    @Test
+    fun matches_official_message_key_vector() {
+        val keys =
+            Nip44Crypto.deriveMessageKeys(
+                hex("a1a3d60f3470a8612633924e91febf96dc5366ce130f658b1f0fc652c20b3b54"),
+                hex("e1e6f880560d6d149ed83dcc7e5861ee62a5ee051f7fde9975fe5d25d2a02d72")
+            )
+
+        keys.use {
+            assertEquals(
+                "f145f3bed47cb70dbeaac07f3a3fe683e822b3715edb7c4fe310829014ce7d76",
+                Bip340Hash.bytesToHex(keys.chachaKey)
+            )
+            assertEquals(
+                "c4ad129bb01180c0933a160c",
+                Bip340Hash.bytesToHex(keys.chachaNonce)
+            )
+            assertEquals(
+                "027c1db445f05e2eee864a0975b0ddef5b7110583c8c192de3732571ca5838c4",
+                Bip340Hash.bytesToHex(keys.hmacKey)
+            )
+        }
+    }
+
+    @Test
+    fun matches_official_encryption_vector() {
+        val conversationKey =
+            hex("c41c775356fd92eadc63ff5a0dc1da211b268cbea22316767095b2871ea1412d")
+        val nonce =
+            hex("0000000000000000000000000000000000000000000000000000000000000001")
+
+        val payload =
+            Nip44Crypto.encryptWithNonce(
+                "a",
+                conversationKey,
+                nonce
+            )
+
+        assertEquals(EXPECTED_PAYLOAD, payload)
+        assertEquals(
+            "a",
+            Nip44Crypto.decryptWithConversationKey(
+                payload,
+                conversationKey
+            )
+        )
+    }
+
+    @Test
+    fun padding_matches_official_boundaries() {
+        mapOf(
+            1L to 32L,
+            16L to 32L,
+            32L to 32L,
+            33L to 64L,
+            65L to 96L,
+            200L to 224L,
+            250L to 256L,
+            257L to 320L,
+            515L to 640L,
+            65535L to 65536L,
+            65536L to 65536L,
+            65537L to 81920L
+        ).forEach { (input, expected) ->
+            assertEquals(
+                expected,
+                Nip44Crypto.calculatePaddedLength(input)
+            )
+        }
+    }
+
+    @Test
+    fun encrypt_round_trip_uses_fresh_nonce() {
+        val privateKey = ByteArray(32).also { it[31] = 1 }
+        val publicKey =
+            Secp256k1.xOnlyPublicKey(
+                ByteArray(32).also { it[31] = 2 }
+            )
+
+        val first = Nip44Crypto.encrypt("hello", privateKey, publicKey)
+        val second = Nip44Crypto.encrypt("hello", privateKey, publicKey)
+
+        assertFalse(first == second)
+        assertEquals(
+            "hello",
+            Nip44Crypto.decrypt(first, privateKey, publicKey)
+        )
+    }
+
+    @Test
+    fun rejects_empty_plaintext_and_non_canonical_base64() {
+        val conversationKey =
+            hex("c41c775356fd92eadc63ff5a0dc1da211b268cbea22316767095b2871ea1412d")
+        val nonce =
+            hex("0000000000000000000000000000000000000000000000000000000000000001")
+
+        assertThrows(IllegalArgumentException::class.java) {
+            Nip44Crypto.encryptWithNonce("", conversationKey, nonce)
+        }
+
+        val canonical = Nip44Crypto.encryptWithNonce(
+            "a".repeat(33),
+            conversationKey,
+            nonce
+        )
+        assertTrue(canonical.endsWith("="))
+        val alphabet =
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+        val finalDataIndex = canonical.length - 2
+        val canonicalValue = alphabet.indexOf(canonical[finalDataIndex])
+        val nonCanonical = canonical.replaceRange(
+            finalDataIndex,
+            finalDataIndex + 1,
+            alphabet[canonicalValue xor 1].toString()
+        )
+        assertArrayEquals(
+            Base64.getDecoder().decode(canonical),
+            Base64.getDecoder().decode(nonCanonical)
+        )
+
+        assertThrows(IllegalArgumentException::class.java) {
+            Nip44Crypto.decryptWithConversationKey(
+                nonCanonical,
+                conversationKey
+            )
+        }
+    }
+
+    @Test
+    fun rejects_tampered_mac_and_unknown_version() {
+        val conversationKey =
+            hex("c41c775356fd92eadc63ff5a0dc1da211b268cbea22316767095b2871ea1412d")
+        val decoded = Base64.getDecoder().decode(EXPECTED_PAYLOAD)
+
+        decoded[decoded.lastIndex] =
+            (decoded.last().toInt() xor 1).toByte()
+        val tampered = Base64.getEncoder().encodeToString(decoded)
+
+        assertThrows(IllegalArgumentException::class.java) {
+            Nip44Crypto.decryptWithConversationKey(
+                tampered,
+                conversationKey
+            )
+        }
+
+        decoded[0] = 3
+        val unknownVersion =
+            Base64.getEncoder().encodeToString(decoded)
+
+        assertThrows(IllegalArgumentException::class.java) {
+            Nip44Crypto.decryptWithConversationKey(
+                unknownVersion,
+                conversationKey
+            )
+        }
+        assertThrows(IllegalArgumentException::class.java) {
+            Nip44Crypto.decryptWithConversationKey(
+                "#$EXPECTED_PAYLOAD",
+                conversationKey
+            )
+        }
+    }
+
+    private fun hex(value: String): ByteArray {
+        return Bip340Hash.hexToBytes(value)
+    }
+
+    companion object {
+        // https://github.com/paulmillr/nip44/blob/master/nip44.vectors.json
+        private const val EXPECTED_PAYLOAD =
+            "AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABee0G5VSK0/9YypIObAtDKfYEAjD35uVkHyB0F4DwrcNaCXlCWZKaArsGrY6M9wnuTMxWfp1RTN9Xga8no+kF5Vsb"
+    }
+}