Sync with upstream

17.md

@@ -133,7 +133,7 @@ When sending a message to anyone, clients must then connect to the relays in the
 
 This example sends the message `Hola, que tal?` from `nsec1w8udu59ydjvedgs3yv5qccshcj8k05fh3l60k9x57asjrqdpa00qkmr89m` to `nsec12ywtkplvyq5t6twdqwwygavp5lm4fhuang89c943nf2z92eez43szvn4dt`.
 
-The two final GiftWraps, one to the receiver and the other to the sender, are:
+The two final GiftWraps, one to the receiver and the other to the sender, respectively, are:
 
 ```json
 {

22.md

@@ -13,6 +13,9 @@ It uses `kind:1111` with plaintext `.content` (no HTML, Markdown, or other forma
 Comments MUST point to the root scope using uppercase tag names (e.g. `K`, `E`, `A` or `I`)
 and MUST point to the parent item with lowercase ones (e.g. `k`, `e`, `a` or `i`).
 
+Comments MUST point to the authors when one is available (i.e. tagging a nostr event). `P` for the root scope
+and `p` for the author of the parent item.
+
 ```jsonc
 {
   kind: 1111,
@@ -23,10 +26,16 @@ and MUST point to the parent item with lowercase ones (e.g. `k`, `e`, `a` or `i`
     // the root item kind
     ["K", "<root kind>"],
 
+    // pubkey of the author of the root scope event
+    ["P", "<root-pubkey>", "relay-url-hint"],
+
     // parent item: event addresses, event ids, or i-tags.
     ["<a, e, i>", "<address, id or i-value>", "<relay or web page hint>", "<parent event's pubkey, if an e tag>"],
     // parent item kind
-    ["k", "<parent comment kind>"]
+    ["k", "<parent comment kind>"],
+
+    // parent item pubkey
+    ["p", "<parent-pubkey>", "relay-url-hint"]
   ]
   // other fields
 }
@@ -46,11 +55,6 @@ Their uppercase versions use the same type of values but relate to the root item
 ```
 
 `p` tags SHOULD be used when mentioning pubkeys in the `.content` with [NIP-21](21.md).
-If the parent item is an event, a `p` tag set to the parent event's author SHOULD be added.
-
-```json
-["p", "<pubkey>", "<relay-url>"]
-```
 
 ## Examples
 
@@ -65,13 +69,17 @@ A comment on a blog post looks like this:
     ["A", "30023:3c9849383bdea883b0bd16fece1ed36d37e37cdde3ce43b17ea4e9192ec11289:f9347ca7", "wss://example.relay"],
     // the root kind
     ["K", "30023"],
+    // author of root event
+    ["P", "3c9849383bdea883b0bd16fece1ed36d37e37cdde3ce43b17ea4e9192ec11289", "wss://example.relay"]
 
     // the parent event address (same as root for top-level comments)
     ["a", "30023:3c9849383bdea883b0bd16fece1ed36d37e37cdde3ce43b17ea4e9192ec11289:f9347ca7", "wss://example.relay"],
     // when the parent event is replaceable or addressable, also include an `e` tag referencing its id
     ["e", "5b4fc7fed15672fefe65d2426f67197b71ccc82aa0cc8a9e94f683eb78e07651", "wss://example.relay"],
     // the parent event kind
-    ["k", "30023"]
+    ["k", "30023"],
+    // author of the parent event
+    ["p", "3c9849383bdea883b0bd16fece1ed36d37e37cdde3ce43b17ea4e9192ec11289", "wss://example.relay"]
   ]
   // other fields
 }
@@ -88,11 +96,14 @@ A comment on a [NIP-94](94.md) file looks like this:
     ["E", "768ac8720cdeb59227cf95e98b66560ef03d8bc9a90d721779e76e68fb42f5e6", "wss://example.relay", "3721e07b079525289877c366ccab47112bdff3d1b44758ca333feb2dbbbbe5bb"],
     // the root kind
     ["K", "1063"],
+    // author of the root event
+    ["P", "3721e07b079525289877c366ccab47112bdff3d1b44758ca333feb2dbbbbe5bb"],
 
     // the parent event id (same as root for top-level comments)
     ["e", "768ac8720cdeb59227cf95e98b66560ef03d8bc9a90d721779e76e68fb42f5e6", "wss://example.relay", "3721e07b079525289877c366ccab47112bdff3d1b44758ca333feb2dbbbbe5bb"],
     // the parent kind
-    ["k", "1063"]
+    ["k", "1063"],
+    ["p", "3721e07b079525289877c366ccab47112bdff3d1b44758ca333feb2dbbbbe5bb"]
   ]
   // other fields
 }
@@ -109,11 +120,13 @@ A reply to a comment looks like this:
     ["E", "768ac8720cdeb59227cf95e98b66560ef03d8bc9a90d721779e76e68fb42f5e6", "wss://example.relay", "fd913cd6fa9edb8405750cd02a8bbe16e158b8676c0e69fdc27436cc4a54cc9a"],
     // the root kind
     ["K", "1063"],
+    ["P", "fd913cd6fa9edb8405750cd02a8bbe16e158b8676c0e69fdc27436cc4a54cc9a"],
 
     // the parent event
     ["e", "5c83da77af1dec6d7289834998ad7aafbd9e2191396d75ec3cc27f5a77226f36", "wss://example.relay", "93ef2ebaaf9554661f33e79949007900bbc535d239a4c801c33a4d67d3e7f546"],
     // the parent kind
-    ["k", "1111"]
+    ["k", "1111"],
+    ["p", "93ef2ebaaf9554661f33e79949007900bbc535d239a4c801c33a4d67d3e7f546"]
   ]
   // other fields
 }
@@ -178,7 +191,9 @@ A reply to a podcast comment:
     ["e", "80c48d992a38f9c445b943a9c9f1010b396676013443765750431a9004bdac05", "wss://example.relay", "252f10c83610ebca1a059c0bae8255eba2f95be4d1d7bcfa89d7248a82d9f111"],
     // the parent comment kind
     ["k", "1111"]
+    ["p", "252f10c83610ebca1a059c0bae8255eba2f95be4d1d7bcfa89d7248a82d9f111"]
   ]
   // other fields
 }
 ```
+

29.md

@@ -30,8 +30,6 @@ When encountering just the `<host>` without the `'<group-id>`, clients MAY infer
 
 Events sent by users to groups (chat messages, text notes, moderation events etc) MUST have an `h` tag with the value set to the group _id_.
 
-`h` tags MAY include the group's name as the second argument. This allows `unmanaged` groups to be assigned human-readable names without relay support.
-
 ## Timeline references
 
 In order to not be used out of context, events sent to these groups may contain references to previous events seen from the same relay in the `previous` tag. The choice of which previous events to pick belongs to the clients. The references are to be made using the first 8 characters (4 bytes) of any event in the last 50 events seen by the user in the relay, excluding events by themselves. There can be any number of references (including zero), but it's recommended that clients include at least 3 and that relays enforce this.
@@ -72,7 +70,7 @@ These are events that can be sent by users to manage their situation in a group,
 
 - *join request* (`kind:9021`)
 
-Any user can send one of these events to the relay in order to be automatically or manually added to the group. If the group is `open` the relay will automatically issue a `kind:9000` in response adding this user. Otherwise group admins may choose to query for these requests and act upon them.
+Any user can send a kind `9021` event to the relay in order to request admission to the group. Relays MUST reject the request if the user has not been added to the group. The accompanying error message SHOULD explain whether the rejection is final, if the request is pending review, or if some other special handling is relevant (e.g. if payment is required). If a user is already a member, the event MUST be rejected with `duplicate: ` as the error message prefix.
 
 ```json
 {
@@ -242,3 +240,5 @@ A definition for `kind:10009` was included in [NIP-51](51.md) that allows client
 ### Using `unmanaged` relays
 
 To prevent event leakage, when using `unmanaged` relays, clients should include the [NIP-70](70.md) `-` tag, as just the `previous` tag won't be checked by other `unmanaged` relays.
+
+Groups MAY be named without relay support by adding a `name` to the corresponding tag in a user's `kind 10009` group list.

32.md

@@ -157,7 +157,7 @@ considered open for public use, and not proprietary. In other words, if there is
 namespace that fits your use case, use it even if it points to someone else's domain name.
 
 Vocabularies MAY choose to fully qualify all labels within a namespace (for example,
-`["l", "com.example.vocabulary:my-label"]`. This may be preferred when defining more
+`["l", "com.example.vocabulary:my-label"]`). This may be preferred when defining more
 formal vocabularies that should not be confused with another namespace when querying
 without an `L` tag. For these vocabularies, all labels SHOULD include the namespace
 (rather than mixing qualified and unqualified labels).
@@ -173,4 +173,4 @@ Appendix: Known Ontologies
 
 Below is a non-exhaustive list of ontologies currently in widespread use.
 
-- [social.ontolo.categories](https://ontolo.social/)
+- [social ontology categories](https://github.com/CLARIAH/awesome-humanities-ontologies)

37.md

@@ -0,0 +1,50 @@
+NIP-37
+======
+
+Draft Events 
+------------
+
+`draft` `optional`
+
+This NIP defines kind `31234` as a private wrap for drafts of any other event kind. 
+
+The draft event is JSON-stringified, [NIP44-encrypted](44.md) to the signer's public key and placed inside the `.content` of the event.
+
+An additional `k` tag identifies the kind of the draft event. 
+
+```js
+{
+  "kind": 31234,
+  "tags": [
+    ["d", "<identifier>"],
+    ["k", "<kind of the draft event>"],
+    ["e", "<anchor event event id>", "<relay-url>"],
+    ["a", "<anchor event address>", "<relay-url>"],
+  ],
+  "content": nip44Encrypt(JSON.stringify(draft_event)),
+  // other fields
+}
+```
+
+A blanked `.content` means this draft has been deleted by a client but relays still have the event. 
+
+Tags `e` and `a` identify one or more anchor events, such as parent events on replies.   
+
+## Relay List for Private Content
+
+Kind `10013` indicates the user's preferred relays to store private events like Drafts. The event MUST include a list of `relay` URLs in private tags. Private tags are JSON Stringified, NIP-44-encrypted to the signer's keys and placed inside the .content of the event.
+
+```js
+{
+  "kind": 10013,
+  "tags": [],
+  "content": nip44Encrypt(JSON.stringify([
+    ["relay", "wss://myrelay.mydomain.com"]
+  ]))
+  //...other fields
+}
+```
+
+Relays listed in this event SHOULD be authed and only allow downloads to events signed by the authed user.
+
+Clients SHOULD publish kind `10013` events to the author's [NIP-65](65.md) `write` relays. 

44.md

@@ -8,11 +8,11 @@ Encrypted Payloads (Versioned)
 
 The NIP introduces a new data format for keypair-based encryption. This NIP is versioned
 to allow multiple algorithm choices to exist simultaneously. This format may be used for
-many things, but MUST be used in the context of a signed event as described in NIP 01.
+many things, but MUST be used in the context of a signed event as described in NIP-01.
 
 *Note*: this format DOES NOT define any `kind`s related to a new direct messaging standard,
 only the encryption required to define one. It SHOULD NOT be used as a drop-in replacement
-for NIP 04 payloads.
+for NIP-04 payloads.
 
 ## Versions
 
@@ -41,7 +41,7 @@ On its own, messages sent using this scheme have a number of important shortcomi
 - No post-compromise security: when a key is compromised, it is possible to decrypt all future conversations
 - No post-quantum security: a powerful quantum computer would be able to decrypt the messages
 - IP address leak: user IP may be seen by relays and all intermediaries between user and relay
-- Date leak: `created_at` is public, since it is a part of NIP 01 event
+- Date leak: `created_at` is public, since it is a part of NIP-01 event
 - Limited message size leak: padding only partially obscures true message length
 - No attachments: they are not supported
 
@@ -63,7 +63,7 @@ NIP-44 version 2 has the following design characteristics:
 - SHA256 is used instead of SHA3 or BLAKE because it is already used in nostr. Also BLAKE's speed advantage
   is smaller in non-parallel environments.
 - A custom padding scheme is used instead of padmé because it provides better leakage reduction for small messages.
-- Base64 encoding is used instead of another compression algorithm because it is widely available, and is already used in nostr.
+- Base64 encoding is used instead of another encoding algorithm because it is widely available, and is already used in nostr.
 
 ### Encryption
 
@@ -86,7 +86,7 @@ NIP-44 version 2 has the following design characteristics:
    - Content must be encoded from UTF-8 into byte array
    - Validate plaintext length. Minimum is 1 byte, maximum is 65535 bytes
    - Padding format is: `[plaintext_length: u16][plaintext][zero_bytes]`
-   - Padding algorithm is related to powers-of-two, with min padded msg size of 32
+   - Padding algorithm is related to powers-of-two, with min padded msg size of 32 bytes
    - Plaintext length is encoded in big-endian as first 2 bytes of the padded blob
 5. Encrypt padded content
    - Use ChaCha20, with key and nonce from step 3
@@ -148,8 +148,8 @@ validation rules, refer to BIP-340.
   - `x[i:j]`, where `x` is a byte array and `i, j <= 0` returns a `(j - i)`-byte array with a copy of the
     `i`-th byte (inclusive) to the `j`-th byte (exclusive) of `x`.
 - Constants `c`:
-  - `min_plaintext_size` is 1. 1b msg is padded to 32b.
-  - `max_plaintext_size` is 65535 (64kb - 1). It is padded to 65536.
+  - `min_plaintext_size` is 1. 1 byte msg is padded to 32 bytes.
+  - `max_plaintext_size` is 65535 (64kB - 1). It is padded to 65536 bytes.
 - Functions
   - `base64_encode(string)` and `base64_decode(bytes)` are Base64 ([RFC 4648](https://datatracker.ietf.org/doc/html/rfc4648), with padding)
   - `concat` refers to byte array concatenation

46.md

@@ -72,12 +72,12 @@ nostrconnect://83f3b2ae6aa368e8275397b9c26cf550101d63ebaab900d19dd4a4429f5ad8f5?
 {
     "kind": 24133,
     "pubkey": <local_keypair_pubkey>,
-    "content": <nip04(<request>)>,
+    "content": <nip44(<request>)>,
     "tags": [["p", <remote-signer-pubkey>]],
 }
 ```
 
-The `content` field is a JSON-RPC-like message that is [NIP-04](04.md) encrypted and has the following structure:
+The `content` field is a JSON-RPC-like message that is [NIP-44](44.md) encrypted and has the following structure:
 
 ```jsonc
 {
@@ -109,7 +109,7 @@ Each of the following are methods that the _client_ sends to the _remote-signer_
 
 ### Requested permissions
 
-The `connect` method may be provided with `optional_requested_permissions` for user convenience. The permissions are a comma-separated list of `method[:params]`, i.e. `nip04_encrypt,sign_event:4` meaning permissions to call `nip04_encrypt` and to call `sign_event` with `kind:4`. Optional parameter for `sign_event` is the kind number, parameters for other methods are to be defined later. Same permission format may be used for `perms` field of `metadata` in `nostrconnect://` string.
+The `connect` method may be provided with `optional_requested_permissions` for user convenience. The permissions are a comma-separated list of `method[:params]`, i.e. `nip44_encrypt,sign_event:4` meaning permissions to call `nip44_encrypt` and to call `sign_event` with `kind:4`. Optional parameter for `sign_event` is the kind number, parameters for other methods are to be defined later. Same permission format may be used for `perms` field of `metadata` in `nostrconnect://` string.
 
 ## Response Events `kind:24133`
 
@@ -118,13 +118,13 @@ The `connect` method may be provided with `optional_requested_permissions` for u
     "id": <id>,
     "kind": 24133,
     "pubkey": <remote-signer-pubkey>,
-    "content": <nip04(<response>)>,
+    "content": <nip44(<response>)>,
     "tags": [["p", <client-pubkey>]],
     "created_at": <unix timestamp in seconds>
 }
 ```
 
-The `content` field is a JSON-RPC-like message that is [NIP-04](04.md) encrypted and has the following structure:
+The `content` field is a JSON-RPC-like message that is [NIP-44](44.md) encrypted and has the following structure:
 
 ```json
 {
@@ -150,7 +150,7 @@ The `content` field is a JSON-RPC-like message that is [NIP-04](04.md) encrypted
 {
     "kind": 24133,
     "pubkey": "eff37350d839ce3707332348af4549a96051bd695d3223af4aabce4993531d86",
-    "content": nip04({
+    "content": nip44({
         "id": <random_string>,
         "method": "sign_event",
         "params": [json_stringified(<{
@@ -170,7 +170,7 @@ The `content` field is a JSON-RPC-like message that is [NIP-04](04.md) encrypted
 {
     "kind": 24133,
     "pubkey": "fa984bd7dbb282f07e16e7ae87b26a2a7b9b90b7246a44771f0cf5ae58018f52",
-    "content": nip04({
+    "content": nip44({
         "id": <random_string>,
         "result": json_stringified(<signed-event>)
     }),
@@ -213,7 +213,7 @@ _remote-signer_ MAY publish it's metadata by using [NIP-05](05.md) and [NIP-89](
     },
     "nip46": {
         "relays": ["wss://relay1","wss://relay2"...],
-        "nostrconnect_url": "https://remote-signer-domain.com/<nostrconnect>"
+        "nostrconnect_url": "https://remote-signer-domain.example/<nostrconnect>"
     }
 }
 ```
@@ -224,4 +224,4 @@ The `<remote-signer-app-pubkey>` MAY be used to verify the domain from _remote-s
 
 _remote-signer_ MAY publish a NIP-89 `kind: 31990` event with `k` tag of `24133`, which MAY also include one or more `relay` tags and MAY include `nostrconnect_url` tag. The semantics of `relay` and `nostrconnect_url` tags are the same as in the section above.
 
-_client_ MAY improve UX by discovering _remote-signers_ using their `kind: 31990` events. _client_ MAY then pre-generate `nostrconnect://` strings for the _remote-signers_, and SHOULD in that case verify that `kind: 31990` event's author is mentioned in signer's `nostr.json?name=_` file as `<remote-signer-app-pubkey>`. 
+_client_ MAY improve UX by discovering _remote-signers_ using their `kind: 31990` events. _client_ MAY then pre-generate `nostrconnect://` strings for the _remote-signers_, and SHOULD in that case verify that `kind: 31990` event's author is mentioned in signer's `nostr.json?name=_` file as `<remote-signer-app-pubkey>`.

47.md

@@ -107,7 +107,7 @@ The content of notifications is encrypted with [NIP04](https://github.com/nostr-
 ## Nostr Wallet Connect URI
 **client** discovers **wallet service** by scanning a QR code, handling a deeplink or pasting in a URI.
 
-The **wallet service** generates this connection URI with protocol `nostr+walletconnect://` and base path it's hex-encoded `pubkey` with the following query string parameters:
+The **wallet service** generates this connection URI with protocol `nostr+walletconnect://` and base path its hex-encoded `pubkey` with the following query string parameters:
 
 - `relay` Required. URL of the relay where the **wallet service** is connected and will be listening for events. May be more than one.
 - `secret` Required. 32-byte randomly generated hex encoded string. The **client** MUST use this to sign events and encrypt payloads when communicating with the **wallet service**.
@@ -175,7 +175,7 @@ Request:
 Response:
 
 For every invoice in the request, a separate response event is sent. To differentiate between the responses, each
-response event contains a `d` tag with the id of the invoice it is responding to, if no id was given, then the
+response event contains a `d` tag with the id of the invoice it is responding to; if no id was given, then the
 payment hash of the invoice should be used.
 
 ```jsonc
@@ -247,7 +247,7 @@ Request:
 Response:
 
 For every keysend in the request, a separate response event is sent. To differentiate between the responses, each
-response event contains an `d` tag with the id of the keysend it is responding to, if no id was given, then the
+response event contains a `d` tag with the id of the keysend it is responding to; if no id was given, then the
 pubkey should be used.
 
 ```jsonc