1 files changed, 149 insertions, 64 deletions

diff --git a/55.md b/55.md
index 4565e8c..afca0aa 100644
--- a/55.md
+++ b/55.md
@@ -1,6 +1,8 @@
-# NIP-55
+NIP-55
+======
 
-## Android Signer Application
+Android Signer Application
+--------------------------
 
 `draft` `optional`
 
@@ -51,8 +53,8 @@ val launcher = rememberLauncherForActivityResult(
                 Toast.LENGTH_SHORT
             ).show()
         } else {
-            val signature = activityResult.data?.getStringExtra("signature")
-            // Do something with signature ...
+            val result = activityResult.data?.getStringExtra("result")
+            // Do something with result ...
         }
     }
 )
@@ -70,6 +72,35 @@ Set the Signer package name:
 intent.`package` = "com.example.signer"
 ```
 
+If you are sending multiple intents without awaiting you can add some intent flags to sign all events without opening multiple times the signer
+
+```kotlin
+intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+```
+
+If you are developing a signer application them you need to add this to your AndroidManifest.xml so clients can use the intent flags above
+
+```kotlin
+android:launchMode="singleTop"
+```
+
+Signer MUST answer multiple permissions with an array of results
+
+```kotlin
+
+val results = listOf(
+  Result(
+    package = signerPackageName,
+    result = eventSignture,
+    id = intentId
+  )
+)
+
+val json = results.toJson()
+
+intent.putExtra("results", json)
+```
+
 Send the Intent:
 
 ```kotlin
@@ -99,10 +130,10 @@ launcher.launch(intent)
     context.startActivity(intent)
     ```
   - result:
-    - If the user approved intent it will return the **npub** in the signature field
+    - If the user approved intent it will return the **pubkey** in the result field
 
       ```kotlin
-      val npub = intent.data?.getStringExtra("signature")
+      val pubkey = intent.data?.getStringExtra("result")
       // The package name of the signer application
       val packageName = intent.data?.getStringExtra("package")
       ```
@@ -116,16 +147,16 @@ launcher.launch(intent)
     intent.putExtra("type", "sign_event")
     // To handle results when not waiting between intents
     intent.putExtra("id", event.id)
-    // Send the current logged in user npub
-    intent.putExtra("current_user", npub)
+    // Send the current logged in user pubkey
+    intent.putExtra("current_user", pubkey)
 
     context.startActivity(intent)
     ```
   - result:
-    - If the user approved intent it will return the **signature**, **id** and **event** fields
+    - If the user approved intent it will return the **result**, **id** and **event** fields
 
       ```kotlin
-      val signature = intent.data?.getStringExtra("signature")
+      val signature = intent.data?.getStringExtra("result")
       // The id you sent
       val id = intent.data?.getStringExtra("id")
       val signedEventJson = intent.data?.getStringExtra("event")
@@ -140,18 +171,18 @@ launcher.launch(intent)
     intent.putExtra("type", "nip04_encrypt")
     // to control the result in your application in case you are not waiting the result before sending another intent
     intent.putExtra("id", "some_id")
-    // Send the current logged in user npub
-    intent.putExtra("current_user", account.keyPair.pubKey.toNpub())
-    // Send the hex pubKey that will be used for encrypting the data
-    intent.putExtra("pubKey", pubKey)
+    // Send the current logged in user pubkey
+    intent.putExtra("current_user", account.keyPair.pubkey)
+    // Send the hex pubkey that will be used for encrypting the data
+    intent.putExtra("pubkey", pubkey)
 
     context.startActivity(intent)
     ```
   - result:
-    - If the user approved intent it will return the **signature** and **id** fields
+    - If the user approved intent it will return the **result** and **id** fields
 
       ```kotlin
-      val encryptedText = intent.data?.getStringExtra("signature")
+      val encryptedText = intent.data?.getStringExtra("result")
       // the id you sent
       val id = intent.data?.getStringExtra("id")
       ```
@@ -165,10 +196,10 @@ launcher.launch(intent)
     intent.putExtra("type", "nip44_encrypt")
     // to control the result in your application in case you are not waiting the result before sending another intent
     intent.putExtra("id", "some_id")
-    // Send the current logged in user npub
-    intent.putExtra("current_user", account.keyPair.pubKey.toNpub())
-    // Send the hex pubKey that will be used for encrypting the data
-    intent.putExtra("pubKey", pubKey)
+    // Send the current logged in user pubkey
+    intent.putExtra("current_user", account.keyPair.pubkey)
+    // Send the hex pubkey that will be used for encrypting the data
+    intent.putExtra("pubkey", pubkey)
 
     context.startActivity(intent)
     ```
@@ -190,18 +221,18 @@ launcher.launch(intent)
     intent.putExtra("type", "nip04_decrypt")
     // to control the result in your application in case you are not waiting the result before sending another intent
     intent.putExtra("id", "some_id")
-    // Send the current logged in user npub
-    intent.putExtra("current_user", account.keyPair.pubKey.toNpub())
-    // Send the hex pubKey that will be used for decrypting the data
-    intent.putExtra("pubKey", pubKey)
+    // Send the current logged in user pubkey
+    intent.putExtra("current_user", account.keyPair.pubkey)
+    // Send the hex pubkey that will be used for decrypting the data
+    intent.putExtra("pubkey", pubkey)
 
     context.startActivity(intent)
     ```
   - result:
-    - If the user approved intent it will return the **signature** and **id** fields
+    - If the user approved intent it will return the **result** and **id** fields
 
       ```kotlin
-      val plainText = intent.data?.getStringExtra("signature")
+      val plainText = intent.data?.getStringExtra("result")
       // the id you sent
       val id = intent.data?.getStringExtra("id")
       ```
@@ -215,18 +246,41 @@ launcher.launch(intent)
     intent.putExtra("type", "nip04_decrypt")
     // to control the result in your application in case you are not waiting the result before sending another intent
     intent.putExtra("id", "some_id")
-    // Send the current logged in user npub
-    intent.putExtra("current_user", account.keyPair.pubKey.toNpub())
-    // Send the hex pubKey that will be used for decrypting the data
-    intent.putExtra("pubKey", pubKey)
+    // Send the current logged in user pubkey
+    intent.putExtra("current_user", account.keyPair.pubkey)
+    // Send the hex pubkey that will be used for decrypting the data
+    intent.putExtra("pubkey", pubkey)
 
     context.startActivity(intent)
     ```
   - result:
-    - If the user approved intent it will return the **signature** and **id** fields
+    - If the user approved intent it will return the **result** and **id** fields
 
       ```kotlin
-      val plainText = intent.data?.getStringExtra("signature")
+      val plainText = intent.data?.getStringExtra("result")
+      // the id you sent
+      val id = intent.data?.getStringExtra("id")
+      ```
+
+- **get_relays**
+  - params:
+
+    ```kotlin
+    val intent = Intent(Intent.ACTION_VIEW, Uri.parse("nostrsigner:"))
+    intent.`package` = "com.example.signer"
+    intent.putExtra("type", "get_relays")
+    // to control the result in your application in case you are not waiting the result before sending another intent
+    intent.putExtra("id", "some_id")
+    // Send the current logged in user pubkey
+    intent.putExtra("current_user", account.keyPair.pubkey)
+
+    context.startActivity(intent)
+    ```
+  - result:
+    - If the user approved intent it will return the **result** and **id** fields
+
+      ```kotlin
+      val relayJsonText = intent.data?.getStringExtra("result")
       // the id you sent
       val id = intent.data?.getStringExtra("id")
       ```
@@ -240,15 +294,15 @@ launcher.launch(intent)
     intent.putExtra("type", "decrypt_zap_event")
     // to control the result in your application in case you are not waiting the result before sending another intent
     intent.putExtra("id", "some_id")
-    // Send the current logged in user npub
-    intent.putExtra("current_user", account.keyPair.pubKey.toNpub())
+    // Send the current logged in user pubkey
+    intent.putExtra("current_user", account.keyPair.pubkey)
     context.startActivity(intent)
     ```
   - result:
-    - If the user approved intent it will return the **signature** and **id** fields
+    - If the user approved intent it will return the **result** and **id** fields
 
       ```kotlin
-      val eventJson = intent.data?.getStringExtra("signature")
+      val eventJson = intent.data?.getStringExtra("result")
       // the id you sent
       val id = intent.data?.getStringExtra("id")
       ```
@@ -257,11 +311,11 @@ launcher.launch(intent)
 
 To get the result back from Signer Application you should use contentResolver.query in Kotlin. If you are using another framework check the documentation of your framework or a third party library to get the result.
 
-If the user did not check the "remember my choice" option, the npub is not in Signer Application or the signer type is not recognized the `contentResolver` will return null
+If the user did not check the "remember my choice" option, the pubkey is not in Signer Application or the signer type is not recognized the `contentResolver` will return null
 
-For the SIGN_EVENT type Signer Application returns two columns "signature" and "event". The column event is the signed event json
+For the SIGN_EVENT type Signer Application returns two columns "result" and "event". The column event is the signed event json
 
-For the other types Signer Application returns the column "signature"
+For the other types Signer Application returns the column "result"
 
 If the user chose to always reject the event, signer application will return the column "rejected" and you should not open signer application
 
@@ -280,15 +334,15 @@ If the user chose to always reject the event, signer application will return the
     )
     ```
   - result:
-    - Will return the **npub** in the signature column
+    - Will return the **pubkey** in the result column
 
       ```kotlin
         if (result == null) return
 
         if (result.moveToFirst()) {
-            val index = it.getColumnIndex("signature")
+            val index = it.getColumnIndex("result")
             if (index < 0) return
-            val npub = it.getString(index)
+            val pubkey = it.getString(index)
         }
       ```
 
@@ -298,20 +352,20 @@ If the user chose to always reject the event, signer application will return the
     ```kotlin
     val result = context.contentResolver.query(
         Uri.parse("content://com.example.signer.SIGN_EVENT"),
-        listOf("$eventJson", "", "${logged_in_user_npub}"),
+        listOf("$eventJson", "", "${logged_in_user_pubkey}"),
         null,
         null,
         null
     )
     ```
   - result:
-    - Will return the **signature** and the **event** columns
+    - Will return the **result** and the **event** columns
 
       ```kotlin
         if (result == null) return
 
         if (result.moveToFirst()) {
-            val index = it.getColumnIndex("signature")
+            val index = it.getColumnIndex("result")
             val indexJson = it.getColumnIndex("event")
             val signature = it.getString(index)
             val eventJson = it.getString(indexJson)
@@ -324,20 +378,20 @@ If the user chose to always reject the event, signer application will return the
     ```kotlin
     val result = context.contentResolver.query(
         Uri.parse("content://com.example.signer.NIP04_ENCRYPT"),
-        listOf("$plainText", "${hex_pub_key}", "${logged_in_user_npub}"),
+        listOf("$plainText", "${hex_pub_key}", "${logged_in_user_pubkey}"),
         null,
         null,
         null
     )
     ```
   - result:
-    - Will return the **signature** column
+    - Will return the **result** column
 
       ```kotlin
         if (result == null) return
 
         if (result.moveToFirst()) {
-            val index = it.getColumnIndex("signature")
+            val index = it.getColumnIndex("result")
             val encryptedText = it.getString(index)
         }
       ```
@@ -348,20 +402,20 @@ If the user chose to always reject the event, signer application will return the
     ```kotlin
     val result = context.contentResolver.query(
         Uri.parse("content://com.example.signer.NIP44_ENCRYPT"),
-        listOf("$plainText", "${hex_pub_key}", "${logged_in_user_npub}"),
+        listOf("$plainText", "${hex_pub_key}", "${logged_in_user_pubkey}"),
         null,
         null,
         null
     )
     ```
   - result:
-    - Will return the **signature** column
+    - Will return the **result** column
 
       ```kotlin
         if (result == null) return
 
         if (result.moveToFirst()) {
-            val index = it.getColumnIndex("signature")
+            val index = it.getColumnIndex("result")
             val encryptedText = it.getString(index)
         }
       ```
@@ -372,20 +426,20 @@ If the user chose to always reject the event, signer application will return the
     ```kotlin
     val result = context.contentResolver.query(
         Uri.parse("content://com.example.signer.NIP04_DECRYPT"),
-        listOf("$encryptedText", "${hex_pub_key}", "${logged_in_user_npub}"),
+        listOf("$encryptedText", "${hex_pub_key}", "${logged_in_user_pubkey}"),
         null,
         null,
         null
     )
     ```
   - result:
-    - Will return the **signature** column
+    - Will return the **result** column
 
       ```kotlin
         if (result == null) return
 
         if (result.moveToFirst()) {
-            val index = it.getColumnIndex("signature")
+            val index = it.getColumnIndex("result")
             val encryptedText = it.getString(index)
         }
       ```
@@ -396,44 +450,68 @@ If the user chose to always reject the event, signer application will return the
     ```kotlin
     val result = context.contentResolver.query(
         Uri.parse("content://com.example.signer.NIP44_DECRYPT"),
-        listOf("$encryptedText", "${hex_pub_key}", "${logged_in_user_npub}"),
+        listOf("$encryptedText", "${hex_pub_key}", "${logged_in_user_pubkey}"),
         null,
         null,
         null
     )
     ```
   - result:
-    - Will return the **signature** column
+    - Will return the **result** column
 
       ```kotlin
         if (result == null) return
 
         if (result.moveToFirst()) {
-            val index = it.getColumnIndex("signature")
+            val index = it.getColumnIndex("result")
             val encryptedText = it.getString(index)
         }
       ```
 
+- **get_relays**
+  - params:
+
+    ```kotlin
+    val result = context.contentResolver.query(
+        Uri.parse("content://com.example.signer.GET_RELAYS"),
+        listOf("${logged_in_user_pubkey}"),
+        null,
+        null,
+        null
+    )
+    ```
+  - result:
+    - Will return the **result** column
+
+      ```kotlin
+        if (result == null) return
+
+        if (result.moveToFirst()) {
+            val index = it.getColumnIndex("result")
+            val relayJsonText = it.getString(index)
+        }
+      ```
+
 - **decrypt_zap_event**
   - params:
 
     ```kotlin
     val result = context.contentResolver.query(
         Uri.parse("content://com.example.signer.DECRYPT_ZAP_EVENT"),
-        listOf("$eventJson", "", "${logged_in_user_npub}"),
+        listOf("$eventJson", "", "${logged_in_user_pubkey}"),
         null,
         null,
         null
     )
     ```
   - result:
-    - Will return the **signature** column
+    - Will return the **result** column
 
       ```kotlin
         if (result == null) return
 
         if (result.moveToFirst()) {
-            val index = it.getColumnIndex("signature")
+            val index = it.getColumnIndex("result")
             val eventJson = it.getString(index)
         }
       ```
@@ -470,28 +548,35 @@ Android intents and browser urls have limitations, so if you are using the `retu
   - params:
 
     ```js
-    window.href = `nostrsigner:${plainText}?pubKey=${hex_pub_key}&compressionType=none&returnType=signature&type=nip04_encrypt&callbackUrl=https://example.com/?event=`;
+    window.href = `nostrsigner:${plainText}?pubkey=${hex_pub_key}&compressionType=none&returnType=signature&type=nip04_encrypt&callbackUrl=https://example.com/?event=`;
     ```
 
 - **nip44_encrypt**
   - params:
 
     ```js
-    window.href = `nostrsigner:${plainText}?pubKey=${hex_pub_key}&compressionType=none&returnType=signature&type=nip44_encrypt&callbackUrl=https://example.com/?event=`;
+    window.href = `nostrsigner:${plainText}?pubkey=${hex_pub_key}&compressionType=none&returnType=signature&type=nip44_encrypt&callbackUrl=https://example.com/?event=`;
     ```
 
 - **nip04_decrypt**
   - params:
 
     ```js
-    window.href = `nostrsigner:${encryptedText}?pubKey=${hex_pub_key}&compressionType=none&returnType=signature&type=nip04_decrypt&callbackUrl=https://example.com/?event=`;
+    window.href = `nostrsigner:${encryptedText}?pubkey=${hex_pub_key}&compressionType=none&returnType=signature&type=nip04_decrypt&callbackUrl=https://example.com/?event=`;
     ```
 
 - **nip44_decrypt**
   - params:
 
     ```js
-    window.href = `nostrsigner:${encryptedText}?pubKey=${hex_pub_key}&compressionType=none&returnType=signature&type=nip44_decrypt&callbackUrl=https://example.com/?event=`;
+    window.href = `nostrsigner:${encryptedText}?pubkey=${hex_pub_key}&compressionType=none&returnType=signature&type=nip44_decrypt&callbackUrl=https://example.com/?event=`;
+    ```
+
+- **get_relays**
+  - params:
+
+    ```js
+    window.href = `nostrsigner:?compressionType=none&returnType=signature&type=get_relays&callbackUrl=https://example.com/?event=`;
     ```
 
 - **decrypt_zap_event**