Shared Key DM

43.md

@@ -0,0 +1,115 @@
+NIP-43
+======
+
+Shared Key DM
+-------------
+
+`draft` `optional`
+
+This direct message (DM) scheme between two participants aims to hide metadata while keeping the regular client-relay filtering experience.
+
+## Chat Request
+
+A `kind:1043` "Chat Request" event is sent from user A to B. If user A has sent a considerable amount of messages with no reply from user B,
+it can send to B another "Chat Request" event.
+
+The chat request uses a random pubkey to hide who's the requester. It wraps an encrypted `kind:30043` "Pubkey Owner Proof" event
+signed by user A's privkey, proving it owns the key as long as the event has a `created_at` not too far in the past.
+
+The inner event is a parameterized replaceable one with no `d` tag to make it hard to be accepted by relays if the receiver tries to publish it.
+It has a `p` tag with the receiver pubkey to make it focused to this specific interaction, to avoid its reuse.
+It has an empty `.content` so that it has little value for spammers (there is no attached message to show to the receiver).
+
+This event should be sent to atleast one of the receiver's [NIP-65](65.md) `read` relays.
+
+```js
+{
+  "kind": 1043,
+  "pubkey": "<random>",
+  "tags": [
+    ["p", "<pubkey-B>"]
+  ]
+  "content": "<nip44Encrypt(JSON.stringify({
+    "kind": 30043,
+    "pubkey": "<pubkey-A>",
+     // No "d" tag
+    "tags": [
+      ["p", "<pubkey-B>"]
+    ],
+    "content": "",
+    "created_at": 1702711000 // now
+    // ...other fields
+  }))>",
+  "created_at": 1702711000 // now
+  // ...other fields
+}
+```
+
+## Active Chats
+
+When receiving a chat request from user A, an user B can accept it or ignore it.
+The user accepts it by adding the sender's pubkey to its `kind:10043` "Active Chat" event's list of encrypted `p` tags.
+
+B's client should auto accept it if A is one of its follows or contact. Else
+the client should show A's `kind:0` metadata and link to its profile to help with B decision.
+
+When sending a chat request, the sender auto adds the receiver's pubkey to its own "Active Chat" event.
+
+The user should publish the event to all of its [NIP-65](65.md) `write` relays.
+
+```js
+{
+  "kind": 10043,
+  "pubkey": "<pubkey-B>"
+  "content": "<nip44Encrypt(JSON.stringify([
+    ["p", "<pubkey-A>"],
+    // other "p" tags
+  ]))>",
+  // ...other fields
+}
+```
+
+## Direct Message
+
+After sending a chat request and updating its own active chats, user A is able to send `kind:14` Shared Key DM events
+even though it doesn't know if B will ever fetch and read them.
+
+Both A and B use their [NIP-44](44.md) "Conversation Key" they have in common as a private key to sign a [NIP-59](59.md) `kind:1059` wrapper event
+(with `kind:13` seal). It wraps the encrypted DM event authored by the real user's pubkey.
+
+The "Conversation Key" is used to encrypt the inner events.
+
+There is no `p` tag on the wrapper event because the two participants will fetch messages by the pubkey derived from the "Conversation Key".
+This way no spam can be sent to any of the participants and the new messages download is finished faster.
+
+The correct current date is used on the wrapper event.
+
+The inner `kind:14` event MUST NOT include a `.sig` field to avoid it being published to relays.
+
+```js
+{
+  "kind": 1059, // gift wrap
+  "pubkey": "<conversation-key-AB-derived-pubkey>",
+  "tags": []
+  "content": "<nip44Encrypt(JSON.stringify({
+    "kind": 13, // seal
+    "pubkey" "<pubkey-A>",
+    "tags": [],
+    "content": "<nip44Encrypt(JSON.stringify({
+      "kind": 14, // DM
+      "pubkey" "<pubkey-A>",
+      "tags": [],
+      "content": "Hello, User B",
+      "created_at": 1702711000 // now
+      // ....other fields without .sig
+    }))>",
+    "created_at": 0
+    // ....other fields
+  }))>",
+  "created_at": 1702711000 // now
+  // ...other fields
+}
+```
+
+This event should be sent to atleast one of the receiver's [NIP-65](65.md) `read` relays and also to one or more of the sender's `read` relays.
+This way, an user will only have to fetch DMs from its own set of `read` relays.