Fixes Wallet import encoding bug

quartz/src/appleMain/kotlin/com/vitorpamplona/quartz/utils/UriParser.apple.kt

@@ -45,9 +45,15 @@ actual class UriParser actual constructor(
         return queryItems.mapNotNull { (it as? NSURLQueryItem)?.name }.toSet()
     }
 
-    actual fun getQueryParameter(param: String): String? {
+    actual fun getQueryParameter(param: String): List<String>? {
         val queryItems = nsUrlComponents.queryItems ?: return null
-        return (queryItems.firstOrNull { (it as? NSURLQueryItem)?.name == param } as? NSURLQueryItem)?.value
+        return queryItems.mapNotNull {
+            if ((it as? NSURLQueryItem)?.name == param) {
+                it.value
+            } else {
+                null
+            }
+        }
     }
 
     val fragments: Map<String, String> by lazy {

quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/nip47WalletConnect/Nip47WalletConnect.kt

@@ -63,10 +63,10 @@ class Nip47WalletConnect {
                     throw IllegalArgumentException("Hostname is not a valid Nostr Pubkey")
                 }
 
-            val relay = url.getQueryParameter("relay") ?: throw IllegalArgumentException("Relay cannot be null")
+            val relay = url.getQueryParameter("relay")?.firstOrNull() ?: throw IllegalArgumentException("Relay cannot be null")
             val relayNorm = RelayUrlNormalizer.normalizeOrNull(relay) ?: throw IllegalArgumentException("Invalid relay Url")
-            val secret = url.getQueryParameter("secret")
-            val lud16 = url.getQueryParameter("lud16")
+            val secret = url.getQueryParameter("secret")?.firstOrNull()
+            val lud16 = url.getQueryParameter("lud16")?.firstOrNull()
 
             return Nip47URINorm(pubkeyHex, relayNorm, secret, lud16)
         }

quartz/src/commonMain/kotlin/com/vitorpamplona/quartz/utils/UriParser.kt

@@ -33,7 +33,7 @@ expect class UriParser(
 
     fun queryParameterNames(): Set<String>
 
-    fun getQueryParameter(param: String): String?
+    fun getQueryParameter(param: String): List<String>?
 
     fun fragments(): Map<String, String>
 }

quartz/src/jvmAndroid/kotlin/com/vitorpamplona/quartz/utils/UriParser.jvmAndroid.kt

@@ -22,22 +22,32 @@ package com.vitorpamplona.quartz.utils
 
 import java.net.URI
 import java.net.URLDecoder
+import kotlin.getValue
 
 actual class UriParser actual constructor(
     uri: String,
 ) {
     private val myUri = URI.create(uri)
 
-    private val queryParameters: Map<String, String> by lazy {
-        myUri.query?.ifBlank { null }?.let { query ->
-            query.split('&').associate { paramValue ->
+    private val queryParameters: Map<String, List<String>> by lazy {
+        myUri.rawQuery?.ifBlank { null }?.let { query ->
+            val params = mutableMapOf<String, MutableList<String>>()
+
+            query.split('&').forEach { paramValue ->
                 val parts = paramValue.split("=", limit = 2)
+                val currentValue =
+                    params.getOrPut(parts[0]) {
+                        mutableListOf()
+                    }
+
                 if (parts.size == 2) {
-                    parts[0] to URLDecoder.decode(parts[1], "UTF-8")
+                    currentValue.add(URLDecoder.decode(parts[1], "UTF-8"))
                 } else {
-                    parts[0] to "" // Handle parameters without a value
+                    currentValue.add("")
                 }
             }
+
+            params
         } ?: emptyMap()
     }
 
@@ -67,7 +77,7 @@ actual class UriParser actual constructor(
 
     actual fun queryParameterNames(): Set<String> = queryParameters.keys
 
-    actual fun getQueryParameter(param: String): String? = queryParameters[param]
+    actual fun getQueryParameter(param: String): List<String>? = queryParameters[param]
 
     actual fun fragments(): Map<String, String> = fragments
 }

quartz/src/linuxMain/kotlin/com/vitorpamplona/quartz/utils/UriParser.linux.kt

@@ -125,20 +125,20 @@ actual class UriParser actual constructor(
         val query = parsedQuery ?: return emptySet()
         return query
             .split('&')
-            .mapNotNull { param ->
+            .map { param ->
                 val eqIndex = param.indexOf('=')
                 if (eqIndex >= 0) param.substring(0, eqIndex) else param
             }.toSet()
     }
 
-    actual fun getQueryParameter(param: String): String? {
+    actual fun getQueryParameter(param: String): List<String>? {
         val query = parsedQuery ?: return null
         return query
             .split('&')
-            .firstOrNull { part ->
+            .filter { part ->
                 val eqIndex = part.indexOf('=')
                 if (eqIndex >= 0) part.substring(0, eqIndex) == param else part == param
-            }?.let { part ->
+            }.map { part ->
                 val eqIndex = part.indexOf('=')
                 if (eqIndex >= 0) part.substring(eqIndex + 1) else ""
             }