diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/FlexibleIntListSerializer.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/FlexibleIntListSerializer.kt new file mode 100644 index 000000000..cdb3159d4 --- /dev/null +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/FlexibleIntListSerializer.kt @@ -0,0 +1,89 @@ +/** + * Copyright (c) 2025 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.nip11RelayInfo + +import kotlinx.serialization.ExperimentalSerializationApi +import kotlinx.serialization.KSerializer +import kotlinx.serialization.builtins.ListSerializer +import kotlinx.serialization.builtins.serializer +import kotlinx.serialization.descriptors.SerialDescriptor +import kotlinx.serialization.encoding.Decoder +import kotlinx.serialization.encoding.Encoder +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonDecoder +import kotlinx.serialization.json.JsonNull +import kotlinx.serialization.json.JsonPrimitive +import kotlinx.serialization.json.int +import kotlinx.serialization.json.jsonPrimitive + +object FlexibleIntListSerializer : KSerializer?> { + private val listSerializer = ListSerializer(Int.serializer()) + + override val descriptor: SerialDescriptor = listSerializer.descriptor + + override fun deserialize(decoder: Decoder): List? { + require(decoder is JsonDecoder) { "This serializer can only be used with Json format" } + + val element = decoder.decodeJsonElement() + + return when { + // Handle JSON null + element is JsonNull -> null + + // Handle array format (spec-compliant): [1, 2, 3] + element is JsonArray -> { + element.mapNotNull { arrayElement -> + try { + arrayElement.jsonPrimitive.int + } catch (e: Exception) { + // Skip elements that aren't valid integers (strings, booleans, floats, etc.) + null + } + } + } + + // Handle single integer format (malformed but found in the wild): 1 + element is JsonPrimitive && !element.isString -> { + try { + listOf(element.int) + } catch (e: Exception) { + // Can't parse as integer (e.g., float, boolean), treat as missing data + null + } + } + + // Unsupported format (strings, objects, etc.) + else -> null + } + } + + @OptIn(ExperimentalSerializationApi::class) + override fun serialize( + encoder: Encoder, + value: List?, + ) { + if (value == null) { + encoder.encodeNull() + } else { + listSerializer.serialize(encoder, value) + } + } +} diff --git a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/Nip11RelayInformation.kt b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/Nip11RelayInformation.kt index fce0f2b4e..593f20494 100644 --- a/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/Nip11RelayInformation.kt +++ b/quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/Nip11RelayInformation.kt @@ -32,6 +32,7 @@ class Nip11RelayInformation( val icon: String? = null, val pubkey: String? = null, val contact: String? = null, + @Serializable(with = FlexibleIntListSerializer::class) val supported_nips: List? = null, val supported_nip_extensions: List? = null, val software: String? = null, diff --git a/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/Nip11RelayInformationTest.kt b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/Nip11RelayInformationTest.kt new file mode 100644 index 000000000..3f8653f2d --- /dev/null +++ b/quartz/src/commonTest/kotlin/com/vitorpamplona/quartz/nip11RelayInfo/Nip11RelayInformationTest.kt @@ -0,0 +1,209 @@ +/** + * Copyright (c) 2025 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.nip11RelayInfo + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertNull + +class Nip11RelayInformationTest { + // Test case for properly formatted relay info with array of supported NIPs + val standardFormatJson = + """ + { + "contact":"_@f7z.io", + "description":"Nostr's Purple Pages", + "limitation":{ + "max_limit":5000000, + "max_message_length":131072, + "max_subscriptions":50000 + }, + "name":"purplepag.es", + "negentropy":1, + "pubkey":"fa984bd7dbb282f07e16e7ae87b26a2a7b9b90b7246a44771f0cf5ae58018f52", + "software":"git+https://github.com/hoytech/strfry.git", + "supported_nips":[1,2,9,11], + "version":"1.0.4" + } + """.trimIndent() + + // Test case for malformed relay info where supported_nips is a single integer instead of an array + val malformedSingleIntegerJson = + """ + { + "contact":"_@f7z.io", + "description":"Nostr's Purple Pages", + "limitation":{ + "max_limit":5000000, + "max_message_length":131072, + "max_subscriptions":50000 + }, + "name":"purplepag.es", + "negentropy":1, + "pubkey":"fa984bd7dbb282f07e16e7ae87b26a2a7b9b90b7246a44771f0cf5ae58018f52", + "software":"git+https://github.com/hoytech/strfry.git", + "supported_nips":1, + "version":"1.0.4" + } + """.trimIndent() + + @Test + fun `Parse standard format`() { + val info = Nip11RelayInformation.fromJson(standardFormatJson) + + assertNotNull(info) + assertEquals("purplepag.es", info.name) + assertEquals("Nostr's Purple Pages", info.description) + assertEquals("fa984bd7dbb282f07e16e7ae87b26a2a7b9b90b7246a44771f0cf5ae58018f52", info.pubkey) + assertEquals(listOf(1, 2, 9, 11), info.supported_nips) + assertEquals("1.0.4", info.version) + assertEquals("git+https://github.com/hoytech/strfry.git", info.software) + } + + @Test + fun `Parse malformed single integer`() { + val info = Nip11RelayInformation.fromJson(malformedSingleIntegerJson) + + assertNotNull(info) + assertEquals("purplepag.es", info.name) + assertEquals("Nostr's Purple Pages", info.description) + assertEquals("fa984bd7dbb282f07e16e7ae87b26a2a7b9b90b7246a44771f0cf5ae58018f52", info.pubkey) + // Single integer should be converted to a list with one element + assertEquals(listOf(1), info.supported_nips) + assertEquals("1.0.4", info.version) + assertEquals("git+https://github.com/hoytech/strfry.git", info.software) + } + + @Test + fun `Parse null value`() { + val json = """{"name":"test relay","supported_nips":null}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + assertNull(info.supported_nips) + } + + @Test + fun `Parse missing field`() { + val json = """{"name":"test relay","version":"1.0"}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + assertNull(info.supported_nips) // Field is optional with default null + } + + @Test + fun `Parse empty array`() { + val json = """{"name":"test relay","supported_nips":[]}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + assertEquals(emptyList(), info.supported_nips) + } + + @Test + fun `Parse malformed array With invalid elements`() { + // Array contains valid integers mixed with invalid elements (strings, floats, booleans) + val json = """{"name":"test relay","supported_nips":[1,"invalid",3,4.5,true,11]}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + // Should skip invalid elements and keep only valid integers + assertEquals(listOf(1, 3, 11), info.supported_nips) + } + + @Test + fun `Parse malformed array with all invalid elements`() { + // Array contains only invalid elements + val json = """{"name":"test relay","supported_nips":["one","two","three"]}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + // All elements invalid, should result in empty list + assertEquals(emptyList(), info.supported_nips) + } + + @Test + fun `Parse invalid primitive float`() { + // Float instead of int + val json = """{"name":"test relay","supported_nips":1.5}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + // Cannot parse float as integer, should be null + assertNull(info.supported_nips) + } + + @Test + fun `Parse invalid primitive boolean`() { + // Boolean instead of int/array + val json = """{"name":"test relay","supported_nips":true}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + // Cannot parse boolean as integer, should be null + assertNull(info.supported_nips) + } + + @Test + fun `Parse invalid primitive string`() { + // String instead of int/array + val json = """{"name":"test relay","supported_nips":"1"}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + // Strings are explicitly excluded (element.isString check), should be null + assertNull(info.supported_nips) + } + + @Test + fun `Parse invalid object`() { + // Object instead of int/array + val json = """{"name":"test relay","supported_nips":{"nip":1}}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + // Objects are unsupported format, should be null + assertNull(info.supported_nips) + } + + @Test + fun `Parse large array`() { + // Test with a large array to ensure no performance issues + val nips = (1..100).joinToString(",") + val json = """{"name":"test relay","supported_nips":[$nips]}""" + val info = Nip11RelayInformation.fromJson(json) + + assertNotNull(info) + assertEquals("test relay", info.name) + assertEquals((1..100).toList(), info.supported_nips) + } +}