64 files changed, 2722 insertions, 1121 deletions
diff --git a/01.md b/01.md
index f7f592c..eb9f60c 100644
--- a/01.md
+++ b/01.md
@@ -4,7 +4,7 @@ NIP-01
 Basic protocol flow description
 -------------------------------
-`draft` `mandatory`
+`draft` `mandatory` `relay`
 This NIP defines the basic protocol that should be implemented by everybody. New NIPs may add new optional (or mandatory) fields and messages and features to the structures and flows described here.
@@ -14,7 +14,7 @@ Each user has a keypair. Signatures, public key, and encodings are done accordin
 The only object type that exists is the `event`, which has the following format on the wire:
-```jsonc
+```yaml
 {
  "id": <32-bytes lowercase hex-encoded sha256 of the serialized event data>,
  "pubkey": <32-bytes lowercase hex-encoded public key of the event creator>,
@@ -85,7 +85,7 @@ As a convention, all single-letter (only english alphabet letters: a-z, A-Z) key
 ### Kinds
-Kinds specify how clients should interpret the meaning of each event and the other fields of each event (e.g. an `"r"` tag may have a meaning in an event of kind 1 and an entirely different meaning in an event of kind 10002). Each NIP may define the meaning of a set of kinds that weren't defined elsewhere. [NIP-10](10.md), for instance, especifies the `kind:1` text note for social media applications.  
+Kinds specify how clients should interpret the meaning of each event and the other fields of each event (e.g. an `"r"` tag may have a meaning in an event of kind 1 and an entirely different meaning in an event of kind 10002). Each NIP may define the meaning of a set of kinds that weren't defined elsewhere. [NIP-10](10.md), for instance, specifies the `kind:1` text note for social media applications.
 This NIP defines one basic kind:
@@ -120,7 +120,7 @@ Clients can send 3 types of messages, which must be JSON arrays, according to th
 `<filtersX>` is a JSON object that determines what events will be sent in that subscription, it can have the following attributes:
-```json
+```yaml
 {
  "ids": <a list of event ids>,
  "authors": <a list of lowercase pubkeys, the pubkey of an event must be one of these>,
@@ -144,7 +144,7 @@ All conditions of a filter that are specified must match for an event for it to
 A `REQ` message may contain multiple filters. In this case, events that match any of the filters are to be returned, i.e., multiple filters are to be interpreted as `||` conditions.
-The `limit` property of a filter is only valid for the initial query and MUST be ignored afterwards. When `limit: n` is present it is assumed that the events returned in the initial query will be the last `n` events ordered by the `created_at`. Newer events should appear first, and in the case of ties the event with the lowest id (first in lexical order) should be first. It is safe to return less events than `limit` specifies, but it is expected that relays do not return (much) more events than requested so clients don't get unnecessarily overwhelmed by data.
+The `limit` property of a filter is only valid for the initial query and MUST be ignored afterwards. When `limit: n` is present it is assumed that the events returned in the initial query will be the last `n` events ordered by the `created_at`. Newer events should appear first, and in the case of ties the event with the lowest id (first in lexical order) should be first. Relays SHOULD use the `limit` value to guide how many events are returned in the initial response. Returning fewer events is acceptable, but returning (much) more should be avoided to prevent overwhelming clients.
 ### From relay to client: sending events and notices
@@ -170,8 +170,9 @@ This NIP defines no rules for how `NOTICE` messages should be sent or treated.
  * `["OK", "b1a649ebe8...", false, "pow: difficulty 26 is less than 30"]`
  * `["OK", "b1a649ebe8...", false, "restricted: not allowed to write."]`
  * `["OK", "b1a649ebe8...", false, "error: could not connect to the database"]`
+  * `["OK", "b1a649ebe8...", false, "mute: no one was listening to your ephemeral event and it wasn't handled in any way, it was ignored"]`
 - `CLOSED` messages MUST be sent in response to a `REQ` when the relay refuses to fulfill it. It can also be sent when a relay decides to kill a subscription on its side before a client has disconnected or sent a `CLOSE`. This message uses the same pattern of `OK` messages with the machine-readable prefix and human-readable message. Some examples:
  * `["CLOSED", "sub1", "unsupported: filter contains unknown elements"]`
  * `["CLOSED", "sub1", "error: could not connect to the database"]`
  * `["CLOSED", "sub1", "error: shutting down idle subscription"]`
- The standardized machine-readable prefixes for `OK` and `CLOSED` are: `duplicate`, `pow`, `blocked`, `rate-limited`, `invalid`, `restricted`, and `error` for when none of that fits.
+- The standardized machine-readable prefixes for `OK` and `CLOSED` are: `duplicate`, `pow`, `blocked`, `rate-limited`, `invalid`, `restricted`, `mute` and `error` for when none of that fits.
diff --git a/03.md b/03.md
index 74e010c..3cd40a0 100644
--- a/03.md
+++ b/03.md
@@ -12,8 +12,8 @@ This NIP defines an event with `kind:1040` that can contain an [OpenTimestamps](
 {
  "kind": 1040
  "tags": [
-    ["e", <event-id>, <relay-url>],
+    ["e", <target-event-id>, <relay-url>],
-    ["alt", "opentimestamps attestation"]
+    ["k", "<target-event-kind>"]
  ],
  "content": <base64-encoded OTS file data>
 }
diff --git a/04.md b/04.md
index a561a2f..107d872 100644
--- a/04.md
+++ b/04.md
@@ -6,7 +6,7 @@ NIP-04
 Encrypted Direct Message
 ------------------------
-`final` `unrecommended` `optional`
+`final` `unrecommended` `optional` `relay`
 A special event with kind `4`, meaning "encrypted direct message". It is supposed to have the following attributes:
diff --git a/05.md b/05.md
index 7e823fb..57a3936 100644
--- a/05.md
+++ b/05.md
@@ -6,11 +6,11 @@ Mapping Nostr keys to DNS-based internet identifiers
 `final` `optional`
-On events of kind `0` (`user metadata`) one can specify the key `"nip05"` with an [internet identifier](https://datatracker.ietf.org/doc/html/rfc5322#section-3.4.1) (an email-like address) as the value. Although there is a link to a very liberal "internet identifier" specification above, NIP-05 assumes the `<local-part>` part will be restricted to the characters `a-z0-9-_.`, case-insensitive.
+On events of kind `0` (`user metadata`) one can specify the key `"nip05"` with an [internet identifier](https://datatracker.ietf.org/doc/html/rfc5322#section-3.4.1) (an email-like address) as the value. Although there is a link to a very liberal "internet identifier" specification above, the `<local-part>` part MUST only use characters `a-z0-9-_.`.
 Upon seeing that, the client splits the identifier into `<local-part>` and `<domain>` and use these values to make a GET request to `https://<domain>/.well-known/nostr.json?name=<local-part>`.
-The result should be a JSON document object with a key `"names"` that should then be a mapping of names to hex formatted public keys. If the public key for the given `<name>` matches the `pubkey` from the `user metadata` event, the client then concludes that the given pubkey can indeed be referenced by its identifier.
+The result should be a JSON document object with a key `"names"` that should then be a mapping of names to hex formatted public keys, in lowercase. If the public key for the given `<name>` matches the `pubkey` from the `user metadata` event, the client then concludes that the given pubkey can indeed be referenced by its identifier.
 ### Example
@@ -73,7 +73,7 @@ For example, if after finding that `bob@bob.com` has the public key `abc...def`,
 ### Public keys must be in hex format
-Keys must be returned in hex format. Keys in NIP-19 `npub` format are only meant to be used for display in client UIs, not in this NIP.
+Keys must be returned in hex format, in lowercase. Keys in NIP-19 `npub` format are only meant to be used for display in client UIs, not in this NIP.
 ### Showing just the domain as an identifier
diff --git a/09.md b/09.md
index 23ffeab..f061464 100644
--- a/09.md
+++ b/09.md
@@ -4,7 +4,7 @@ NIP-09
 Event Deletion Request
 ----------------------
-`draft` `optional`
+`draft` `optional` `relay`
 A special event with kind `5`, meaning "deletion request" is defined as having a list of one or more `e` or `a` tags, each referencing an event the author is requesting to be deleted. Deletion requests SHOULD include a `k` tag for the kind of each event being requested for deletion.
diff --git a/11.md b/11.md
index 8229bd4..d1acab7 100644
--- a/11.md
+++ b/11.md
@@ -4,9 +4,9 @@ NIP-11
 Relay Information Document
 --------------------------
-`draft` `optional`
+`draft` `optional` `relay`
-Relays may provide server metadata to clients to inform them of capabilities, administrative contacts, and various server attributes.  This is made available as a JSON document over HTTP, on the same URI as the relay's websocket.
+Relays may provide server metadata to clients to inform them of capabilities, administrative contacts, and various server attributes. This is made available as a JSON document over HTTP, on the same URI as the relay's websocket.
 When a relay receives an HTTP(s) request with an `Accept` header of `application/nostr+json` to a URI supporting WebSocket upgrades, they SHOULD return a document with the following structure.
@@ -17,14 +17,12 @@ When a relay receives an HTTP(s) request with an `Accept` header of `application
  "banner": <a link to an image (e.g. in .jpg, or .png format)>,
  "icon": <a link to an icon (e.g. in .jpg, or .png format>,
  "pubkey": <administrative contact pubkey>,
+  "self": <relay's own pubkey>,
  "contact": <administrative alternate contact>,
  "supported_nips": <a list of NIP numbers supported by the relay>,
  "software": <string identifying relay software URL>,
-  "version": <string version identifier>
+  "version": <string version identifier>,
-  "privacy_policy": <a link to a text file describing the relay's privacy policy>,
+  "terms_of_service": <a link to a text file describing the relay's term of service>
-  "terms_of_service": <a link to a text file describing the relay's term of service>,
 }
 ```
@@ -35,11 +33,11 @@ Field Descriptions
 ### Name
-A relay may select a `name` for use in client software.  This is a string, and SHOULD be less than 30 characters to avoid client truncation.
+A relay may select a `name` for use in client software. This is a string, and SHOULD be less than 30 characters to avoid client truncation.
 ### Description
-Detailed plain-text information about the relay may be contained in the `description` string.  It is recommended that this contain no markup, formatting or line breaks for word wrapping, and simply use double newline characters to separate paragraphs.  There are no limitations on length.
+Detailed plain-text information about the relay may be contained in the `description` string. It is recommended that this contain no markup, formatting or line breaks for word wrapping, and simply use double newline characters to separate paragraphs. There are no limitations on length.
 ### Banner
@@ -58,36 +56,34 @@ Icon is a compact visual representation of the relay for use in UI with limited
 ### Pubkey
-An administrative contact may be listed with a `pubkey`, in the same format as Nostr events (32-byte hex for a `secp256k1` public key).  If a contact is listed, this provides clients with a recommended address to send encrypted direct messages (See [NIP-17](17.md)) to a system administrator.  Expected uses of this address are to report abuse or illegal content, file bug reports, or request other technical assistance.
+An administrative contact may be listed with a `pubkey`, in the same format as Nostr events (32-byte hex for a `secp256k1` public key).  If a contact is listed, this provides clients with a recommended address to send encrypted direct messages (See [NIP-17](17.md)) to a system administrator. Expected uses of this address are to report abuse or illegal content, file bug reports, or request other technical assistance.
 Relay operators have no obligation to respond to direct messages.
+### Self
+A relay MAY maintain an identity independent from its administrator using the `self` field, which MUST be a 32-byte hex public key. This allows relays to respond to requests with events published either in advance or on demand by their own key.
 ### Contact
-An alternative contact may be listed under the `contact` field as well, with the same purpose as `pubkey`.  Use of a Nostr public key and direct message SHOULD be preferred over this.  Contents of this field SHOULD be a URI, using schemes such as `mailto` or `https` to provide users with a means of contact.
+An alternative contact may be listed under the `contact` field as well, with the same purpose as `pubkey`.  Use of a Nostr public key and direct message SHOULD be preferred over this. Contents of this field SHOULD be a URI, using schemes such as `mailto` or `https` to provide users with a means of contact.
 ### Supported NIPs
-As the Nostr protocol evolves, some functionality may only be available by relays that implement a specific `NIP`.  This field is an array of the integer identifiers of `NIP`s that are implemented in the relay.  Examples would include `1`, for `"NIP-01"` and `9`, for `"NIP-09"`.  Client-side `NIPs` SHOULD NOT be advertised, and can be ignored by clients.
+As the Nostr protocol evolves, some functionality may only be available by relays that implement a specific `NIP`.  This field is an array of the integer identifiers of `NIP`s that are implemented in the relay. Examples would include `1`, for `"NIP-01"` and `9`, for `"NIP-09"`.  Client-side `NIPs` SHOULD NOT be advertised, and can be ignored by clients.
 ### Software
-The relay server implementation MAY be provided in the `software` attribute.  If present, this MUST be a URL to the project's homepage.
+The relay server implementation MAY be provided in the `software` attribute. If present, this MUST be a URL to the project's homepage.
 ### Version
-The relay MAY choose to publish its software version as a string attribute.  The string format is defined by the relay implementation.  It is recommended this be a version number or commit identifier.
+The relay MAY choose to publish its software version as a string attribute. The string format is defined by the relay implementation. It is recommended this be a version number or commit identifier.
-### Privacy Policy
-The relay owner/admin MAY choose to link to a privacy policy document, which describes how the relay utilizes user data. Data collection, data usage, data retention, monetization of data, and third party data sharing SHOULD be included.
 ### Terms of Service
 The relay owner/admin MAY choose to link to a terms of service document.
 Extra Fields
 ------------
@@ -162,113 +158,7 @@ a specific niche kind or content. Normal anti-spam heuristics, for example, do n
 - `created_at_upper_limit`: 'created_at' upper limit
- `default_limit`: The maximum returned events if you send a filter with the limit set to 0.
+- `default_limit`: The maximum returned events if you send a filter without a `limit`.
-### Event Retention
-There may be a cost associated with storing data forever, so relays
-may wish to state retention times. The values stated here are defaults
-for unauthenticated users and visitors. Paid users would likely have
-other policies.
-Retention times are given in seconds, with `null` indicating infinity.
-If zero is provided, this means the event will not be stored at
-all, and preferably an error will be provided when those are received.
-```jsonc
-{
-  "retention": [
-    {"kinds": [0, 1, [5, 7], [40, 49]], "time": 3600},
-    {"kinds": [[40000, 49999]], "time": 100},
-    {"kinds": [[30000, 39999]], "count": 1000},
-    {"time": 3600, "count": 10000}
-  ],
-  // other fields...
-}
-```
-`retention` is a list of specifications: each will apply to either all kinds, or
-a subset of kinds. Ranges may be specified for the kind field as a tuple of inclusive
-start and end values. Events of indicated kind (or all) are then limited to a `count`
-and/or time period.
-It is possible to effectively blacklist Nostr-based protocols that rely on
-a specific `kind` number, by giving a retention time of zero for those `kind` values.
-While that is unfortunate, it does allow clients to discover servers that will
-support their protocol quickly via a single HTTP fetch.
-There is no need to specify retention times for _ephemeral events_ since they are not retained.
-### Content Limitations
-Some relays may be governed by the arbitrary laws of a nation state. This
-may limit what content can be stored in clear-text on those relays. All
-clients are encouraged to use encryption to work around this limitation.
-It is not possible to describe the limitations of each country's laws
-and policies which themselves are typically vague and constantly shifting.
-Therefore, this field allows the relay operator to indicate which
-countries' laws might end up being enforced on them, and then
-indirectly on their users' content.
-Users should be able to avoid relays in countries they don't like,
-and/or select relays in more favorable zones. Exposing this
-flexibility is up to the client software.
-```jsonc
-{
-  "relay_countries": [ "CA", "US" ],
-  // other fields...
-}
-```
- `relay_countries`: a list of two-level ISO country codes (ISO 3166-1 alpha-2)  whose
-  laws and policies may affect this relay. `EU` may be used for European Union countries. A `*` can be used for global relays.
-Remember that a relay may be hosted in a country which is not the
-country of the legal entities who own the relay, so it's very
-likely a number of countries are involved.
-### Community Preferences
-For public text notes at least, a relay may try to foster a
-local community. This would encourage users to follow the global
-feed on that relay, in addition to their usual individual follows.
-To support this goal, relays MAY specify some of the following values.
-```jsonc
-{
-  "language_tags": ["en", "en-419"],
-  "tags": ["sfw-only", "bitcoin-only", "anime"],
-  "posting_policy": "https://example.com/posting-policy.html",
-  // other fields...
-}
-```
- `language_tags` is an ordered list
-  of [IETF language tags](https://en.wikipedia.org/wiki/IETF_language_tag) indicating
-  the major languages spoken on the relay. A `*` can be used for global relays.
- `tags` is a list of limitations on the topics to be discussed.
-  For example `sfw-only` indicates that only "Safe For Work" content
-  is encouraged on this relay. This relies on assumptions of what the
-  "work" "community" feels "safe" talking about. In time, a common
-  set of tags may emerge that allow users to find relays that suit
-  their needs, and client software will be able to parse these tags easily.
-  The `bitcoin-only` tag indicates that any *altcoin*, *"crypto"* or *blockchain*
-  comments will be ridiculed without mercy.
- `posting_policy` is a link to a human-readable page which specifies the
-  community policies for the relay. In cases where `sfw-only` is True, it's
-  important to link to a page which gets into the specifics of your posting policy.
-The `description` field should be used to describe your community
-goals and values, in brief. The `posting_policy` is for additional
-detail and legal terms. Use the `tags` field to signify limitations
-on content, or topics to be discussed, which could be machine
-processed by appropriate client software.
 ### Pay-to-Relay
@@ -288,82 +178,68 @@ Relays that require payments may want to expose their fee schedules.
 ### Examples
-As of 25 March 2025 the following command provided these results:
+```yaml
+~> curl -H "Accept: application/nostr+json" https://nostr.wine | jq
-```bash
-curl -H "Accept: application/nostr+json" https://jellyfish.land | jq
-```
-```json
 {
-  "name": "JellyFish",
+  "contact": "wino@nostr.wine",
-  "description": "Stay Immortal!",
+  "description": "A paid nostr relay for wine enthusiasts and everyone else.",
-  "banner": "https://image.nostr.build/7fdefea2dec1f1ec25b8ce69362566c13b2b7f13f1726c2e4584f05f64f62496.jpg",
-  "pubkey": "bf2bee5281149c7c350f5d12ae32f514c7864ff10805182f4178538c2c421007",
-  "contact": "hi@dezh.tech",
-  "software": "https://github.com/dezh-tech/immortal",
-  "supported_nips": [
-    1,
-    9,
-    11,
-    13,
-    17,
-    40,
-    42,
-    59,
-    62,
-    70
-  ],
-  "version": "immortal - 0.0.9",
-  "relay_countries": [
-    "*"
-  ],
-  "language_tags": [
-    "*"
-  ],
-  "tags": [],
-  "posting_policy": "https://jellyfish.land/tos.txt",
-  "payments_url": "https://jellyfish.land/relay",
-  "icon": "https://image.nostr.build/2547e9ec4b23589e09bc7071e0806c3d4293f76284c58ff331a64bce978aaee8.jpg",
-  "retention": [],
  "fees": {
-    "subscription": [
+    "admission": [
-      {
-        "amount": 3000,
-        "period": 2628003,
-        "unit": "sats"
-      },
      {
-        "amount": 8000,
+        "amount": 18888000,
-        "period": 7884009,
+        "unit": "msats"
-        "unit": "sats"
-      },
-      {
-        "amount": 15000,
-        "period": 15768018,
-        "unit": "sats"
-      },
-      {
-        "amount": 28000,
-        "period": 31536036,
-        "unit": "sats"
      }
    ]
  },
+  "icon": "https://image.nostr.build/30acdce4a81926f386622a07343228ae99fa68d012d54c538c0b2129dffe400c.png",
  "limitation": {
    "auth_required": false,
-    "max_message_length": 70000,
+    "created_at_lower_limit": 94608000,
-    "max_subid_length": 256,
+    "created_at_upper_limit": 300,
-    "max_subscriptions": 350,
+    "max_event_tags": 4000,
+    "max_limit": 1000,
+    "max_message_length": 524288,
+    "max_subid_length": 71,
+    "max_subscriptions": 50,
    "min_pow_difficulty": 0,
    "payment_required": true,
-    "restricted_writes": true,
+    "restricted_writes": true
+  },
+  "name": "nostr.wine",
+  "payments_url": "https://nostr.wine/invoices",
+  "pubkey": "4918eb332a41b71ba9a74b1dc64276cfff592e55107b93baae38af3520e55975",
+  "software": "https://nostr.wine",
+  "supported_nips": [ 1, 2, 4, 9, 11, 40, 42, 50, 70, 77 ],
+  "terms_of_service": "https://nostr.wine/terms",
+  "version": "0.3.3"
+}
+~> curl -H "Accept: application/nostr+json" https://nostr.land | jq
+{
+  "description": "[✨ NFDB] nostr.land family of relays (fi-01 [tiger])",
+  "name": "[✨ NFDB] nostr.land",
+  "pubkey": "52b4a076bcbbbdc3a1aefa3735816cf74993b1b8db202b01c883c58be7fad8bd",
+  "software": "NFDB",
+  "icon": "https://i.nostr.build/b3thno790aodH8lE.jpg",
+  "supported_nips": [ 1, 2, 4, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 27, 28, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 42, 44, 46, 47, 48, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 65, 68, 69, 71, 72, 73, 75, 78, 84, 88, 89, 90, 92, 99 ],
+  "version": "1.0.0",
+  "limitation": {
+    "payment_required": true,
+    "max_message_length": 65535,
    "max_event_tags": 2000,
-    "max_content_length": 70000,
+    "max_subscriptions": 200,
-    "created_at_lower_limit": 0,
+    "auth_required": false
-    "created_at_upper_limit": 2147483647,
+  },
-    "default_limit": 500,
+  "payments_url": "https://nostr.land",
-    "max_limit": 5000
+  "fees": {
-  }
+    "subscription": [
+      {
+        "amount": 4000000,
+        "unit": "msats",
+        "period": 2592000
+      }
+    ]
+  },
+  "terms_of_service": "https://nostr.land/terms"
 }
 ```
diff --git a/13.md b/13.md
index cf5b1ac..d7e7725 100644
--- a/13.md
+++ b/13.md
@@ -4,7 +4,7 @@ NIP-13
 Proof of Work
 -------------
-`draft` `optional`
+`draft` `optional` `relay`
 This NIP defines a way to generate and interpret Proof of Work for nostr notes. Proof of Work (PoW) is a way to add a proof of computational work to a note. This is a bearer proof that all relays and clients can universally validate with a small amount of code. This proof can be used as a means of spam deterrence.
diff --git a/17.md b/17.md
index 4383308..3ccdc77 100644
--- a/17.md
+++ b/17.md
@@ -4,34 +4,40 @@ NIP-17
 Private Direct Messages
 -----------------------
-`draft` `optional`
+`draft` `optional` `relay`
-This NIP defines an encrypted direct messaging scheme using [NIP-44](44.md) encryption and [NIP-59](59.md) seals and gift wraps.
+This NIP defines an encrypted chat scheme which uses [NIP-44](44.md) encryption and [NIP-59](59.md) seals and gift wraps.
-## Direct Message Kind
+Any event sent to an encrypted chat MUST NOT be signed, and MUST be encrypted as described in [NIP-59](./59.md) and illustrated below. Omitting signatures makes messages deniable in case they are accidentally or maliciously leaked, while still allowing the recipient to authenticate them.
+By convention, `kind 14` direct messages, `kind 15` file messages, and [`kind 7` reactions](./25.md) may be sent to an encrypted chat.
+## Kind Definitions
+### Chat Message
 Kind `14` is a chat message. `p` tags identify one or more receivers of the message.
 ```jsonc
 {
  "id": "<usual hash>",
-  "pubkey": "<sender-pubkey>",
+  "pubkey": "<sender-pubkey>",
  "created_at": "<current-time>",
-  "kind": 14,
+  "kind": 14,
-  "tags": [
+  "tags": [
-    ["p", "<receiver-1-pubkey>", "<relay-url>"],
+    ["p", "<receiver-1-pubkey>", "<relay-url>"],
-    ["p", "<receiver-2-pubkey>", "<relay-url>"],
+    ["p", "<receiver-2-pubkey>", "<relay-url>"],
-    ["e", "<kind-14-id>", "<relay-url>"] // if this is a reply
+    ["e", "<kind-14-id>", "<relay-url>"] // if this is a reply
    ["subject", "<conversation-title>"],
-    // rest of tags...
+    // rest of tags...
-  ],
+  ],
-  "content": "<message-in-plain-text>",
+  "content": "<message-in-plain-text>",
 }
 ```
 `.content` MUST be plain text. Fields `id` and `created_at` are required.
-An `e` tag denotes the direct parent message this post is replying to. 
+An `e` tag denotes the direct parent message this post is replying to.
 `q` tags MAY be used when citing events in the `.content` with [NIP-21](21.md).
@@ -39,9 +45,7 @@ An `e` tag denotes the direct parent message this post is replying to.
 ["q", "<event-id> or <event-address>", "<relay-url>", "<pubkey-if-a-regular-event>"]
 ```
-Kind `14`s MUST never be signed. If it is signed, the message might leak to relays and become **fully public**.
+## File Message
-## File Message Kind
 ```jsonc
 {
@@ -65,21 +69,20 @@ Kind `14`s MUST never be signed. If it is signed, the message might leak to rela
 }
 ```
-Kind 15 is used for sending encrypted file event messages:
+Kind `15` is used for sending encrypted file event messages:
- `file-type`: Specifies the MIME type of the attached file (e.g., `image/jpeg`, `audio/mpeg`, etc.).
+- `file-type`: Specifies the MIME type of the attached file (e.g., `image/jpeg`, `audio/mpeg`, etc.) before encryption.
- `encryption-algorithm`: Indicates the encryption algorithm used for encrypting the file. Supported algorithms may include `aes-gcm`, `chacha20-poly1305`,`aes-cbc` etc.
+- `encryption-algorithm`: Indicates the encryption algorithm used for encrypting the file. Supported algorithms: `aes-gcm`.
 - `decryption-key`: The decryption key that will be used by the recipient to decrypt the file.
 - `decryption-nonce`: The decryption nonce that will be used by the recipient to decrypt the file.
 - `content`: The URL of the file (`<file-url>`).
- `x` containing the SHA-256 hexencoded string of the file.
+- `x` containing the SHA-256 hexencoded string of the encrypted file.
- `size` (optional) size of file in bytes
+- `ox` containing the SHA-256 hexencoded string of the file before encryption.
- `dim` (optional) size of the file in pixels in the form `<width>x<height>`
+- `size` (optional) size of the encrypted file in bytes
+- `dim` (optional) size in pixels in the form `<width>x<height>`
 - `blurhash`(optional) the [blurhash](https://github.com/woltapp/blurhash) to show while the client is loading the file
 - `thumb` (optional) URL of thumbnail with same aspect ratio (encrypted with the same key, nonce)
- `fallback` (optional) zero or more fallback file sources in case `url` fails
+- `fallback` (optional) zero or more fallback file sources in case `url` fails (encrypted with the same key, nonce)
-Just like kind 14, kind `15`s MUST never be signed.
 ## Chat Rooms
@@ -87,34 +90,34 @@ The set of `pubkey` + `p` tags defines a chat room. If a new `p` tag is added or
 Clients SHOULD render messages of the same room in a continuous thread.
-An optional `subject` tag defines the current name/topic of the conversation. Any member can change the topic by simply submitting a new `subject` to an existing `pubkey` + `p`-tags room. There is no need to send `subject` in every message. The newest `subject` in the thread is the subject of the conversation.
+An optional `subject` tag defines the current name/topic of the conversation. Any member can change the topic by simply submitting a new `subject` to an existing `pubkey` + `p` tags room. There is no need to send `subject` in every message. The newest `subject` in the chat room is the subject of the conversation.
 ## Encrypting
-Following [NIP-59](59.md), the **unsigned** `kind:14` & `kind:15` chat messages must be sealed (`kind:13`) and then gift-wrapped (`kind:1059`) to each receiver and the sender individually.
+Following [NIP-59](59.md), the **unsigned** chat messages must be sealed (`kind:13`) and then gift-wrapped (`kind:1059`) to each receiver and the sender individually.
-```jsonc
+```js
 {
  "id": "<usual hash>",
-  "pubkey": randomPublicKey,
+  "pubkey": randomPublicKey,
-  "created_at": randomTimeUpTo2DaysInThePast(),
+  "created_at": randomTimeUpTo2DaysInThePast(),
  "kind": 1059, // gift wrap
-  "tags": [
+  "tags": [
-    ["p", receiverPublicKey, "<relay-url>"] // receiver
+    ["p", receiverPublicKey, "<relay-url>"] // receiver
-  ],
+  ],
-  "content": nip44Encrypt(
+  "content": nip44Encrypt(
-    {
+    {
      "id": "<usual hash>",
-      "pubkey": senderPublicKey,
+      "pubkey": senderPublicKey,
-      "created_at": randomTimeUpTo2DaysInThePast(),
+      "created_at": randomTimeUpTo2DaysInThePast(),
-      "kind": 13, // seal
+      "kind": 13, // seal
-      "tags": [], // no tags
+      "tags": [], // no tags
-      "content": nip44Encrypt(unsignedKind14, senderPrivateKey, receiverPublicKey),
+      "content": nip44Encrypt(unsignedKind14, senderPrivateKey, receiverPublicKey),
-      "sig": "<signed by senderPrivateKey>"
+      "sig": "<signed by senderPrivateKey>"
-    },
+    },
-    randomPrivateKey, receiverPublicKey
+    randomPrivateKey, receiverPublicKey
-  ),
+  ),
-  "sig": "<signed by randomPrivateKey>"
+  "sig": "<signed by randomPrivateKey>"
 }
 ```
@@ -124,9 +127,9 @@ Clients MUST verify if pubkey of the `kind:13` is the same pubkey on the `kind:1
 Clients SHOULD randomize `created_at` in up to two days in the past in both the seal and the gift wrap to make sure grouping by `created_at` doesn't reveal any metadata.
-The gift wrap's `p`-tag can be the receiver's main pubkey or an alias key created to receive DMs without exposing the receiver's identity.
+The gift wrap's `p` tag can be the receiver's main pubkey or an alias key created to receive DMs without exposing the receiver's identity.
-Clients CAN offer disappearing messages by setting an `expiration` tag in the gift wrap of each receiver or by not generating a gift wrap to the sender's public key
+Clients MAY offer disappearing messages by setting an `expiration` tag in the gift wrap of each receiver or by not generating a gift wrap to the sender's public key. This tag SHOULD be included on the `kind 13` seal as well, in case it leaks.
 ## Publishing
@@ -144,15 +147,13 @@ Kind `10050` indicates the user's preferred relays to receive DMs. The event MUS
 }
 ```
-Clients SHOULD publish kind `14` events to the `10050`-listed relays. If that is not found that indicates the user is not ready to receive messages under this NIP and clients shouldn't try.
+Clients SHOULD publish the gift-wrapped `kind 1059` events that contain the sealed rumors to the relays listed in the recipient’s kind 10050 event. If that is not found that indicates the user is not ready to receive messages under this NIP and clients shouldn't try.
 ## Relays
-It's advisable that relays do not serve `kind:1059` to clients other than the ones tagged in them.
+Relays MAY protect message metadata by only serving `kind:1059` events to users p-tagged on the event (enforced using [NIP 42 AUTH](./42.md)).
-It's advisable that users choose relays that conform to these practices.
+Clients SHOULD guide users to keep `kind:10050` lists small (1-3 relays) and SHOULD spread them to as many relays as viable.
-Clients SHOULD guide users to keep `kind:10050` lists small (1-3 relays) and SHOULD spread it to as many relays as viable.
 ## Benefits & Limitations
@@ -169,12 +170,6 @@ This NIP offers the following privacy and security features:
 The main limitation of this approach is having to send a separate encrypted event to each receiver. Group chats with more than 100 participants should find a more suitable messaging scheme.
-## Implementation
-Clients implementing this NIP should by default only connect to the set of relays found in their `kind:10050` list. From that they should be able to load all messages both sent and received as well as get new live updates, making it for a very simple and lightweight implementation that should be fast.
-When sending a message to anyone, clients must then connect to the relays in the receiver's `kind:10050` and send the events there but can disconnect right after unless more messages are expected to be sent (e.g. the chat tab is still selected). Clients should also send a copy of their outgoing messages to their own `kind:10050` relay set.
 ## Examples
 This example sends the message `Hola, que tal?` from `nsec1w8udu59ydjvedgs3yv5qccshcj8k05fh3l60k9x57asjrqdpa00qkmr89m` to `nsec12ywtkplvyq5t6twdqwwygavp5lm4fhuang89c943nf2z92eez43szvn4dt`.
@@ -188,7 +183,7 @@ The two final GiftWraps, one to the receiver and the other to the sender, respec
   "created_at":1703128320,
   "kind":1059,
   "tags":[
-      [ "p", "918e2da906df4ccd12c8ac672d8335add131a4cf9d27ce42b3bb3625755f0788"]
+      ["p", "918e2da906df4ccd12c8ac672d8335add131a4cf9d27ce42b3bb3625755f0788"]
   ],
   "content":"AsqzdlMsG304G8h08bE67dhAR1gFTzTckUUyuvndZ8LrGCvwI4pgC3d6hyAK0Wo9gtkLqSr2rT2RyHlE5wRqbCOlQ8WvJEKwqwIJwT5PO3l2RxvGCHDbd1b1o40ZgIVwwLCfOWJ86I5upXe8K5AgpxYTOM1BD+SbgI5jOMA8tgpRoitJedVSvBZsmwAxXM7o7sbOON4MXHzOqOZpALpS2zgBDXSAaYAsTdEM4qqFeik+zTk3+L6NYuftGidqVluicwSGS2viYWr5OiJ1zrj1ERhYSGLpQnPKrqDaDi7R1KrHGFGyLgkJveY/45y0rv9aVIw9IWF11u53cf2CP7akACel2WvZdl1htEwFu/v9cFXD06fNVZjfx3OssKM/uHPE9XvZttQboAvP5UoK6lv9o3d+0GM4/3zP+yO3C0NExz1ZgFmbGFz703YJzM+zpKCOXaZyzPjADXp8qBBeVc5lmJqiCL4solZpxA1865yPigPAZcc9acSUlg23J1dptFK4n3Tl5HfSHP+oZ/QS/SHWbVFCtq7ZMQSRxLgEitfglTNz9P1CnpMwmW/Y4Gm5zdkv0JrdUVrn2UO9ARdHlPsW5ARgDmzaxnJypkfoHXNfxGGXWRk0sKLbz/ipnaQP/eFJv/ibNuSfqL6E4BnN/tHJSHYEaTQ/PdrA2i9laG3vJti3kAl5Ih87ct0w/tzYfp4SRPhEF1zzue9G/16eJEMzwmhQ5Ec7jJVcVGa4RltqnuF8unUu3iSRTQ+/MNNUkK6Mk+YuaJJs6Fjw6tRHuWi57SdKKv7GGkr0zlBUU2Dyo1MwpAqzsCcCTeQSv+8qt4wLf4uhU9Br7F/L0ZY9bFgh6iLDCdB+4iABXyZwT7Ufn762195hrSHcU4Okt0Zns9EeiBOFxnmpXEslYkYBpXw70GmymQfJlFOfoEp93QKCMS2DAEVeI51dJV1e+6t3pCSsQN69Vg6jUCsm1TMxSs2VX4BRbq562+VffchvW2BB4gMjsvHVUSRl8i5/ZSDlfzSPXcSGALLHBRzy+gn0oXXJ/447VHYZJDL3Ig8+QW5oFMgnWYhuwI5QSLEyflUrfSz+Pdwn/5eyjybXKJftePBD9Q+8NQ8zulU5sqvsMeIx/bBUx0fmOXsS3vjqCXW5IjkmSUV7q54GewZqTQBlcx+90xh/LSUxXex7UwZwRnifvyCbZ+zwNTHNb12chYeNjMV7kAIr3cGQv8vlOMM8ajyaZ5KVy7HpSXQjz4PGT2/nXbL5jKt8Lx0erGXsSsazkdoYDG3U",
   "sig":"a3c6ce632b145c0869423c1afaff4a6d764a9b64dedaf15f170b944ead67227518a72e455567ca1c2a0d187832cecbde7ed478395ec4c95dd3e71749ed66c480"
@@ -202,7 +197,7 @@ The two final GiftWraps, one to the receiver and the other to the sender, respec
   "created_at":1702711587,
   "kind":1059,
   "tags":[
-      [ "p", "44900586091b284416a0c001f677f9c49f7639a55c3f1e2ec130a8e1a7998e1b"]
+      ["p", "44900586091b284416a0c001f677f9c49f7639a55c3f1e2ec130a8e1a7998e1b"]
   ],
   "content":"AsTClTzr0gzXXji7uye5UB6LYrx3HDjWGdkNaBS6BAX9CpHa+Vvtt5oI2xJrmWLen+Fo2NBOFazvl285Gb3HSM82gVycrzx1HUAaQDUG6HI7XBEGqBhQMUNwNMiN2dnilBMFC3Yc8ehCJT/gkbiNKOpwd2rFibMFRMDKai2mq2lBtPJF18oszKOjA+XlOJV8JRbmcAanTbEK5nA/GnG3eGUiUzhiYBoHomj3vztYYxc0QYHOx0WxiHY8dsC6jPsXC7f6k4P+Hv5ZiyTfzvjkSJOckel1lZuE5SfeZ0nduqTlxREGeBJ8amOykgEIKdH2VZBZB+qtOMc7ez9dz4wffGwBDA7912NFS2dPBr6txHNxBUkDZKFbuD5wijvonZDvfWq43tZspO4NutSokZB99uEiRH8NAUdGTiNb25m9JcDhVfdmABqTg5fIwwTwlem5aXIy8b66lmqqz2LBzJtnJDu36bDwkILph3kmvaKPD8qJXmPQ4yGpxIbYSTCohgt2/I0TKJNmqNvSN+IVoUuC7ZOfUV9lOV8Ri0AMfSr2YsdZ9ofV5o82ClZWlWiSWZwy6ypa7CuT1PEGHzywB4CZ5ucpO60Z7hnBQxHLiAQIO/QhiBp1rmrdQZFN6PUEjFDloykoeHe345Yqy9Ke95HIKUCS9yJurD+nZjjgOxZjoFCsB1hQAwINTIS3FbYOibZnQwv8PXvcSOqVZxC9U0+WuagK7IwxzhGZY3vLRrX01oujiRrevB4xbW7Oxi/Agp7CQGlJXCgmRE8Rhm+Vj2s+wc/4VLNZRHDcwtfejogjrjdi8p6nfUyqoQRRPARzRGUnnCbh+LqhigT6gQf3sVilnydMRScEc0/YYNLWnaw9nbyBa7wFBAiGbJwO40k39wj+xT6HTSbSUgFZzopxroO3f/o4+ubx2+IL3fkev22mEN38+dFmYF3zE+hpE7jVxrJpC3EP9PLoFgFPKCuctMnjXmeHoiGs756N5r1Mm1ffZu4H19MSuALJlxQR7VXE/LzxRXDuaB2u9days/6muP6gbGX1ASxbJd/ou8+viHmSC/ioHzNjItVCPaJjDyc6bv+gs1NPCt0qZ69G+JmgHW/PsMMeL4n5bh74g0fJSHqiI9ewEmOG/8bedSREv2XXtKV39STxPweceIOh0k23s3N6+wvuSUAJE7u1LkDo14cobtZ/MCw/QhimYPd1u5HnEJvRhPxz0nVPz0QqL/YQeOkAYk7uzgeb2yPzJ6DBtnTnGDkglekhVzQBFRJdk740LEj6swkJ",
   "sig":"c94e74533b482aa8eeeb54ae72a5303e0b21f62909ca43c8ef06b0357412d6f8a92f96e1a205102753777fd25321a58fba3fb384eee114bd53ce6c06a1c22bab"
diff --git a/18.md b/18.md
index 5d55f84..3b94df8 100644
--- a/18.md
+++ b/18.md
@@ -21,18 +21,12 @@ reposted.
 ## Quote Reposts
-Quote reposts are `kind 1` events with an embedded `q` tag of the note being
+Mentions to [NIP-21](21.md) entities like `nevent`, `note` and `naddr` on any
-quote reposted. The `q` tag ensures quote reposts are not pulled and included
+event must be converted into `q` tags. The `q` tag ensures quote reposts are
-as replies in threads. It also allows you to easily pull and count all of the
+not pulled and included as replies in threads. It also allows you to easily
-quotes for a post.
+pull and count all of the quotes for a post. The syntax follows
-`q` tags should follow the same conventions as NIP 10 `e` tags, with the exception
+`["q", "<event-id> or <event-address>", "<relay-url>", "<pubkey-if-a-regular-event>"]`
-of the `mark` argument.
-`["q", <event-id>, <relay-url>, <pubkey>]`
-Quote reposts MUST include the [NIP-21](21.md) `nevent`, `note`, or `naddr` of the
-event in the content.
 ## Generic Reposts
@@ -40,6 +34,12 @@ Since `kind 6` reposts are reserved for `kind 1` contents, we use `kind 16`
 as a "generic repost", that can include any kind of event inside other than
 `kind 1`.
-`kind 16` reposts SHOULD contain a `k` tag with the stringified kind number
+`kind 16` reposts SHOULD contain a `"k"` tag with the stringified kind number
 of the reposted event as its value.
+When reposting a replaceable event, the repost SHOULD include an `"a"` tag with
+the event coordinate (`kind:pubkey:d-tag`) of the reposted event.
+If the `"a"` tag is not present, it indicates that a specific version of a replaceable
+event is being reposted, in which case the `content` field must contain the full
+JSON string of the reposted event.
diff --git a/19.md b/19.md
index 3ea8e11..eb350a5 100644
--- a/19.md
+++ b/19.md
@@ -34,7 +34,7 @@ These are the possible bech32 prefixes with `TLV`:
  - `nprofile`: a nostr profile
  - `nevent`: a nostr event
-  - `naddr`: a nostr _replaceable event_ coordinate
+  - `naddr`: a nostr _addressable event_ coordinate
  - `nrelay`: a nostr relay (deprecated)
 These possible standardized `TLV` types are indicated here:
@@ -67,3 +67,4 @@ These possible standardized `TLV` types are indicated here:
 - `npub` keys MUST NOT be used in NIP-01 events or in NIP-05 JSON responses, only the hex format is supported there.
 - When decoding a bech32-formatted string, TLVs that are not recognized or supported should be ignored, rather than causing an error.
+- Bech32-formatted strings SHOULD be limited in size to 5000 characters.
diff --git a/21.md b/21.md
index 988485d..800e490 100644
--- a/21.md
+++ b/21.md
@@ -12,9 +12,27 @@ The scheme is `nostr:`.
 The identifiers that come after are expected to be the same as those defined in [NIP-19](19.md) (except `nsec`).
-## Examples
+#### Examples
 - `nostr:npub1sn0wdenkukak0d9dfczzeacvhkrgz92ak56egt7vdgzn8pv2wfqqhrjdv9`
 - `nostr:nprofile1qqsrhuxx8l9ex335q7he0f09aej04zpazpl0ne2cgukyawd24mayt8gpp4mhxue69uhhytnc9e3k7mgpz4mhxue69uhkg6nzv9ejuumpv34kytnrdaksjlyr9p`
 - `nostr:note1fntxtkcy9pjwucqwa9mddn7v03wwwsu9j330jj350nvhpky2tuaspk6nqc`
 - `nostr:nevent1qqstna2yrezu5wghjvswqqculvvwxsrcvu7uc0f78gan4xqhvz49d9spr3mhxue69uhkummnw3ez6un9d3shjtn4de6x2argwghx6egpr4mhxue69uhkummnw3ez6ur4vgh8wetvd3hhyer9wghxuet5nxnepm`
+### Linking HTML pages to Nostr entities
+`<link>` tags with `rel="alternate"` can be used to associate webpages to Nostr events, in cases where the same content is served via the two mediums (for example, a web server that exposes Markdown articles both as HTML pages and as `kind:30023` events served under itself as a relay or through some other relay). For example:
+```
+<head>
+  <link rel="alternate" href="nostr:naddr1qqyrzwrxvc6ngvfkqyghwumn8ghj7enfv96x5ctx9e3k7mgzyqalp33lewf5vdq847t6te0wvnags0gs0mu72kz8938tn24wlfze6qcyqqq823cph95ag" />
+</head>
+```
+Likewise, `<link>` tags with `rel="me"` or `rel="author"` can be used to assign authorship of webpages to Nostr profiles. For example:
+```
+<head>
+  <link rel="me" href="nostr:nprofile1qyxhwumn8ghj7mn0wvhxcmmvqyd8wumn8ghj7un9d3shjtnhv4ehgetjde38gcewvdhk6qpq80cvv07tjdrrgpa0j7j7tmnyl2yr6yr7l8j4s3evf6u64th6gkwswpnfsn" />
+</head>
+```
diff --git a/22.md b/22.md
index be07e53..daad6ea 100644
--- a/22.md
+++ b/22.md
@@ -45,7 +45,7 @@ Tags `K` and `k` MUST be present to define the event kind of the root and the pa
 `I` and `i` tags create scopes for hashtags, geohashes, URLs, and other external identifiers.
-The possible values for `i` tags – and `k` tags, when related to an extenal identity – are listed on [NIP-73](73.md).
+The possible values for `i` tags – and `k` tags, when related to an external identity – are listed on [NIP-73](73.md).
 Their uppercase versions use the same type of values but relate to the root item instead of the parent one.
 `q` tags MAY be used when citing events in the `.content` with [NIP-21](21.md).
@@ -143,13 +143,13 @@ A comment on a website's url looks like this:
  "tags": [
    // referencing the root url
    ["I", "https://abc.com/articles/1"],
-    // the root "kind": for an url, the kind is its domain
+    // the root "kind": for an url
-    ["K", "https://abc.com"],
+    ["K", "web"],
    // the parent reference (same as root for top-level comments)
    ["i", "https://abc.com/articles/1"],
-    // the parent "kind": for an url, the kind is its domain
+    // the parent "kind": for an url
-    ["k", "https://abc.com"]
+    ["k", "web"]
  ]
  // other fields
 }
@@ -192,7 +192,7 @@ A reply to a podcast comment:
    // this is a reference to the above comment
    ["e", "80c48d992a38f9c445b943a9c9f1010b396676013443765750431a9004bdac05", "wss://example.relay", "252f10c83610ebca1a059c0bae8255eba2f95be4d1d7bcfa89d7248a82d9f111"],
    // the parent comment kind
-    ["k", "1111"]
+    ["k", "1111"],
    ["p", "252f10c83610ebca1a059c0bae8255eba2f95be4d1d7bcfa89d7248a82d9f111"]
  ]
  // other fields
diff --git a/24.md b/24.md
index 5904efb..0094d58 100644
--- a/24.md
+++ b/24.md
@@ -8,8 +8,7 @@ Extra metadata fields and tags
 This NIP keeps track of extra optional fields that can added to events which are not defined anywhere else but have become _de facto_ standards and other minor implementation possibilities that do not deserve their own NIP and do not have a place in other NIPs.
-kind 0
+### kind 0
-======
 These are extra fields not specified in NIP-01 that may be present in the stringified JSON of metadata events:
@@ -19,24 +18,22 @@ These are extra fields not specified in NIP-01 that may be present in the string
  - `bot`: a boolean to clarify that the content is entirely or partially the result of automation, such as with chatbots or newsfeeds.
  - `birthday`: an object representing the author's birth date. The format is { "year": number, "month": number, "day": number }. Each field MAY be omitted.
-### Deprecated fields
+#### Deprecated fields
 These are fields that should be ignored or removed when found in the wild:
  - `displayName`: use `display_name` instead.
  - `username`: use `name` instead.
-kind 3
+### kind 3
-======
 These are extra fields not specified in NIP-02 that may be present in the stringified JSON of follow events:
-### Deprecated fields
+#### Deprecated fields
  - `{<relay-url>: {"read": <true|false>, "write": <true|false>}, ...}`: an object of relays used by a user to read/write. [NIP-65](65.md) should be used instead.
-tags
+### tags
-====
 These tags may be present in multiple event kinds. Whenever a different meaning is not specified by some more specific NIP, they have the following meanings:
diff --git a/25.md b/25.md
index 72109c0..7ac4fb1 100644
--- a/25.md
+++ b/25.md
@@ -7,38 +7,36 @@ Reactions
 `draft` `optional`
-A reaction is a `kind 7` event that is used to react to other events.
+A reaction is a `kind 7` event that is used to indicate user reactions to other events. A
+reaction's `content` field MUST include user-generated-content indicating the value of the
+reaction (conventionally `+`, `-`, or an emoji).
-The generic reaction, represented by the `content` set to a `+` string, SHOULD
+A reaction with `content` set to `+` or an empty string MUST be interpreted as a "like" or "upvote".
-be interpreted as a "like" or "upvote".
+A reaction with `content` set to `-` MUST be interpreted as a "dislike" or "downvote".
-A reaction with `content` set to `-` SHOULD be interpreted as a "dislike" or
+A reaction with `content` set to an emoji or [NIP-30](30.md) custom emoji SHOULD NOT be interpreted
-"downvote". It SHOULD NOT be counted as a "like", and MAY be displayed as a
+as a "like" or "dislike". Clients MAY instead display this emoji reaction on the post.
-downvote or dislike on a post. A client MAY also choose to tally likes against
-dislikes in a reddit-like system of upvotes and downvotes, or display them as
-separate tallies.
-The `content` MAY be an emoji, or [NIP-30](30.md) custom emoji in this case it MAY be interpreted as a "like" or "dislike",
-or the client MAY display this emoji reaction on the post. If the `content` is an empty string then the client should
-consider it a "+".
 Tags
 ----
 There MUST be always an `e` tag set to the `id` of the event that is being reacted to. The `e` tag SHOULD include a relay hint pointing to a relay where the event being reacted to can be found. If a client decides to include other `e`, which not recommended, the target event `id` should be last of the `e` tags.
-The SHOULD be a `p` tag set to the `pubkey` of the event being reacted to. If a client decides to include other `p` tags, which not recommended, the target event `pubkey` should be last the `p` tags.
+There SHOULD be a `p` tag set to the `pubkey` of the event being reacted to. If a client decides to include other `p` tags, which not recommended, the target event `pubkey` should be last the `p` tags.
 If the event being reacted to is an addressable event, an `a` SHOULD be included together with the `e` tag, it must be set to the coordinates (`kind:pubkey:d-tag`) of the event being reacted to.
-The reaction SHOULD include a `k` tag with the stringified kind number of the reacted event as its value.
+The `e` and `a` tags SHOULD include relay and pubkey hints. The `p` tags SHOULD include relay hints.
+The reaction event MAY include a `k` tag with the stringified kind number of the reacted event as its value.
 **Example code**
 ```swift
-func make_like_event(pubkey: String, privkey: String, liked: NostrEvent) -> NostrEvent {
+func make_like_event(pubkey: String, privkey: String, liked: NostrEvent, hint: String) -> NostrEvent {
-    tags.append(["e", liked.id, liked.source_relays.first ?? ""])
+    var tags: [[String]] = []
-    tags.append(["p", liked.pubkey])
+    tags.append(["e", liked.id, hint, liked.pubkey])
+    tags.append(["p", liked.pubkey, hint])
    tags.append(["k", String(liked.kind)])
    let ev = NostrEvent(content: "+", pubkey: pubkey, kind: 7, tags: tags)
    ev.calculate_id()
@@ -47,25 +45,39 @@ func make_like_event(pubkey: String, privkey: String, liked: NostrEvent) -> Nost
 }
 ```
-Reactions to a website
+External Content Reactions
 ---------------------
-If the target of the reaction is a website, the reaction MUST be a `kind 17` event and MUST include an `r` tag with the website's URL.
+If the target of a reaction is not a native nostr event, the reaction MUST be a `kind 17` event and MUST include [NIP-73](73.md) external content `k` + `i` tags to properly reference the content.
+_Reacting to a website:_
 ```jsonc
 {
  "kind": 17,
  "content": "⭐",
  "tags": [
-    ["r", "https://example.com/"]
+    ["k", "web"],
+    ["i", "https://example.com"]
  ],
-  // other fields...
 }
 ```
-URLs SHOULD be [normalized](https://datatracker.ietf.org/doc/html/rfc3986#section-6), so that reactions to the same website are not omitted from queries.
+_Reacting to a podcast episode:_
-A fragment MAY be attached to the URL, to react to a section of the page.
+```jsonc
-It should be noted that a URL with a fragment is not considered to be the same URL as the original.
+{
+  "kind": 17,
+  "content": "+",
+  "tags": [
+    ["k", "podcast:guid"],
+    ["i", "podcast:guid:917393e3-1b1e-5cef-ace4-edaa54e1f810", "https://fountain.fm/show/QRT0l2EfrKXNGDlRrmjL"],
+    ["k", "podcast:item:guid"],
+    ["i", "podcast:item:guid:PC20-229", "https://fountain.fm/episode/DQqBg5sD3qFGMCZoSuLF"]
+  ],
+}
+```
 Custom Emoji Reaction
 ---------------------
diff --git a/26.md b/26.md
index 050041b..6cd32f4 100644
--- a/26.md
+++ b/26.md
@@ -1,4 +1,4 @@
-> __Warning__  `unrecommended`: adds unecessary burden for little gain
+> __Warning__  `unrecommended`: adds unnecessary burden for little gain
 NIP-26
 =======
@@ -6,7 +6,7 @@ NIP-26
 Delegated Event Signing
 -----------------------
-`draft` `optional`
+`draft` `optional` `relay`
 This NIP defines how events can be delegated so that they can be signed by other keypairs.
diff --git a/29.md b/29.md
index 601d63a..f39d4d8 100644
--- a/29.md
+++ b/29.md
@@ -4,7 +4,7 @@ NIP-29
 Relay-based Groups
 ------------------
-`draft` `optional`
+`draft` `optional` `relay`
 This NIP defines a standard for groups that are only writable by a closed set of users. They can be public for reading by external users or not.
@@ -48,14 +48,6 @@ The roles supported by the group as to having some special privilege assigned to
 Users with any roles that have any privilege can be considered _admins_ in a broad sense and be returned in the `kind:39001` event for a group.
-## Unmanaged groups
-Unmanaged groups are impromptu groups that can be used in any public relay unaware of NIP-29 specifics. They piggyback on relays' natural white/blacklists (or lack of) but aside from that are not actively managed and won't have any admins, group state or metadata events.
-In `unmanaged` groups, everybody is considered to be a member.
-Unmanaged groups can transition to managed groups, in that case the relay master key just has to publish moderation events setting the state of all groups and start enforcing the rules they choose to.
 ## Event definitions
 These are the events expected to be found in NIP-29 groups.
@@ -83,7 +75,7 @@ Any user can send a kind `9021` event to the relay in order to request admission
 }
 ```
-The optional `code` tag may be used by the relay to preauthorize acceptances in `closed` groups, together with the `kind:9009` `create-invite` moderation event.
+The optional `code` tag may be used by the relay to preauthorize acceptance, together with the `kind:9009` `create-invite` moderation event.
 - *leave request* (`kind:9022`)
@@ -120,21 +112,21 @@ Clients can send these events to a relay in order to accomplish a moderation act
 Each moderation action uses a different kind and requires different arguments, which are given as tags. These are defined in the following table:
-| kind | name                | tags                                           |
+| kind | name            | tags                                                                             |
-| ---  | ---                 | ---                                            |
+| ---  | ---             | ---                                                                              |
-| 9000 | `put-user`          | `p` with pubkey hex and optional roles         |
+| 9000 | `put-user`      | `p` with pubkey hex and optional roles                                           |
-| 9001 | `remove-user`       | `p` with pubkey hex                            |
+| 9001 | `remove-user`   | `p` with pubkey hex                                                              |
-| 9002 | `edit-metadata`     | fields from `kind:39000` to be modified        |
+| 9002 | `edit-metadata` | fields to be modified, and optionally `unrestricted`, `open`, `visible` `public` |
-| 9005 | `delete-event`      | `e` with event id hex                          |
+| 9005 | `delete-event`  | `e` with event id hex                                                            |
-| 9007 | `create-group`      |                                                |
+| 9007 | `create-group`  |                                                                                  |
-| 9008 | `delete-group`      |                                                |
+| 9008 | `delete-group`  |                                                                                  |
-| 9009 | `create-invite`     |                                                |
+| 9009 | `create-invite` | arbitrary `code`                                                                 |
 It's expected that the group state (of who is an allowed member or not, who is an admin and with which permission or not, what are the group name and picture etc) can be fully reconstructed from the canonical sequence of these events.
 ### Group metadata events
-These events contain the group id in a `d` tag instead of the `h` tag. They MUST be created by the relay master key only and a single instance of each (or none) should exist at all times for each group. They are merely informative but should reflect the latest group state (as it was changed by moderation events over time).
+These events contain the group id in a `d` tag instead of the `h` tag. They MUST be created by the relay master key only (as stated by the [NIP-11](11.md) `"self"` pubkey) and a single instance of each (or none) should exist at all times for each group. They are merely informative but should reflect the latest group state (as it was changed by moderation events over time).
 - *group metadata* (`kind:39000`) (optional)
@@ -142,8 +134,6 @@ This event defines the metadata for the group -- basically how clients should di
 If the group is forked and hosted in multiple relays, there will be multiple versions of this event in each different relay and so on.
-When this event is not found, clients may still connect to the group, but treat it as having a different status, `unmanaged`,
 ```jsonc
 {
  "kind": 39000,
@@ -153,14 +143,18 @@ When this event is not found, clients may still connect to the group, but treat
    ["name", "Pizza Lovers"],
    ["picture", "https://pizza.com/pizza.png"],
    ["about", "a group for people who love pizza"],
-    ["public"], // or ["private"]
+    ["private"],
-    ["open"] // or ["closed"]
+    ["closed"]
  ]
  // other fields...
 }
 ```
-`name`, `picture` and `about` are basic metadata for the group for display purposes. `public` signals the group can be _read_ by anyone, while `private` signals that only AUTHed users can read. `open` signals that anyone can request to join and the request will be automatically granted, while `closed` signals that members must be pre-approved or that requests to join will be manually handled.
+- `name`, `picture` and `about` are basic metadata for the group for display purposes.
+- `private` indicates that only members can _read_ group messages. Omitting this tag indicates that anyone can read group messages.
+- `restricted` indicates that only members can _write_ messages to the group. Omitting this tag indicates that anyone can send messages to the group.
+- `hidden` indicates that relays should hide group metadata from non-members. Omitting this tag indicates that anyone can request group metadata events.
+- `closed` indicates that join requests are ignored. Omitting this tag indicates that users can expect join requests to be honored.
 - *group admins* (`kind:39001`) (optional)
@@ -227,18 +221,12 @@ The process through which the relay decides what roles to support and how to han
 ### Checking your own membership in a group
-The latest of either `kind:9000` or `kind:9001` events present in a group should tell a user that they are currently members of the group or if they were removed. In case none of these exist the user is assumed to not be a member of the group -- unless the group is `unmanaged`, in which case the user is assumed to be a member.
+The latest of either `kind:9000` or `kind:9001` events present in a group should tell a user that they are currently members of the group or if they were removed. In case none of these exist the user is assumed to not be a member of the group.
 ### Adding yourself to a group
-When a group is `open`, anyone can send a `kind:9021` event to it in order to be added, then expect a `kind:9000` event to be emitted confirming that the user was added. The same happens with `closed` groups, except in that case a user may only send a `kind:9021` if it has an invite code.
+Anyone can send a `kind:9021` join request to a group. The relay may then generate a `kind:9000` event immediately, or defer that decision to an administator. If a group is `closed`, join requests are not honored unless they include an invite code.
 ### Storing your list of groups
 A definition for `kind:10009` was included in [NIP-51](51.md) that allows clients to store the list of groups a user wants to remember being in.
-### 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.
diff --git a/30.md b/30.md
index 54a8b37..c9b9ebe 100644
--- a/30.md
+++ b/30.md
@@ -9,13 +9,14 @@ Custom Emoji
 Custom emoji may be added to **kind 0**, **kind 1**, **kind 7** ([NIP-25](25.md)) and **kind 30315** ([NIP-38](38.md)) events by including one or more `"emoji"` tags, in the form:
 ```
-["emoji", <shortcode>, <image-url>]
+["emoji", <shortcode>, <image-url>, <emoji-set-address>]
 ```
 Where:
 - `<shortcode>` is a name given for the emoji, which MUST be comprised of only alphanumeric characters and underscores.
 - `<image-url>` is a URL to the corresponding image file of the emoji.
+- `<emoji-set-address>` is an optional address pointer (`kind:pubkey:d-tag`) to the kind 30030 emoji set ([NIP-51](51.md)) the emoji belongs to.
 For each emoji tag, clients should parse emoji shortcodes (aka "emojify") like `:shortcode:` in the event to display custom emoji.
@@ -46,7 +47,7 @@ In kind 1 events, the `content` should be emojified.
  "kind": 1,
  "content": "Hello :gleasonator: 😂 :ablobcatrainbow: :disputed: yolo",
    "tags": [
-    ["emoji", "ablobcatrainbow", "https://gleasonator.com/emoji/blobcat/ablobcatrainbow.png"],
+    ["emoji", "ablobcatrainbow", "https://gleasonator.com/emoji/blobcat/ablobcatrainbow.png", "30030:79c2cae114ea28a981e7559b4fe7854a473521a8d22a66bbab9fa248eb820ff6:blobcats"],
    ["emoji", "disputed", "https://gleasonator.com/emoji/Fun/disputed.png"],
    ["emoji", "gleasonator", "https://gleasonator.com/emoji/Gleasonator/gleasonator.png"]
  ],
diff --git a/34.md b/34.md
index 56ede85..d35c0eb 100644
--- a/34.md
+++ b/34.md
@@ -10,7 +10,7 @@ This NIP defines all the ways code collaboration using and adjacent to [`git`](h
 ## Repository announcements
-Git repositories are hosted in Git-enabled servers, but their existence can be announced using Nostr events, as well as their willingness to receive patches, bug reports and comments in general.
+Git repositories are hosted in Git-enabled servers, but their existence can be announced using Nostr events. By doing so the author asserts themselves as a maintainer and expresses a willingness to receive patches, bug reports and comments in general, unless `t` tag `personal-fork` is included.
 ```jsonc
 {
@@ -25,6 +25,7 @@ Git repositories are hosted in Git-enabled servers, but their existence can be a
    ["relays", "<relay-url>", ...], // relays that this repository will monitor for patches and issues
    ["r", "<earliest-unique-commit-id>", "euc"],
    ["maintainers", "<other-recognized-maintainer>", ...],
+    ["t","personal-fork"], // optionally indicate author isn't a maintainer
    ["t", "<arbitrary string>"], // hashtags labelling the repository
  ]
 }
@@ -45,7 +46,7 @@ An optional source of truth for the state of branches and tags in a repository.
  "kind": 30618,
  "content": "",
  "tags": [
-    ["d", "<repo-id>"], // matches the identifier in the coresponding repository announcement
+    ["d", "<repo-id>"], // matches the identifier in the corresponding repository announcement
    ["refs/<heads|tags>/<branch-or-tag-name>","<commit-id>"]
    ["HEAD", "ref: refs/heads/<branch-name>"]
  ]
@@ -66,13 +67,17 @@ The `refs` tag can be optionally extended to enable clients to identify how many
 }
 ```
-## Patches
+## Patches and Pull Requests (PRs)
-Patches can be sent by anyone to any repository. Patches to a specific repository SHOULD be sent to the relays specified in that repository's announcement event's `"relays"` tag. Patch events SHOULD include an `a` tag pointing to that repository's announcement address.
+Patches and PRs can be sent by anyone to any repository. Patches and PRs to a specific repository SHOULD be sent to the relays specified in that repository's announcement event's `"relays"` tag. Patch and PR events SHOULD include an `a` tag pointing to that repository's announcement address.
-Patches in a patch set SHOULD include a NIP-10 `e` `reply` tag pointing to the previous patch.
+Patches SHOULD be used if each event is under 60kb, otherwise PRs SHOULD be used.
-The first patch revision in a patch revision SHOULD include a NIP-10 `e` `reply` to the original root patch.
+### Patches
+Patches in a patch set SHOULD include a [NIP-10](10.md) `e` `reply` tag pointing to the previous patch.
+The first patch revision in a patch revision SHOULD include a [NIP-10](10.md) `e` `reply` to the original root patch.
 ```jsonc
 {
@@ -103,9 +108,66 @@ The first patch revision in a patch revision SHOULD include a NIP-10 `e` `reply`
 The first patch in a series MAY be a cover letter in the format produced by `git format-patch`.
+### Pull Requests
+The PR or PR update tip SHOULD be successfully pushed to `refs/nostr/<[PR|PR-Update]-event-id>` in all repositories listed in its `clone` tag before the event is signed.
+An attempt SHOULD be made to push this ref to all repositories listed in the repository's announcement event's `"clone"` tag, for which their is reason to believe the user might have write access. This includes each [grasp server](https://njump.me/naddr1qvzqqqrhnypzpgqgmmc409hm4xsdd74sf68a2uyf9pwel4g9mfdg8l5244t6x4jdqy28wumn8ghj7un9d3shjtnwva5hgtnyv4mqqpt8wfshxuqlnvh8x) which can be identified using this method: `clone` tag includes `[http|https]://<grasp-path>/<valid-npub>/<string>.git` and `relays` tag includes `[ws/wss]://<grasp-path>`.
+Clients MAY fallback to creating a 'personal-fork' `repository announcement` listing other grasp servers, e.g. from the `User grasp list`, for the purpose of serving the specified commit(s).
+```jsonc
+{
+  "kind": 1618,
+  "content": "<markdown text>",
+  "tags": [
+    ["a", "30617:<base-repo-owner-pubkey>:<base-repo-id>"],
+    ["r", "<earliest-unique-commit-id-of-repo>"] // so clients can subscribe to all PRs sent to a local git repo
+    ["p", "<repository-owner>"],
+    ["p", "<other-user>"], // optionally send the PR to another user to bring it to their attention
+    ["subject", "<PR-subject>"],
+    ["t", "<PR-label>"], // optional
+    ["t", "<another-PR-label>"], // optional
+    ["c", "<current-commit-id>"], // tip of the PR branch
+    ["clone", "<clone-url>", ...], // at least one git clone url where commit can be downloaded
+    ["branch-name", "<branch-name>"], // optional recommended branch name
+    ["e", "<root-patch-event-id>"], // optionally indicate PR is a revision of an existing patch, which should be closed
+    ["merge-base", "<commit-id>"], // optional: the most recent common ancestor with the target branch
+  ]
+}
+```
+### Pull Request Updates
+A PR Update changes the tip of a referenced PR event.
+```jsonc
+{
+  "kind": 1619,
+  "content": "",
+  "tags": [
+    ["a", "30617:<base-repo-owner-pubkey>:<base-repo-id>"],
+    ["r", "<earliest-unique-commit-id-of-repo>"] // so clients can subscribe to all PRs sent to a local git repo
+    ["p", "<repository-owner>"],
+    ["p", "<other-user>"], // optionally send the PR to another user to bring it to their attention
+    // NIP-22 tags
+    ["E", "<pull-request-event-id>"],
+    ["P", "<pull-request-author>"],
+    ["c", "<current-commit-id>"], // updated tip of PR
+    ["clone", "<clone-url>", ...], // at least one git clone url where commit can be downloaded
+    ["merge-base", "<commit-id>"], // optional: the most recent common ancestor with the target branch
+  ]
+}
+```
 ## Issues
-Issues are Markdown text that is just human-readable conversational threads related to the repository: bug reports, feature requests, questions or comments of any kind. Like patches, these SHOULD be sent to the relays specified in that repository's announcement event's `"relays"` tag. 
+Issues are Markdown text that is just human-readable conversational threads related to the repository: bug reports, feature requests, questions or comments of any kind. Like patches, these SHOULD be sent to the relays specified in that repository's announcement event's `"relays"` tag.
 Issues may have a `subject` tag, which clients can utilize to display a header. Additionally, one or more `t` tags may be included to provide labels for the issue.
@@ -125,11 +187,11 @@ Issues may have a `subject` tag, which clients can utilize to display a header.
 ## Replies
-Replies to either a `kind:1621` _issue_ or a `kind:1617` _patch_ event should follow [NIP-22 comment](22.md).
+Replies to either a `kind:1621` (_issue_), `kind:1617` (_patch_) or `kind:1618` (_pull request_) event should follow [NIP-22 comment](22.md).
 ## Status
-Root Patches and Issues have a Status that defaults to 'Open' and can be set by issuing Status events.
+Root Patches, PRs and Issues have a Status that defaults to 'Open' and can be set by issuing Status events.
 ```jsonc
 {
@@ -139,7 +201,7 @@ Root Patches and Issues have a Status that defaults to 'Open' and can be set by
  "kind": 1633, // Draft
  "content": "<markdown text>",
  "tags": [
-    ["e", "<issue-or-original-root-patch-id-hex>", "", "root"],
+    ["e", "<issue-or-PR-or-original-root-patch-id-hex>", "", "root"],
    ["e", "<accepted-revision-root-id-hex>", "", "reply"], // for when revisions applied
    ["p", "<repository-owner>"],
    ["p", "<root-event-author>"],
@@ -150,7 +212,7 @@ Root Patches and Issues have a Status that defaults to 'Open' and can be set by
    ["r", "<earliest-unique-commit-id-of-repo>"]
    // optional for `1631` status
-    ["e", "<applied-or-merged-patch-event-id>", "", "mention"], // for each
+    ["q", "<applied-or-merged-patch-event-id>", "<relay-url>", "<pubkey>"], // for each
    // when merged
    ["merge-commit", "<merge-commit-id>"]
    ["r", "<merge-commit-id>"]
@@ -161,12 +223,26 @@ Root Patches and Issues have a Status that defaults to 'Open' and can be set by
 }
 ```
-The Status event with the largest created_at date is valid.
+The most recent Status event (by `created_at` date) from either the issue/patch author or a maintainer is considered valid.
-The Status of a patch-revision defaults to either that of the root-patch, or `1632` (Closed) if the root-patch's Status is `1631` and the patch-revision isn't tagged in the `1631` event.
+The Status of a patch-revision is to either that of the root-patch, or `1632` (_Closed_) if the root-patch's Status is `1631` (_Applied/Merged_) and the patch-revision isn't tagged in the `1631` (_Applied/Merged_) event.
+## User grasp list
+List of [grasp servers](https://njump.me/naddr1qvzqqqrhnypzpgqgmmc409hm4xsdd74sf68a2uyf9pwel4g9mfdg8l5244t6x4jdqy28wumn8ghj7un9d3shjtnwva5hgtnyv4mqqpt8wfshxuqlnvh8x) the user generally wishes to use for NIP-34 related activity. It is similar in function to the NIP-65 relay list and NIP-B7 blossom list.
+The event SHOULD include a list of `g` tags with grasp service websocket URLs in order of preference.
+```jsonc
+{
+  "kind": 10317,
+  "content": "",
+  "tags": [
+    ["g", "<grasp-service-websocket-url>"], // zero or more grasp sever urls
+  ]
+}
+```
 ## Possible things to be added later
- "branch merge" kind (specifying a URL from where to fetch the branch to be merged)
 - inline file comments kind (we probably need one for patches and a different one for merged files)
diff --git a/37.md b/37.md
index 1ade59d..ca0fdfb 100644
--- a/37.md
+++ b/37.md
@@ -1,50 +1,57 @@
 NIP-37
 ======
-Draft Events 
+Draft Wraps
------------
+-----------
 `draft` `optional`
-This NIP defines kind `31234` as a private wrap for drafts of any other event kind. 
+This NIP defines kind `31234` as an encrypted storage for unsigned draft events of any other 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.
+The draft is JSON-stringified, [NIP44-encrypted](44.md) to the signer's public key and placed inside the `.content`.
-An additional `k` tag identifies the kind of the draft event. 
+`k` tags identify the kind of the draft. 
 ```js
 {
  "kind": 31234,
  "tags": [
    ["d", "<identifier>"],
-    ["k", "<kind of the draft event>"],
+    ["k", "<kind of the draft event>"], // required
-    ["e", "<anchor event event id>", "<relay-url>"],
+    ["expiration", "now + 90 days"] // recommended
-    ["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. 
+A blanked `.content` field signals that the draft has been deleted. 
-Tags `e` and `a` identify one or more anchor events, such as parent events on replies.   
+[NIP-40](40.md) `expiration` tags are recommended. 
+Clients SHOULD publish kind `31234` events to relays listed on kind `10013` below.
 ## 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.
+Kind `10013` indicates the user's preferred relays to store private events like Draft Wraps. 
+The event MUST include a list of `relay` URLs in private tags. Private tags are JSON Stringified, [NIP44-encrypted](44.md) to the signer's keys and placed inside the .content of the event.
 ```js
 {
  "kind": 10013,
  "tags": [],
-  "content": nip44Encrypt(JSON.stringify([
+  "content": nip44Encrypt(
-    ["relay", "wss://myrelay.mydomain.com"]
+    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.
+It's recommended that Private Storage relays SHOULD be [NIP-42](42.md)-authed and only allow downloads of events signed by the authed user.
-Clients SHOULD publish kind `10013` events to the author's [NIP-65](65.md) `write` relays. 
+Clients MUST publish kind `10013` events to the author's [NIP-65](65.md) `write` relays. 
diff --git a/38.md b/38.md
index ece5e5f..27359f1 100644
--- a/38.md
+++ b/38.md
@@ -50,11 +50,11 @@ The status MAY include an `r`, `p`, `e` or `a` tag linking to a URL, profile, no
 The `content` MAY include emoji(s), or [NIP-30](30.md) custom emoji(s). If the `content` is an empty string then the client should clear the status.
-# Client behavior
+## Client behavior
 Clients MAY display this next to the username on posts or profiles to provide live user status information.
-# Use Cases
+## Use Cases
 * Calendar nostr apps that update your general status when you're in a meeting
 * Nostr Nests that update your general status with a link to the nest when you join
diff --git a/39.md b/39.md
index 3777ac5..8a3247f 100644
--- a/39.md
+++ b/39.md
@@ -8,16 +8,11 @@ External Identities in Profiles
 ## Abstract
-Nostr protocol users may have other online identities such as usernames, profile pages, keypairs etc. they control and they may want to include this data in their profile metadata so clients can parse, validate and display this information.
+Users can declare their control over one or more online identities such as usernames, profile pages, keypairs in kind `10011` using `i` tags.
-## `i` tag on a metadata event
-A new optional `i` tag is introduced for `kind 0` metadata event defined in [NIP-01](01.md):
 ```jsonc
 {
-  "id": <id>,
+  "kind": 10011,
-  "pubkey": <pubkey>,
  "tags": [
    ["i", "github:semisol", "9721ce4ee4fceb91c9711ca2a6c9a5ab"],
    ["i", "twitter:semisol_public", "1619358434134196225"],
@@ -28,7 +23,7 @@ A new optional `i` tag is introduced for `kind 0` metadata event defined in [NIP
 }
 ```
-An `i` tag will have two parameters, which are defined as the following:
+An `i` tag MUST have two parameters, which are defined as the following:
 1. `platform:identity`: This is the platform name (for example `github`) and the identity on that platform (for example `semisol`) joined together with `:`.
 2. `proof`: String or object that points to the proof of owning this identity.
diff --git a/40.md b/40.md
index 909747f..9450b3c 100644
--- a/40.md
+++ b/40.md
@@ -4,7 +4,7 @@ NIP-40
 Expiration Timestamp
 --------------------
-`draft` `optional`
+`draft` `optional` `relay`
 The `expiration` tag enables users to specify a unix timestamp at which the message SHOULD be considered expired (by relays and clients) and SHOULD be deleted by relays.
diff --git a/42.md b/42.md
index fdc5d10..c2b6ded 100644
--- a/42.md
+++ b/42.md
@@ -4,7 +4,7 @@ NIP-42
 Authentication of clients to relays
 -----------------------------------
-`draft` `optional`
+`draft` `optional` `relay`
 This NIP defines a way for clients to authenticate to relays by signing an ephemeral event.
@@ -32,6 +32,8 @@ And, when sent by clients, the following form:
 ["AUTH", <signed-event-json>]
 ```
+Clients MAY provide signed events from multiple pubkeys in a sequence of `AUTH` messages. Relays MUST treat all pubkeys as authenticated accordingly.
 `AUTH` messages sent by clients MUST be answered with an `OK` message, like any `EVENT` message.
 ### Canonical authentication event
@@ -69,7 +71,9 @@ relay: ["AUTH", "<challenge>"]
 client: ["REQ", "sub_1", {"kinds": [4]}]
 relay: ["CLOSED", "sub_1", "auth-required: we can't serve DMs to unauthenticated users"]
 client: ["AUTH", {"id": "abcdef...", ...}]
+client: ["AUTH", {"id": "abcde2...", ...}]
 relay: ["OK", "abcdef...", true, ""]
+relay: ["OK", "abcde2...", true, ""]
 client: ["REQ", "sub_1", {"kinds": [4]}]
 relay: ["EVENT", "sub_1", {...}]
 relay: ["EVENT", "sub_1", {...}]
diff --git a/43.md b/43.md
new file mode 100644
index 0000000..d0742b4
--- /dev/null
+++ b/43.md
@@ -0,0 +1,146 @@
+NIP-43
+======
+Relay Access Metadata and Requests
+----------------------------------
+`draft` `optional` `relay`
+This NIP defines a way for relays to advertise membership lists, and for clients to request admission to relays on behalf of users.
+## Membership Lists
+Relays MAY publish a `kind 13534` event which indicates pubkeys that have access to a given relay. This event MUST be signed by the pubkey specified in the `self` field of the relay's [NIP 11](./11.md) document.
+The following tags are required:
+- A [NIP 70](./70.md) `-` tag
+- A `member` tag containing a hex pubkey should be included for each member
+This list should not be considered exhaustive or authoritative. To determine membership, both a `kind 13534` event by the relay, and a `kind 10010` event by the member should be consulted.
+Example:
+```jsonc
+{
+  "kind": 13534,
+  "pubkey": "<nip11.self>",
+  "tags": [
+    ["-"],
+    ["member", "c308e1f882c1f1dff2a43d4294239ddeec04e575f2d1aad1fa21ea7684e61fb5"],
+    ["member", "ee1d336e13779e4d4c527b988429d96de16088f958cbf6c074676ac9cfd9c958"]
+  ],
+  // ...other fields
+}
+```
+## Add User
+Relays MAY publish a `kind 8000` event when a member is added to the relay. This event MUST be signed by the pubkey specified in the `self` field of the relay's [NIP 11](./11.md) document.
+The following tags are required:
+- A [NIP 70](./70.md) `-` tag
+- A `p` tag indicating the member's hex pubkey
+Example:
+```jsonc
+{
+  "kind": 8000,
+  "pubkey": "<nip11.self>",
+  "tags": [
+    ["-"],
+    ["p", "c308e1f882c1f1dff2a43d4294239ddeec04e575f2d1aad1fa21ea7684e61fb5"]
+  ],
+  // ...other fields
+}
+```
+## Remove User
+Relays MAY publish a `kind 8001` event when a member is removed from the relay. This event MUST be signed by the pubkey specified in the `self` field of the relay's [NIP 11](./11.md) document.
+The following tags are required:
+- A [NIP 70](./70.md) `-` tag
+- A `p` tag indicating the member's hex pubkey
+Example:
+```jsonc
+{
+  "kind": 8001,
+  "pubkey": "<nip11.self>",
+  "tags": [
+    ["-"],
+    ["p", "c308e1f882c1f1dff2a43d4294239ddeec04e575f2d1aad1fa21ea7684e61fb5"]
+  ],
+  // ...other fields
+}
+```
+## Join Request
+A user MAY send a `kind 28934` to a relay in order to request admission. It MUST have a `claim` tag containing an invite code. The event's `created_at` MUST be now, plus or minus a few minutes.
+```jsonc
+{
+  "kind": 28934,
+  "pubkey": "<user pubkey>",
+  "tags": [
+    ["-"],
+    ["claim", "<invite code>"]
+  ],
+  // ...other fields
+}
+```
+Upon receiving a claim, a relay MUST notify the client as to what the status of the claim is using an `OK` message. Failed claims SHOULD use the same standard `"restricted: "` prefix specified by NIP 42.
+Relays SHOULD update their `kind 13534` member list and MAY publish a `kind 8000` "add member" event.
+Some examples:
+```
+["OK", <event-id>, false, "restricted: that invite code is expired."]
+["OK", <event-id>, false, "restricted: that is an invalid invite code."]
+["OK", <event-id>, true, "duplicate: you are already a member of this relay."]
+["OK", <event-id>, true, "info: welcome to wss://relay.bunk.skunk!"]
+```
+## Invite Request
+Users may request a claim string from a relay by making a request for `kind 28935` events. This event MUST be signed by the pubkey specified in the `self` field of the relay's [NIP 11](./11.md) document.
+```jsonc
+{
+  "kind": 28935,
+  "pubkey": "<nip11.self>",
+  "tags": [
+    ["-"],
+    ["claim", "<invite code>"],
+  ],
+  // ...other fields
+}
+```
+Note that these events are in the `ephemeral` range, which means relays must explicitly opt-in to this behavior by generating claims on the fly when requested. This allows relays to improve security by issuing a different claim for each request, only issuing claims to certain users, or expiring claims.
+## Leave Request
+A user MAY send a `kind 28936` to a relay in order to request that their access be revoked. The event's `created_at` MUST be now, plus or minus a few minutes. This event MUST include a [NIP 70](./70.md) `-` tag.
+```jsonc
+{
+  "kind": 28936,
+  "tags": [["-"]],
+  // ...other fields
+}
+```
+Relays SHOULD update their `kind 13534` member list and MAY publish a `kind 8001` "remove member" event.
+## Implementation
+Clients MUST only request `kind 28935` events from and send `kind 28934` events to relays which include this NIP in the `supported_nips` section of its [NIP 11](./11.md) relay information document.
diff --git a/44.md b/44.md
index 8ba966c..47b8990 100644
--- a/44.md
+++ b/44.md
@@ -84,12 +84,12 @@ NIP-44 version 2 has the following design characteristics:
   - Slice 76-byte HKDF output into: `chacha_key` (bytes 0..32), `chacha_nonce` (bytes 32..44), `hmac_key` (bytes 44..76)
 4. Add padding
   - Content must be encoded from UTF-8 into byte array
-   - Validate plaintext length. Minimum is 1 byte, maximum is 4294967296 bytes
+   - Validate plaintext length. Minimum is 1 byte, maximum is 4,294,967,295 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 bytes
-   - Plaintext length is encoded in big-endian:
+   - Plaintext length prefix is encoded in big-endian:
-     - if smaller than 65536, as a u16 in the first 2 bytes of the padded blob;
+     - If length is less than 65536: prefix is 2 bytes (`u16`), format is `[plaintext_length: u16][plaintext][zero_bytes]`
-     - if greater than 65536, the first 6 bytes of the padded blob, the first 2 being zero and the other 4 being the actual encoded length as u32
+     - If length is 65536 or greater: prefix is 6 bytes (2 zero bytes + `u32`), format is `[0x00, 0x00][plaintext_length: u32][plaintext][zero_bytes]`
+   - A zero value in the first 2 bytes signals the extended format; since valid plaintext is at least 1 byte, a u16 length of 0 is otherwise invalid
 5. Encrypt padded content
   - Use ChaCha20, with key and nonce from step 3
 6. Calculate MAC (message authentication code)
@@ -114,8 +114,8 @@ validation rules, refer to BIP-340.
 2. Decode base64
   - Base64 is decoded into `version, nonce, ciphertext, mac`
   - If the version is unknown, implementations must indicate that the encryption version is not supported
-   - Validate length of base64 message to prevent DoS on base64 decoder: it can be in range from 132 to 87472 chars
+   - Validate minimum length of base64 message to prevent DoS on base64 decoder: it must be at least 132 chars
-   - Validate length of decoded message to verify output of the decoder: it can be in range from 99 to 65603 bytes
+   - Validate minimum length of decoded message to verify output of the decoder: it must be at least 99 bytes
 3. Calculate conversation key
   - See step 1 of [encryption](#Encryption)
 4. Calculate message keys
@@ -126,12 +126,23 @@ validation rules, refer to BIP-340.
 6. Decrypt ciphertext
   - Use ChaCha20 with key and nonce from step 3
 7. Remove padding
-   - Read the first 2 bytes,
+   - Read the first 2 bytes as a big-endian u16
-     - if they're zero, read the next 4 bytes as the u32 big-endian plaintext length;
+     - If zero, read the next 4 bytes as a big-endian u32 plaintext length (6-byte prefix total)
-     - otherwise interpret those 2 bytes as the u16 plaintext length
+     - Otherwise, use those 2 bytes as the u16 plaintext length (2-byte prefix total)
-   - Verify that the length of sliced plaintext matches the value of the two BE bytes
+   - Verify that the length of sliced plaintext matches the decoded length
   - Verify that calculated padding from step 3 of the [encryption](#Encryption) process matches the actual padding
+### Implementation considerations
+The theoretical maximum plaintext size is 2^32 - 1 bytes (~4 GB). Implementations SHOULD enforce
+their own maximum payload size based on platform and resource constraints, rejecting oversized payloads
+early in `decode_payload` (before base64 decoding) to prevent denial-of-service. Decryption may require
+several times the payload size in working memory due to base64 decoding, byte array slicing, and
+padding operations. For reference, JVM-based systems are limited to ~2 GB contiguous arrays, and mobile
+devices may have significantly less available memory. Note that `calc_padded_len` can return values up
+to 2^32, which exceeds the range of unsigned 32-bit integers; implementations must use 64-bit (or
+larger) arithmetic for padding calculations.
 ### Details
 - Cryptographic methods
@@ -152,6 +163,9 @@ 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. 1 byte msg is padded to 32 bytes.
+  - `max_plaintext_size` is 4294967295 (2^32 - 1).
+  - `extended_prefix_threshold` is 65536. Lengths below this use a 2-byte u16 prefix; lengths at or above use a 6-byte prefix (2 zero bytes + u32).
 - 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
@@ -159,6 +173,9 @@ validation rules, refer to BIP-340.
  - `utf8_encode(string)` and `utf8_decode(bytes)` transform string to byte array and back
  - `write_u8(number)` restricts number to values 0..255 and encodes into Big-Endian uint8 byte array
  - `write_u16_be(number)` restricts number to values 0..65535 and encodes into Big-Endian uint16 byte array
+  - `write_u32_be(number)` restricts number to values 0..4294967295 and encodes into Big-Endian uint32 byte array
+  - `read_uint16_be(bytes)` reads 2 bytes as a Big-Endian unsigned 16-bit integer
+  - `read_uint32_be(bytes)` reads 4 bytes as a Big-Endian unsigned 32-bit integer
  - `zeros(length)` creates byte array of length `length >= 0`, filled with zeros
  - `floor(number)` and `log2(number)` are well-known mathematical methods
@@ -178,51 +195,51 @@ def calc_padded_len(unpadded_len):
  if unpadded_len <= 32:
    return 32
  else:
-    return chunk * (floor((len - 1) / chunk) + 1)
+    return chunk * (floor((unpadded_len - 1) / chunk) + 1)
 # Converts unpadded plaintext to padded bytearray
 def pad(plaintext):
  unpadded = utf8_encode(plaintext)
-  unpadded_len = len(plaintext)
+  unpadded_len = len(unpadded)
-  if (unpadded_len < 1 or
+  if (unpadded_len < c.min_plaintext_size or
-      unpadded_len > 4294967295): raise Exception('invalid plaintext length')
+      unpadded_len > c.max_plaintext_size): raise Exception('invalid plaintext length')
-  if unpadded_len > 65536:
+  if unpadded_len >= c.extended_prefix_threshold:
-      prefix = concat(
+    prefix = concat([0, 0], write_u32_be(unpadded_len))  # 6 bytes
-        [0, 0],
-        write_u32_be(unpadded_len),
-      )
  else:
-      prefix = write_u16_be(unpadded_len)
+    prefix = write_u16_be(unpadded_len)                   # 2 bytes
  suffix = zeros(calc_padded_len(unpadded_len) - unpadded_len)
  return concat(prefix, unpadded, suffix)
 # Converts padded bytearray to unpadded plaintext
 def unpad(padded):
-  unpadded_len = read_uint16_be(padded[0:2])
+  first_two = read_uint16_be(padded[0:2])
-  if unpadded_len == 0:
+  if first_two == 0:
-      unpadded_len = read_uint32_be(padded[2:6])
+    unpadded_len = read_uint32_be(padded[2:6])
-      unpadded = padded[6:6+unpadded_len]
+    if unpadded_len < c.extended_prefix_threshold: raise Exception('invalid padding')
+    prefix_len = 6
  else:
-      unpadded = padded[2:2+unpadded_len]
+    unpadded_len = first_two
+    prefix_len = 2
+  unpadded = padded[prefix_len:prefix_len+unpadded_len]
  if (unpadded_len == 0 or
      len(unpadded) != unpadded_len or
-      len(padded) != 2 + calc_padded_len(unpadded_len)): raise Exception('invalid padding')
+      len(padded) != prefix_len + calc_padded_len(unpadded_len)): raise Exception('invalid padding')
  return utf8_decode(unpadded)
-# metadata: always 65b (version: 1b, nonce: 32b, max: 32b)
+# metadata: always 65b (version: 1b, nonce: 32b, mac: 32b)
-# plaintext: 1b to 0xffff
+# plaintext: 1b to 0xffffffff
-# padded plaintext: 32b to 0xffff
+# padded plaintext (small, <65536): 32b to 0x10000, with 2b prefix -> 34b to 0x10000+2
-# ciphertext: 32b+2 to 0xffff+2
+# padded plaintext (large, >=65536): 0x10000 to 0x100000000, with 6b prefix -> 0x10006 to 0x100000000+6
-# raw payload: 99 (65+32+2) to 65603 (65+0xffff+2)
+# ciphertext: same as padded plaintext (chacha20 doesn't change length)
-# compressed payload (base64): 132b to 87472b
+# raw payload (small): 99 (65+34) to 65603 (65+0x10000+2)
+# raw payload (large): 65607 (65+0x10006) to 4294967367 (65+0x100000000+6)
 def decode_payload(payload):
  plen = len(payload)
  if plen == 0 or payload[0] == '#': raise Exception('unknown version')
-  if plen < 132 or plen > 87472: raise Exception('invalid payload size')
+  if plen < 132: raise Exception('invalid payload size')
  data = base64_decode(payload)
-  dlen = len(d)
+  dlen = len(data)
-  if dlen < 99 or dlen > 65603: raise Exception('invalid data size');
+  if dlen < 99: raise Exception('invalid data size');
  vers = data[0]
  if vers != 2: raise Exception('unknown version ' + vers)
  nonce = data[1:33]
@@ -308,3 +325,27 @@ The file also contains intermediate values. A quick guidance with regards to its
 - `invalid.encrypt_msg_lengths`
 - `invalid.get_conversation_key`: calculating conversation_key must throw an error
 - `invalid.decrypt`: decrypting message content must throw an error
+#### Extended length prefix test vectors
+The following test vectors exercise the boundary between the 2-byte u16 prefix and the 6-byte
+extended prefix. Since the payloads are too large to include inline, SHA-256 checksums of the
+plaintext and base64-encoded payload are provided (following the `encrypt_decrypt_long_msg` pattern).
+All vectors use the same `conversation_key` and `nonce` as above. Plaintext is the byte `0x61`
+(`'a'`) repeated to the specified length.
+```
+conversation_key: c41c775356fd92eadc63ff5a0dc1da211b268cbea22316767095b2871ea1412d
+nonce:            0000000000000000000000000000000000000000000000000000000000000001
+```
+| plaintext_len | prefix | padded_len | plaintext_sha256 | payload_sha256 |
+|---|---|---|---|---|
+| 65535 | u16 (2 bytes) | 65536 | `6e1bebca6a8229364a162a72ef064826c4cd7457bf54f190ef782bd9deff3e42` | `6d8c2810d1e870fbaa1f0a0937126cca837a15f9260e27060c331d70a3c0bc84` |
+| 65536 | extended (6 bytes) | 65536 | `bf718b6f653bebc184e1479f1935b8da974d701b893afcf49e701f3e2f9f9c5a` | `b7b4edb36ba92e267d322d56d9aebc22e7fa96ff52e3c12adc07f07a43cbc616` |
+| 65537 | extended (6 bytes) | 81920 | `008ffc88d3c96a9f307524eb361e47c5222a887fc45fa0c1fb8d429c5c23b430` | `eeb7c7c5373894ea2c1547cfd3ccb15d5a0b2d619da852e5c79df792dcc9e435` |
+Note that 65535 and 65536 both have a `padded_len` of 65536, but the total padded-with-prefix
+sizes differ: 65538 (2 + 65536) vs 65542 (6 + 65536). The jump to 65537 triggers the next
+padding bucket at 81920.
diff --git a/45.md b/45.md
index 219368e..794dbe8 100644
--- a/45.md
+++ b/45.md
@@ -4,7 +4,7 @@ NIP-45
 Event Counts
 ------------
-`draft` `optional`
+`draft` `optional` `relay`
 Relays may support the verb `COUNT`, which provides a mechanism for obtaining event counts.
@@ -14,47 +14,137 @@ Some queries a client may want to execute against connected relays are prohibiti
 ## Filters and return values
-This NIP defines the verb `COUNT`, which accepts a subscription id and filters as specified in [NIP 01](01.md) for the verb `REQ`. Multiple filters are OR'd together and aggregated into a single count result.
+This NIP defines the verb `COUNT`, which accepts a query id and filters as specified in [NIP 01](01.md) for the verb `REQ`. Multiple filters are OR'd together and aggregated into a single count result.
 ```
-["COUNT", <subscription_id>, <filters JSON>...]
+["COUNT", <query_id>, <filters JSON>...]
 ```
 Counts are returned using a `COUNT` response in the form `{"count": <integer>}`. Relays may use probabilistic counts to reduce compute requirements.
 In case a relay uses probabilistic counts, it MAY indicate it in the response with `approximate` key i.e. `{"count": <integer>, "approximate": <true|false>}`.
 ```
-["COUNT", <subscription_id>, {"count": <integer>}]
+["COUNT", <query_id>, {"count": <integer>}]
 ```
 Whenever the relay decides to refuse to fulfill the `COUNT` request, it MUST return a `CLOSED` message.
+## HyperLogLog
+Relays may return an HyperLogLog value together with the count, hex-encoded.
+```
+["COUNT", <subscription_id>, {"count": <integer>, "hll": "<hex>"}]
+```
+This is so it enables merging results from multiple relays and yielding a reasonable estimate of reaction counts, comment counts and follower counts, while saving many millions of bytes of bandwidth for everybody.
+### Algorithm
+This section describes the steps a relay should take in order to return HLL values to clients.
+1. Upon receiving a filter, if it is eligible (see below) for HyperLogLog, compute the deterministic `offset` for that filter (see below);
+2. Initialize 256 registers to `0` for the HLL value;
+3. For all the events that are to be counted according to the filter, do this:
+    1. Read the byte at position `offset` of the event `pubkey`, its value will be the register index `ri`;
+    2. Count the number of leading zero bits starting at position `offset+1` of the event `pubkey` and add `1`;
+    3. Compare that with the value stored at register `ri`, if the new number is bigger, store it.
+That is all that has to be done on the relay side, and therefore the only part needed for interoperability.
+On the client side, these HLL values received from different relays can be merged (by simply going through all the registers in HLL values from each relay and picking the highest value for each register, regardless of the relay).
+And finally the absolute count can be estimated by running some methods I don't dare to describe here in English, it's better to check some implementation source code (also, there can be different ways of performing the estimation, with different quirks applied on top of the raw registers).
+### `offset` computation
+The `offset` (used in the HLL computation above) is derived deterministically from the filter sent by the client to the relay. The formula for obtaining the `offset` value is as follows:
+  1. Take the first tag attribute in the filter (with the `#` prefix);
+  2. From that, take its first item (it will be a string);
+  3. Obtain a 32-byte hex string from it:
+    - if the string is an event id or pubkey hex, use it as it is;
+    - if the string is an address (`<kind>:<pubkey>:<d-tag>`), use the `<pubkey>` part;
+    - if the string is anything else, hash it with a `sha256()` and take the result as a hex string;
+  4. From the 64-character hex string obtained before, take the character at position `32`;
+  5. Read that character as a base-16 number;
+  6. Add 8 to it: the result is the `offset`.
+For cases not covered above (filters without a tag attribute, for example), behavior isn't yet defined. This NIP may be modified later to specify those, but for now there isn't a use case that justifies using HLL in those circumstances.
+### Rationale
+The value of `offset` must be deterministic because that's the only way to allow relays to cache the HLL values so they don't have to count thousands of events from the database on every query. It also allows relays to precompute HLL values for any given target `<id>` or `<pubkey>` without having to store the events themselves directly, which can be handy in case of reactions, for example.
+### Common filters
+Some relays may decide to cache or precompute HLL values for some common canonical queries, and also to refrain from counting events that do not match these specs. These are such queries (this NIP can be modified later if more common useful queries are discovered and start being used):
+- **reaction count**: `{"#e": ["<id>"], "kinds": [7]}`
+- **repost count**: `{"#e": ["<id>"], "kinds": [6]}`
+- **quote count**: `{"#q": ["<id>"], "kinds": [1, 1111]}`
+- **reply count**: `{"#e": ["<id>"], "kinds": [1]}`
+- **comment count**: `{"#E": ["<id>"], "kinds": [1111]}`
+- **follower count**: `{"#p": ["<pubkey>"], "kinds": [3]}`
+Notice that these queries only include 1 tag attribute with always a single item in it, which means that implementors don't have to check the order in which these attributes show up in the filter.
+### Attack vectors
+One could mine a pubkey with a certain number of zero bits in the exact place where the HLL algorithm described above would look for them in order to artificially make its reaction or follow "count more" than others. For this to work a different pubkey would have to be created for each different target (event id, followed profile etc). This approach is not very different than creating tons of new pubkeys and using them all to send likes or follow someone in order to inflate their number of followers. The solution is the same in both cases: clients should not fetch these reaction counts from open relays that accept everything, they should base their counts on relays that perform some form of filtering that makes it more likely that only real humans are able to publish there and not bots or artificially-generated pubkeys.
+### `hll` encoding
+The value `hll` value must be the concatenation of the 256 registers, each being a uint8 value (i.e. a byte). Therefore `hll` will be a 512-character hex string.
+### Client-side usage
+This algorithm also allows clients to combine HLL responses received from relays with HLL counts computed locally from raw events. It's recommended that clients keep track of HLL values locally and add to these on each message received from relays. For example:
+  - a client wants to keep track of the number of reactions an event Z has received over time;
+  - the client has decided it will read reactions from relays A, B and C (the NIP-65 "read" relays of Z's author);
+  - of these, only B and C support HLL responses, so the client fetches both and merges them locally;
+  - then the client fetches all reaction events from A then manually applies each event to the HLL from the previous step, using the same algorithm described above;
+  - finally, the client reads the estimate count from the HLL and displays that to the user;
+  - optionally the client may store that HLL value (together with some "last-read-date" for relay A) and repeat the process again later:
+    - this time it only needs to fetch the new reactions from A and add those to the HLL
+    - and redownload the HLL values from B and C and just reapply them to the local value.
+This procedure allows the client to download much less data.
 ## Examples
-### Followers count
+### Count notes and reactions
 ```
-["COUNT", <subscription_id>, {"kinds": [3], "#p": [<pubkey>]}]
+["COUNT", <query_id>, {"kinds": [1, 7], "authors": [<pubkey>]}]
-["COUNT", <subscription_id>, {"count": 238}]
+["COUNT", <query_id>, {"count": 5}]
 ```
-### Count posts and reactions
+### Count notes approximately
 ```
-["COUNT", <subscription_id>, {"kinds": [1, 7], "authors": [<pubkey>]}]
+["COUNT", <query_id>, {"kinds": [1]}]
-["COUNT", <subscription_id>, {"count": 5}]
+["COUNT", <query_id>, {"count": 93412452, "approximate": true}]
+```
+### Followers count with HyperLogLog
+```
+["COUNT", <subscription_id>, {"kinds": [3], "#p": [<pubkey>]}]
+["COUNT", <subscription_id>, {"count": 16578, "hll": "0607070505060806050508060707070706090d080b0605090607070b07090606060b0705070709050807080805080407060906080707080507070805060509040a0b06060704060405070706080607050907070b08060808080b080607090a06060805060604070908050607060805050d05060906090809080807050e0705070507060907060606070708080b0807070708080706060609080705060604060409070a0808050a0506050b0810060a0908070709080b0a07050806060508060607080606080707050806080c0a0707070a080808050608080f070506070706070a0908090c080708080806090508060606090906060d07050708080405070708"}]
 ```
-### Count posts approximately
+### Reaction counts with HyperLogLog
 ```
-["COUNT", <subscription_id>, {"kinds": [1]}]
+["COUNT", <subscription_id>, {"kinds": [7], "#e": [<id>]}]
-["COUNT", <subscription_id>, {"count": 93412452, "approximate": true}]
+["COUNT", <subscription_id>, {"count": 2044, "hll": "01ef070505060806050508060707070706090d080b0605090607070b07090606060b0705070709050807080805080407060906080707080507070805060509040a0b06060704060405070706080607050907070b08060808080b080607090a06060805060604070908050607060805050d05060906090809080807050e0705070507060907060606070708080b0807070708080706060609080705060604060409070a0808050a0506050b0810060a0908070709080b0a07050806060508060607080606080707050806080c0a0707070a080808050608080f070506070706070a0908090c080708080806090508060606090906060d07050708080405070708"}]
 ```
 ### Relay refuses to count
 ```
-["COUNT", <subscription_id>, {"kinds": [4], "authors": [<pubkey>], "#p": [<pubkey>]}]
+["COUNT", <query_id>, {"kinds": [1059], "#p": [<pubkey>]}]
-["CLOSED", <subscription_id>, "auth-required: cannot count other people's DMs"]
+["CLOSED", <query_id>, "auth-required: cannot count other people's DMs"]
 ```
diff --git a/46.md b/46.md
index 1701964..cdc1118 100644
--- a/46.md
+++ b/46.md
@@ -97,18 +97,25 @@ Each of the following are methods that the _client_ sends to the _remote-signer_
 | Command                  | Params                                                                        | Result                                                                 |
 | ------------------------ | -------------------------------------------------                             | ---------------------------------------------------------------------- |
-| `connect`                | `[<remote-signer-pubkey>, <optional_secret>, <optional_requested_permissions>]`        | "ack" OR `<required-secret-value>`                                                                  |
+| `connect`                | `[<remote-signer-pubkey>, <optional_secret>, <optional_requested_perms>]`     | `"ack"` OR `<required-secret-value>`                                   |
 | `sign_event`             | `[<{kind, content, tags, created_at}>]`                                       | `json_stringified(<signed_event>)`                                     |
-| `ping`                   | `[]`                                                                          | "pong"                                                                 |
+| `ping`                   | `[]`                                                                          | `"pong"`                                                               |
-| `get_public_key`         | `[]`                                                                          | `<user-pubkey>`                                                         |
+| `get_public_key`         | `[]`                                                                          | `<user-pubkey>`                                                        |
 | `nip04_encrypt`          | `[<third_party_pubkey>, <plaintext_to_encrypt>]`                              | `<nip04_ciphertext>`                                                   |
 | `nip04_decrypt`          | `[<third_party_pubkey>, <nip04_ciphertext_to_decrypt>]`                       | `<plaintext>`                                                          |
 | `nip44_encrypt`          | `[<third_party_pubkey>, <plaintext_to_encrypt>]`                              | `<nip44_ciphertext>`                                                   |
 | `nip44_decrypt`          | `[<third_party_pubkey>, <nip44_ciphertext_to_decrypt>]`                       | `<plaintext>`                                                          |
+| `switch_relays`          | `[]`                                                                          | `["<relay-url>", "<relay-url>", ...]` OR `null`                        |
 ### 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. `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.
+The `connect` method may be provided with `optional_requested_perms` 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.
+### Switching relays
+At all times, the _remote-signer_ should be in control of what relays are being used for the connection between it and the _client_. Therefore it should be possible for it to evolve its set of relays over time as old relays go out of operation and new ones appear. Even more importantly, in the case of the connection initiated by the _client_ the client may pick relays completely foreign to the _remote-signer_'s preferences, so it must be possible for it to switch those immediately.
+Therefore, compliant clients should send a `switch_relays` request immediately upon establishing a connection (always, or at reasonable intervals). Upon receiving such requests, the _remote-signer_ should reply with its updated list of relays, or `null` if there is nothing to be changed. Immediately upon receiving an updated relay list, the _client_ should update its local state and send further requests on the new relays. The `remote-signer` should then be free to disconnect from the previous relays if that is desired.
 ## Response Events `kind:24133`
@@ -204,7 +211,7 @@ _client_ should display (in a popup or new tab) the URL from the `error` field a
 ### Announcing _remote-signer_ metadata
-_remote-signer_ MAY publish it's metadata by using [NIP-05](05.md) and [NIP-89](89.md). With NIP-05, a request to `<remote-signer>/.well-known/nostr.json?name=_` MAY return this:
+_remote-signer_ MAY publish its metadata by using [NIP-05](05.md) and [NIP-89](89.md). With NIP-05, a request to `<remote-signer>/.well-known/nostr.json?name=_` MAY return this:
 ```jsonc
 {
    "names":{
diff --git a/47.md b/47.md
index 84f710e..6830820 100644
--- a/47.md
+++ b/47.md
@@ -28,15 +28,16 @@ Fundamentally NWC is communication between a **client** and **wallet service** b
 
 4. Once the payment is complete the **wallet service** will send an encrypted `response` (kind 23195) to the **user** over the relay(s) in the URI.
 
- 5. The **wallet service** may send encrypted notifications (kind 23196) of wallet events (such as a received payment) to the **client**.
+ 5. The **wallet service** may send encrypted notifications (kind 23197) of wallet events (such as a received payment) to the **client**.
 ## Events
 There are four event kinds:
 - `NIP-47 info event`: 13194
 - `NIP-47 request`: 23194
 - `NIP-47 response`: 23195
- `NIP-47 notification event`: 23196
+- `NIP-47 notification event`: 23197 (23196 for backwards compatibility with NIP-04)
 ### Info Event
@@ -46,34 +47,71 @@ The content should be a plaintext string with the supported capabilities space-s
 If the **wallet service** supports notifications, the info event SHOULD contain a `notifications` tag with the supported notification types space-separated, eg. `payment_received payment_sent`.
+It should also contain supported encryption modes as described in the [Encryption](#encryption) section. For example:
+```jsonc
+{
+    "kind": 13194,
+    "tags": [
+        ["encryption", "nip44_v2 nip04"], // List of supported encryption schemes as described in the Encryption section.
+        ["notifications", "payment_received payment_sent"]
+        // ...
+    ],
+    "content": "pay_invoice get_balance make_invoice lookup_invoice list_transactions get_info notifications",
+    // ...
+}
+```
 ### Request and Response Events
 Both the request and response events SHOULD contain one `p` tag, containing the public key of the **wallet service** if this is a request, and the public key of the **client** if this is a response. The response event SHOULD contain an `e` tag with the id of the request event it is responding to.
 Optionally, a request can have an `expiration` tag that has a unix timestamp in seconds. If the request is received after this timestamp, it should be ignored.
-The content of requests and responses is encrypted with [NIP04](04.md), and is a JSON-RPCish object with a semi-fixed structure:
+The content of requests and responses is encrypted with [NIP44](44.md), and is a JSON-RPCish object with a semi-fixed structure.
-Request:
+**Important note for backwards-compatibility:** The initial version of the protocol used [NIP04](04.md). If a **wallet service** or client app does not include the `encryption` tag in the
-```jsonc
+`info` or request events, it should be assumed that the connection is using NIP04 for encryption. See the [Encryption](#encryption) section for more information.
+Example request:
+```js
 {
-    "method": "pay_invoice", // method, string
+    "kind" 23194,
-    "params": { // params, object
+    "tags": [
-        "invoice": "lnbc50n1..." // command-related data
+        ["encryption", "nip44_v2"],
-    }
+        ["p", "03..." ] // public key of the wallet service.
+        // ...
+    ],
+    "content": nip44_encrypt({ // Encryption type corresponds to the `encryption` tag.
+        "method": "pay_invoice", // method, string
+        "params": { // params, object
+            "invoice": "lnbc50n1..." // command-related data
+        }
+    }),
 }
 ```
-Response:
+Example response:
-```jsonc
+```js
 {
-    "result_type": "pay_invoice", //indicates the structure of the result field
+    "kind" 23195,
-    "error": { //object, non-null in case of error
+    "tags": [
-        "code": "UNAUTHORIZED", //string error code, see below
+        ["p", "03..." ] // public key of the requesting client app
-        "message": "human readable error message"
+        ["e", "1234"] // id of the request event this is responding to
-    },
+        // ...
-    "result": { // result, object. null in case of error.
+    ],
-        "preimage": "0123456789abcdef..." // command-related data
+    "content": nip44_encrypt({ // Encrypted using the scheme requested by the client.
-    }
+        "result_type": "pay_invoice", //indicates the structure of the result field
+        "error": { //object, non-null in case of error
+            "code": "UNAUTHORIZED", //string error code, see below
+            "message": "human readable error message"
+        },
+        "result": { // result, object. null in case of error.
+            "preimage": "0123456789abcdef..." // command-related data
+        }
+    })
+    // ...
 }
 ```
@@ -83,9 +121,9 @@ If the command was successful, the `error` field must be null.
 ### Notification Events
-The notification event SHOULD contain one `p` tag, the public key of the **client**.
+The notification event is a kind 23197 event SHOULD contain one `p` tag, the public key of the **client**.
-The content of notifications is encrypted with [NIP04](04.md), and is a JSON-RPCish object with a semi-fixed structure:
+The content of notifications is encrypted with [NIP44](44.md) (or NIP-04 for legacy client apps), and is a JSON-RPCish object with a semi-fixed structure:
 ```jsonc
 {
@@ -96,7 +134,6 @@ The content of notifications is encrypted with [NIP04](04.md), and is a JSON-RPC
 }
 ```
 ### Error codes
 - `RATE_LIMITED`: The client is sending commands too fast. It should retry in a few seconds.
 - `NOT_IMPLEMENTED`: The command is not known or is intentionally not implemented.
@@ -105,6 +142,7 @@ The content of notifications is encrypted with [NIP04](04.md), and is a JSON-RPC
 - `RESTRICTED`: This public key is not allowed to do this operation.
 - `UNAUTHORIZED`: This public key has no wallet connected.
 - `INTERNAL`: An internal error.
+- `UNSUPPORTED_ENCRYPTION`: The encryption type of the request is not supported by the wallet service.
 - `OTHER`: Other error.
 ## Nostr Wallet Connect URI
@@ -148,6 +186,7 @@ Request:
    "params": {
        "invoice": "lnbc50n1...", // bolt11 invoice
        "amount": 123, // invoice amount in msats, optional
+        "metadata": {} // generic metadata that can be used to add things like zap/boostagram details for a payer name/comment/etc, optional
    }
 }
 ```
@@ -166,42 +205,6 @@ Response:
 Errors:
 - `PAYMENT_FAILED`: The payment failed. This may be due to a timeout, exhausting all routes, insufficient capacity or similar.
-### `multi_pay_invoice`
-Description: Requests payment of multiple invoices.
-Request:
-```jsonc
-{
-    "method": "multi_pay_invoice",
-    "params": {
-        "invoices": [
-          {"id":"4da52c32a1", "invoice": "lnbc1...", "amount": 123}, // bolt11 invoice and amount in msats, amount is optional
-          {"id":"3da52c32a1", "invoice": "lnbc50n1..."},
-        ],
-    }
-}
-```
-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
-payment hash of the invoice should be used.
-```jsonc
-{
-    "result_type": "multi_pay_invoice",
-    "result": {
-        "preimage": "0123456789abcdef...", // preimage of the payment
-        "fees_paid": 123, // value in msats, optional
-    }
-}
-```
-Errors:
- `PAYMENT_FAILED`: The payment failed. This may be due to a timeout, exhausting all routes, insufficient capacity or similar.
 ### `pay_keysend`
 Request:
@@ -236,44 +239,6 @@ Response:
 Errors:
 - `PAYMENT_FAILED`: The payment failed. This may be due to a timeout, exhausting all routes, insufficient capacity or similar.
-### `multi_pay_keysend`
-Description: Requests multiple keysend payments.
-Has an array of keysends, these follow the same semantics as `pay_keysend`, just done in a batch
-Request:
-```jsonc
-{
-    "method": "multi_pay_keysend",
-    "params": {
-        "keysends": [
-          {"id": "4c5b24a351", "pubkey": "03...", "amount": 123},
-          {"id": "3da52c32a1", "pubkey": "02...", "amount": 567, "preimage": "abc123..", "tlv_records": [{"type": 696969, "value": "77616c5f6872444873305242454d353736"}]},
-        ],
-    }
-}
-```
-Response:
-For every keysend 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 keysend it is responding to; if no id was given, then the
-pubkey should be used.
-```jsonc
-{
-    "result_type": "multi_pay_keysend",
-    "result": {
-        "preimage": "0123456789abcdef...", // preimage of the payment
-        "fees_paid": 123, // value in msats, optional
-    }
-}
-```
-Errors:
- `PAYMENT_FAILED`: The payment failed. This may be due to a timeout, exhausting all routes, insufficient capacity or similar.
 ### `make_invoice`
 Request:
@@ -284,7 +249,8 @@ Request:
        "amount": 123, // value in msats
        "description": "string", // invoice's description, optional
        "description_hash": "string", // invoice's description hash, optional
-        "expiry": 213 // expiry in seconds from time invoice is created, optional
+        "expiry": 213, // expiry in seconds from time invoice is created, optional
+        "metadata": {} // generic metadata that can be used to add things like zap/boostagram details for a payer name/comment/etc, optional
    }
 }
 ```
@@ -295,6 +261,7 @@ Response:
    "result_type": "make_invoice",
    "result": {
        "type": "incoming", // "incoming" for invoices, "outgoing" for payments
+        "state": "pending", // optional
        "invoice": "string", // encoded invoice, optional
        "description": "string", // invoice's description, optional
        "description_hash": "string", // invoice's description hash, optional
@@ -328,6 +295,7 @@ Response:
    "result_type": "lookup_invoice",
    "result": {
        "type": "incoming", // "incoming" for invoices, "outgoing" for payments
+        "state": "pending", // can be "pending", "settled", "accepted" (for hold invoices), "expired" (for invoices) or "failed" (for payments), optional
        "invoice": "string", // encoded invoice, optional
        "description": "string", // invoice's description, optional
        "description_hash": "string", // invoice's description hash, optional
@@ -376,6 +344,7 @@ Response:
        "transactions": [
            {
               "type": "incoming", // "incoming" for invoices, "outgoing" for payments
+               "state": "pending", // can be "pending", "settled", "accepted" (for hold invoices), "expired" (for invoices) or "failed" (for payments), optional
               "invoice": "string", // encoded invoice, optional
               "description": "string", // invoice's description, optional
               "description_hash": "string", // invoice's description hash, optional
@@ -440,6 +409,89 @@ Response:
 }
 ```
+### `make_hold_invoice`
+Creates a hold invoice using a pre-generated preimage.
+Request:
+```jsonc
+{
+    "method": "make_hold_invoice",
+    "params": {
+        "amount": 123, // value in msats
+        "description": "string", // invoice's description, optional
+        "description_hash": "string", // invoice's description hash, optional
+        "expiry": 213 // expiry in seconds from time invoice is created for a payment to be initiated, optional. This does not determine how long a payment can be held (see `settle_deadline`)
+        "payment_hash": "string" // Payment hash for the payment generated from the preimage
+        "min_cltv_expiry_delta": 144 // The minimum CLTV delta to use for the final hop, optional
+    }
+}
+```
+Response:
+```jsonc
+{
+    "result_type": "make_hold_invoice",
+    "result": {
+        "type": "incoming", // "incoming" for invoices, "outgoing" for payments
+        "invoice": "string", // encoded invoice, optional
+        "description": "string", // invoice's description, optional
+        "description_hash": "string", // invoice's description hash, optional
+        "payment_hash": "string", // Payment hash for the payment
+        "amount": 123, // value in msats
+        "created_at": unixtimestamp, // invoice/payment creation time
+        "expires_at": unixtimestamp, // invoice expiration time, optional if not applicable
+        "metadata": {} // generic metadata that can be used to add things like zap/boostagram details for a payer name/comment/etc.
+    }
+}
+```
+### `cancel_hold_invoice`
+Cancels a hold invoice using the payment hash
+Request:
+```jsonc
+{
+    "method": "cancel_hold_invoice",
+    "params": {
+        "payment_hash": "string" // Payment hash for the payment generated from the preimage
+    }
+}
+```
+Response:
+```jsonc
+{
+    "result_type": "cancel_hold_invoice",
+    "result": {}
+}
+```
+### `settle_hold_invoice`
+Settles a hold invoice using the preimage
+Request:
+```jsonc
+{
+    "method": "settle_hold_invoice",
+    "params": {
+        "preimage": "string" // preimage for the payment
+    }
+}
+```
+Response:
+```jsonc
+{
+    "result_type": "settle_hold_invoice",
+    "result": {}
+}
+```
 ## Notifications
 ### `payment_received`
@@ -452,6 +504,7 @@ Notification:
    "notification_type": "payment_received",
    "notification": {
        "type": "incoming",
+        "state": "settled", // optional
        "invoice": "string", // encoded invoice
        "description": "string", // invoice's description, optional
        "description_hash": "string", // invoice's description hash, optional
@@ -477,6 +530,7 @@ Notification:
    "notification_type": "payment_sent",
    "notification": {
        "type": "outgoing",
+        "state": "settled", // optional
        "invoice": "string", // encoded invoice
        "description": "string", // invoice's description, optional
        "description_hash": "string", // invoice's description hash, optional
@@ -492,6 +546,30 @@ Notification:
 }
 ```
+### `hold_invoice_accepted`
+Description: Sent when a payer accepts (locks in) a hold invoice. To avoid locking up funds in channels the hold invoice SHOULD be settled or canceled within a few minutes of receiving this event.
+Notification:
+```jsonc
+{
+    "notification_type": "hold_invoice_accepted",
+    "notification": {
+        "type": "incoming",
+        "state": "accepted",  // optional
+        "invoice": "string", // encoded invoice
+        "description": "string", // invoice's description, optional
+        "description_hash": "string", // invoice's description hash, optional
+        "payment_hash": "string", // Payment hash for the payment
+        "amount": 123, // value in msats
+        "created_at": unixtimestamp, // invoice/payment creation time
+        "expires_at": unixtimestamp, // invoice expiration time
+        "settle_deadline": blocknumber, // invoice can only be safely settled or canceled before this block number.
+        "metadata": {} // generic metadata that can be used to add things like zap/boostagram details for a payer name/comment/etc.
+    }
+}
+```
 ## Example pay invoice flow
 0. The user scans the QR code generated by the **wallet service** with their **client** application, they follow a `nostr+walletconnect://` deeplink or configure the connection details manually.
@@ -499,9 +577,89 @@ Notification:
 2. **wallet service** verifies that the author's key is authorized to perform the payment, decrypts the payload and sends the payment.
 3. **wallet service** responds to the event by sending an event with kind `23195` and content being a response either containing an error message or a preimage.
+## Encryption
+The initial version of NWC used [NIP-04](04.md) for encryption which has been deprecated and replaced by [NIP-44](44.md). NIP-44 should always be preferred for encryption, but there may be legacy cases
+where the **wallet service** or **client** has not yet migrated to NIP-44. The **wallet service** and **client** should negotiate the encryption method to use based on the `encryption` tag in the `info` event.
+The encryption tag can contain either `nip44_v2` or `nip04`. The absence of this tag implies that the wallet only supports `nip04`.
+| Encryption code | Use                  | Notes                                                   |
+|-----------------|----------------------|---------------------------------------------------------|
+| `nip44_v2`      | NIP-44               | Required                                                |
+| `nip04`         | NIP-04               | Deprecated and only here for backward compatibility     |
+| `<not present>` | NIP-04               | Deprecated and only here for backward compatibility     |
+The negotiation works as follows.
+1. The **wallet service** includes an `encryption` tag in the `info` event. This tag contains a space-separated list of encryption schemes that the **wallet service** supports (eg. `nip44_v2 nip04`)
+2. The **client application** includes an `encryption` tag in each request event. This tag contains the encryption scheme which should be used for the request. The **client application** should always prefer nip44 if supported by the **wallet service**.
+When a **client application** establishes a connection, it should read the info event and look for the `encryption` tag.
+**Absence of this tag implies that the wallet only supports nip04.**
+If the `encryption` tag is present, the **client application** will choose optimal encryption supported by both itself, and the **wallet service**, which should always be nip44 if possible.
+### Request events
+When a **client application** sends a request event, it should include a `encryption` tag with the encryption scheme it is using. The scheme MUST be supported by the **wallet service** as indicated by the info event.
+For example, if the client application supports nip44, the request event might look like:
+```jsonc
+{
+    "kind": 23194,
+    "tags": [
+        ["encryption", "nip44_v2"],
+        // ...
+    ],
+    // ...
+}
+```
+If the **wallet service** does not support the specified encryption scheme, it will return an `UNSUPPORTED_ENCRYPTION` error. Absence of the `encryption` tag indicates use of nip04 for encryption.
+### Notification events
+If a **wallet service** supports both nip04 and nip44, it should publish two notification events for each notification - kind 23196 encrypted with NIP-04, and kind 23197 encrypted with NIP-44. If the **wallet service** only supports nip44, it should only publish kind 23197 events.
+The **client** should check the `encryption` tag in the `info` event to determine which encryption schemes the **wallet service** supports, and listen to the appropriate notification event.
 ## Using a dedicated relay
 This NIP does not specify any requirements on the type of relays used. However, if the user is using a custodial service it might make sense to use a relay that is hosted by the custodial service. The relay may then enforce authentication to prevent metadata leaks. Not depending on a 3rd party relay would also improve reliability in this case.
+## Metadata
+Metadata MAY be stored by the **wallet service** alongside invoices and payments. The metadata MUST be no more than 4096 characters, otherwise MUST be dropped. This is to ensure transactions do not get too large to be relayed.
+NWC relays SHOULD allow at least a payload size of 64KB and **clients** SHOULD fetch small page sizes (maximum of 20 transactions per page) otherwise there is risk of `list_transactions` responses being rejected.
+Here are some properties that are recognized by some NWC clients:
+```jsonc
+{
+  "comment": "string", // LUD-12 comment
+  "payer_data": {
+    "email": "string",
+    "name": "string",
+    "pubkey": "string",
+  }, // LUD-18 payer data
+  "recipient_data": {
+    "identifier": "string"
+  }, // similar to LUD-18 payer data, but to record recipient data e.g. the lightning address of the recipient
+  "nostr": {
+    "pubkey": "string",
+    "tags": [],
+    // ... rest of zap request event
+  }, // NIP-57 Zap Request event (kind 9734)
+  "tlv_records": [
+    {
+      "type": 5482373484, // tlv type
+      "value": "0123456789abcdef" // hex encoded tlv value
+    }
+  ] // keysend TLV records (e.g. for podcasting 2.0 boostagrams)
+} & Record<string, unknown>;
+```
 ## Appendix
 ### Example NIP-47 info event
@@ -513,6 +671,7 @@ This NIP does not specify any requirements on the type of relays used. However,
  "created_at": 1713883677,
  "kind": 13194,
  "tags": [
+    [ "encryption", "nip44_v2 nip04" ],
    [
      "notifications",
      "payment_received payment_sent"
@@ -522,3 +681,30 @@ This NIP does not specify any requirements on the type of relays used. However,
  "sig": "31f57b369459b5306a5353aa9e03be7fbde169bc881c3233625605dd12f53548179def16b9fe1137e6465d7e4d5bb27ce81fd6e75908c46b06269f4233c845d8"
 }
 ```
+### Example Hold Invoice Support Flow
+1. Client generates a 32-byte hex-encoded preimage.
+2. Computes SHA-256 to derive payment hash.
+3. Sends `make_hold_invoice` with payment hash and desired parameters.
+4. Waits for `hold_invoice_accepted` notification.
+5. Upon receiving notification, either:
+   * Calls `settle_hold_invoice` with the original preimage to release funds, or
+   * Calls `cancel_hold_invoice` with payment hash to abort.
+### Deep-links
+Wallet applications can register deeplinks in mobile systems to make it possible to create a linking UX that doesn't require the user scanning a QR code or pasting some code.
+`nostrnwc://connect` and `nostrnwc+{app_name}://connect` can be registered by wallet apps and queried by apps that want to receive an NWC pairing code.
+All URI parameters, MUST be URI-encoded.
+URI parameters:
+ * `appicon` -- URL to an icon of the client that wants to create a connection.
+ * `appname` -- Name of the client that wants to create a connection.
+ * `callback` -- URI schema the wallet should open with the connection string
+Once a connection has been created by the wallet, it should be returned to the client by opening the callback with the following parameters
+ * `value` -- NWC pairing code (e.g. `nostr+walletconnect://...`)
diff --git a/50.md b/50.md
index 9eea1f8..08ce4fd 100644
--- a/50.md
+++ b/50.md
@@ -4,7 +4,7 @@ NIP-50
 Search Capability
 -----------------
-`draft` `optional`
+`draft` `optional` `relay`
 ## Abstract
diff --git a/51.md b/51.md
index 5583435..f9d6e56 100644
--- a/51.md
+++ b/51.md
@@ -8,7 +8,7 @@ Lists
 This NIP defines lists of things that users can create. Lists can contain references to anything, and these references can be **public** or **private**.
-Public items in a list are specified in the event `tags` array, while private items are specified in a JSON array that mimics the structure of the event `tags` array, but stringified and encrypted using the same scheme from [NIP-04](04.md) (the shared key is computed using the author's public and private key) and stored in the `.content`.
+Public items in a list are specified in the event `tags` array, while private items are specified in a JSON array that mimics the structure of the event `tags` array, but stringified and encrypted using the same scheme from [NIP-44](44.md) (the shared key is computed using the author's public and private key) and stored in the `.content`. An earlier version of this specification used [NIP-04](04.md) for encryptions. Those are now deprecated. For backward compatibility, Clients can automatically discover if the encryption is NIP-04 or NIP-44 by searching for "iv" in the ciphertext and decrypting accordingly.
 When new items are added to an existing list, clients SHOULD append them to the end of the list, so they are stored in chronological order.
@@ -22,16 +22,19 @@ For example, _mute list_ can contain the public keys of spammers and bad actors
 | name              | kind  | description                                                 | expected tag items                                                                                  |
 | ---               | ---   | ---                                                         | ---                                                                                                 |
+| Follow list       |     3 | microblogging basic follow list, see [NIP-02](02.md)        | `"p"` (pubkeys -- with optional relay hint and petname)                                             |
 | Mute list         | 10000 | things the user doesn't want to see in their feeds          | `"p"` (pubkeys), `"t"` (hashtags), `"word"` (lowercase string), `"e"` (threads)                     |
 | Pinned notes      | 10001 | events the user intends to showcase in their profile page   | `"e"` (kind:1 notes)                                                                                |
 | Read/write relays | 10002 | where a user publishes to and where they expect mentions    | see [NIP-65](65.md)                                                                                 |
-| Bookmarks         | 10003 | uncategorized, "global" list of things a user wants to save | `"e"` (kind:1 notes), `"a"` (kind:30023 articles), `"t"` (hashtags), `"r"` (URLs)                   |
+| Bookmarks         | 10003 | uncategorized, "global" list of things a user wants to save | `"e"` (kind:1 notes), `"a"` (kind:30023 articles)                   |
 | Communities       | 10004 | [NIP-72](72.md) communities the user belongs to             | `"a"` (kind:34550 community definitions)                                                            |
 | Public chats      | 10005 | [NIP-28](28.md) chat channels the user is in                | `"e"` (kind:40 channel definitions)                                                                 |
 | Blocked relays    | 10006 | relays clients should never connect to                      | `"relay"` (relay URLs)                                                                              |
 | Search relays     | 10007 | relays clients should use when performing search queries    | `"relay"` (relay URLs)                                                                              |
 | Simple groups     | 10009 | [NIP-29](29.md) groups the user is in                       | `"group"` ([NIP-29](29.md) group id + relay URL + optional group name), `"r"` for each relay in use |
+| Relay feeds       | 10012 | user favorite browsable relays (and relay sets)             | `"relay"` (relay URLs) and `"a"` (kind:30002 relay set)                                             |
 | Interests         | 10015 | topics a user may be interested in and pointers             | `"t"` (hashtags) and `"a"` (kind:30015 interest set)                                                |
+| Media follows     | 10020 | multimedia (photos, short video) follow list                | `"p"` (pubkeys -- with optional relay hint and petname)                                             |
 | Emojis            | 10030 | user preferred emojis and pointers to emoji sets            | `"emoji"` (see [NIP-30](30.md)) and `"a"` (kind:30030 emoji set)                                    |
 | DM relays         | 10050 | Where to receive [NIP-17](17.md) direct messages            | `"relay"` (see [NIP-17](17.md))                                                                     |
 | Good wiki authors | 10101 | [NIP-54](54.md) user recommended wiki authors               | `"p"` (pubkeys)                                                                                     |
@@ -49,14 +52,18 @@ Aside from their main identifier, the `"d"` tag, sets can optionally have a `"ti
 | ---                   | ---   | ---                                                                                          | ---                                                                                 |
 | Follow sets           | 30000 | categorized groups of users a client may choose to check out in different circumstances      | `"p"` (pubkeys)                                                                     |
 | Relay sets            | 30002 | user-defined relay groups the user can easily pick and choose from during various operations | `"relay"` (relay URLs)                                                              |
-| Bookmark sets         | 30003 | user-defined bookmarks categories , for when bookmarks must be in labeled separate groups    | `"e"` (kind:1 notes), `"a"` (kind:30023 articles), `"t"` (hashtags), `"r"` (URLs)   |
+| Bookmark sets         | 30003 | user-defined bookmarks categories , for when bookmarks must be in labeled separate groups    | `"e"` (kind:1 notes), `"a"` (kind:30023 articles)                                   |
 | Curation sets         | 30004 | groups of articles picked by users as interesting and/or belonging to the same category      | `"a"` (kind:30023 articles), `"e"` (kind:1 notes)                                   |
-| Curation sets         | 30005 | groups of videos picked by users as interesting and/or belonging to the same category        | `"a"` (kind:21 videos)                                                              |
+| Curation sets         | 30005 | groups of videos picked by users as interesting and/or belonging to the same category        | `"e"` (kind:21 videos)                                                              |
+| Curation sets         | 30006 | groups of pictures picked by users as interesting and/or belonging to the same category      | `"e"` (kind:20 pictures)                                                            |
 | Kind mute sets        | 30007 | mute pubkeys by kinds<br>`"d"` tag MUST be the kind string                                   | `"p"` (pubkeys)                                                                     |
 | Interest sets         | 30015 | interest topics represented by a bunch of "hashtags"                                         | `"t"` (hashtags)                                                                    |
 | Emoji sets            | 30030 | categorized emoji groups                                                                     | `"emoji"` (see [NIP-30](30.md))                                                     |
 | Release artifact sets | 30063 | group of artifacts of a software release                                                     | `"e"` (kind:1063 [file metadata](94.md) events), `"a"` (software application event) |
 | App curation sets     | 30267 | references to multiple software applications                                                 | `"a"` (software application event)                                                  |
+| Calendar              | 31924 | a set of events categorized in any way                                                       | `"a"` (calendar event event)                                                        |
+| Starter packs         | 39089 | a named set of profiles to be shared around with the goal of being followed together         | `"p"` (pubkeys)                                                                     |
+| Media starter packs   | 39092 | same as above, but specific to multimedia (photos, short video) clients                      | `"p"` (pubkeys)                                                                     |
 ### Deprecated standard lists
@@ -98,9 +105,9 @@ Some clients have used these lists in the past, but they should work on transiti
  "kind": 30004,
  "tags": [
    ["d", "jvdy9i4"],
-    ["name", "Yaks"],
+    ["title", "Yaks"],
-    ["picture", "https://cdn.britannica.com/40/188540-050-9AC748DE/Yak-Himalayas-Nepal.jpg"],
+    ["image", "https://cdn.britannica.com/40/188540-050-9AC748DE/Yak-Himalayas-Nepal.jpg"],
-    ["about", "The domestic yak, also known as the Tartary ox, grunting ox, or hairy cattle, is a species of long-haired domesticated cattle found throughout the Himalayan region of the Indian subcontinent, the Tibetan Plateau, Gilgit-Baltistan, Tajikistan and as far north as Mongolia and Siberia."],
+    ["description", "The domestic yak, also known as the Tartary ox, grunting ox, or hairy cattle, is a species of long-haired domesticated cattle found throughout the Himalayan region of the Indian subcontinent, the Tibetan Plateau, Gilgit-Baltistan, Tajikistan and as far north as Mongolia and Siberia."],
    ["a", "30023:26dc95542e18b8b7aec2f14610f55c335abebec76f3db9e58c254661d0593a0c:95ODQzw3ajNoZ8SyMDOzQ"],
    ["a", "30023:54af95542e18b8b7aec2f14610f55c335abebec76f3db9e58c254661d0593a0c:1-MYP8dAhramH9J5gJWKx"],
    ["a", "30023:f8fe95542e18b8b7aec2f14610f55c335abebec76f3db9e58c254661d0593a0c:D2Tbd38bGrFvU0bIbvSMt"],
@@ -128,7 +135,6 @@ Some clients have used these lists in the past, but they should work on transiti
    ["e", "340e0326b340e0326b4941ed78ba340e0326b4941ed78ba340e0326b49ed78ba"], // PWA
    ["a", "32267:d6dc95542e18b8b7aec2f14610f55c335abebec76f3db9e58c254661d0593a0c:com.example.app"] // Reference to parent software application
  ],
-  "content": "Example App is a decentralized marketplace for apps",
  "sig": "a9a4e2192eede77e6c9d24ddfab95ba3ff7c03fbd07ad011fff245abea431fb4d3787c2d04aad001cb039cb8de91d83ce30e9a94f82ac3c5a2372aa1294a96bd"
 }
 ```
@@ -159,6 +165,6 @@ val private_items = [
  ["p", "07caba282f76441955b695551c3c5c742e5b9202a3784780f8086fdcdc1da3a9"],
  ["a", "a55c15f5e41d5aebd236eca5e0142789c5385703f1a7485aa4b38d94fd18dcc4"],
 ]
-val base64blob = nip04.encrypt(json.encode_to_string(private_items))
+val base64blob = nip44.encrypt(json.encode_to_string(private_items))
 event.content = base64blob
 ```
diff --git a/52.md b/52.md
index cc2625a..060b38f 100644
--- a/52.md
+++ b/52.md
@@ -12,63 +12,71 @@ Unlike the term `calendar event` specific to this NIP, the term `event` is used
 ## Calendar Events
-There are two types of calendar events represented by different kinds: date-based and time-based calendar events. Calendar events are not required to be part of a [calendar](#calendar).
+There are two types of calendar events represented by different kinds: _date-based_ and _time-based_ calendar events.
-### Date-Based Calendar Event
+These tags are common to both types of calendar events:
-This kind of calendar event starts on a date and ends before a different date in the future. Its use is appropriate for all-day or multi-day events where time and time zone hold no significance. e.g., anniversary, public holidays, vacation days.
-#### Format
-The format uses an _addressable event_ of `kind:31922`.
-The `.content` of these events should be a detailed description of the calendar event. It is required but can be an empty string.
-The list of tags are as follows:
+* `d` (required) a short unique string identifier. Generated by the client creating the calendar event.
-* `d` (required) universally unique identifier (UUID). Generated by the client creating the calendar event.
 * `title` (required) title of the calendar event
-* `start` (required) inclusive start date in ISO 8601 format (YYYY-MM-DD). Must be less than `end`, if it exists.
+* `summary` (optional) brief description of the calendar event
-* `end` (optional) exclusive end date in ISO 8601 format (YYYY-MM-DD). If omitted, the calendar event ends on the same date as `start`.
+* `image` (optional) url of an image to use for the event
 * `location` (optional, repeated) location of the calendar event. e.g. address, GPS coordinates, meeting room name, link to video call
 * `g` (optional) [geohash](https://en.wikipedia.org/wiki/Geohash) to associate calendar event with a searchable physical location
 * `p` (optional, repeated) 32-bytes hex pubkey of a participant, optional recommended relay URL, and participant's role in the meeting
 * `t` (optional, repeated) hashtag to categorize calendar event
 * `r` (optional, repeated) references / links to web pages, documents, video calls, recorded videos, etc.
+* `a` (repeated) reference tag to kind `31924` calendar event requesting to be included in Calendar
 The following tags are deprecated:
 * `name` name of the calendar event. Use only if `title` is not available.
-```jsonc
+Calendar events are _not_ required to be part of a [calendar](#calendar).
+## Collaborative Calendar Event Requests
+Calendar events can include an `a` tag referencing a calendar (kind 31924) to request addition to that calendar. When a calendar event includes such a reference, clients should interpret this as a request to add the event to the referenced calendar by referencing it with an `a` tag.
+This enables collaborative calendar management where multiple users can contribute events to calendars they do not own, subject to the calendar owner's approval.
+### Date-Based Calendar Event
+This kind of calendar event starts on a date and ends before a different date in the future. Its use is appropriate for all-day or multi-day events where time and time zone hold no significance. e.g., anniversary, public holidays, vacation days.
+It's an _addressable event_ of `kind:31922`.
+The `.content` of these events SHOULD be a description of the calendar event.
+Aside from the common tags, this also takes the following tags:
+* `start` (required) inclusive start date in ISO 8601 format (YYYY-MM-DD). Must be less than `end`, if it exists.
+* `end` (optional) exclusive end date in ISO 8601 format (YYYY-MM-DD). If omitted, the calendar event ends on the same date as `start`.
+Example:
+```yaml
 {
-  "id": <32-bytes lowercase hex-encoded SHA-256 of the the serialized event data>,
+  "id": <32-bytes lowercase hex-encoded SHA-256 of the serialized event data>,
  "pubkey": <32-bytes lowercase hex-encoded public key of the event creator>,
-  "created_at": <Unix timestamp in seconds>,
+  "created_at": <unix timestamp in seconds>,
  "kind": 31922,
  "content": "<description of calendar event>",
  "tags": [
-    ["d", "<UUID>"],
+    ["d", "<random-identifier>"],
    ["title", "<title of calendar event>"],
-    // Dates
+    // dates
    ["start", "<YYYY-MM-DD>"],
    ["end", "<YYYY-MM-DD>"],
-    // Location
+    // location
    ["location", "<location>"],
    ["g", "<geohash>"],
-    // Participants
+    // participants
    ["p", "<32-bytes hex of a pubkey>", "<optional recommended relay URL>", "<role>"],
    ["p", "<32-bytes hex of a pubkey>", "<optional recommended relay URL>", "<role>"],
-    // Hashtags
-    ["t", "<tag>"],
-    ["t", "<tag>"],
-    // Reference links
-    ["r", "<url>"],
-    ["r", "<url>"]
  ]
 }
 ```
@@ -77,97 +85,72 @@ The following tags are deprecated:
 This kind of calendar event spans between a start time and end time.
-#### Format
+It's an _addressable event_ of `kind:31923`.
-The format uses an _addressable event_ kind `31923`.
+The `.content` of these events should be a description of the calendar event. It is required but can be an empty string.
-The `.content` of these events should be a detailed description of the calendar event. It is required but can be an empty string.
+Aside from the common tags, this also takes the following tags:
-The list of tags are as follows:
-* `d` (required) universally unique identifier (UUID). Generated by the client creating the calendar event.
-* `title` (required) title of the calendar event
 * `start` (required) inclusive start Unix timestamp in seconds. Must be less than `end`, if it exists.
 * `end` (optional) exclusive end Unix timestamp in seconds. If omitted, the calendar event ends instantaneously.
 * `start_tzid` (optional) time zone of the start timestamp, as defined by the IANA Time Zone Database. e.g., `America/Costa_Rica`
 * `end_tzid` (optional) time zone of the end timestamp, as defined by the IANA Time Zone Database. e.g., `America/Costa_Rica`. If omitted and `start_tzid` is provided, the time zone of the end timestamp is the same as the start timestamp.
-* `summary` (optional) brief description of the calendar event
+* `D` (required) the day-granularity unix timestamp on which the event takes place, calculated as `floor(unix_seconds() / seconds_in_one_day)`. Multiple tags SHOULD be included to cover the event's timeframe.
-* `image` (optional) url of an image to use for the event
-* `location` (optional, repeated) location of the calendar event. e.g. address, GPS coordinates, meeting room name, link to video call
-* `g` (optional) [geohash](https://en.wikipedia.org/wiki/Geohash) to associate calendar event with a searchable physical location
-* `p` (optional, repeated) 32-bytes hex pubkey of a participant, optional recommended relay URL, and participant's role in the meeting
-* `l` (optional, repeated) label to categorize calendar event. e.g. `audiospace` to denote a scheduled event from a live audio space implementation such as cornychat.com
-* `t` (optional, repeated) hashtag to categorize calendar event
-* `r` (optional, repeated) references / links to web pages, documents, video calls, recorded videos, etc.
-The following tags are deprecated:
-* `name` name of the calendar event. Use only if `title` is not available.
-```jsonc
+```yaml
 {
  "id": <32-bytes lowercase hex-encoded SHA-256 of the the serialized event data>,
  "pubkey": <32-bytes lowercase hex-encoded public key of the event creator>,
-  "created_at": <Unix timestamp in seconds>,
+  "created_at": <unix timestamp in seconds>,
  "kind": 31923,
  "content": "<description of calendar event>",
  "tags": [
-    ["d", "<UUID>"],
+    ["d", "<random-identifier>"],
    ["title", "<title of calendar event>"],
    ["summary", "<brief description of the calendar event>"],
    ["image", "<string with image URI>"],
-    // Timestamps
+    // timestamps
-    ["start", "<Unix timestamp in seconds>"],
+    ["start", "<unix timestamp in seconds>"],
-    ["end", "<Unix timestamp in seconds>"],
+    ["end", "<unix timestamp in seconds>"],
+    ["D", "82549"],
    ["start_tzid", "<IANA Time Zone Database identifier>"],
    ["end_tzid", "<IANA Time Zone Database identifier>"],
-    // Location
+    // location
    ["location", "<location>"],
    ["g", "<geohash>"],
-    // Participants
+    // participants
    ["p", "<32-bytes hex of a pubkey>", "<optional recommended relay URL>", "<role>"],
    ["p", "<32-bytes hex of a pubkey>", "<optional recommended relay URL>", "<role>"],
-    // Labels (example using com.cornychat namespace denoting the event as an audiospace)
-    ["L", "com.cornychat"],
-    ["l", "audiospace", "com.cornychat"],
-    // Hashtags
-    ["t", "<tag>"],
-    ["t", "<tag>"],
-    // Reference links
-    ["r", "<url>"],
-    ["r", "<url>"]
  ]
 }
 ```
 ## Calendar
-A calendar is a collection of calendar events, represented as a custom replaceable list event using kind `31924`. A user can have multiple calendars. One may create a calendar to segment calendar events for specific purposes. e.g., personal, work, travel, meetups, and conferences.
+A calendar is a collection of calendar events, represented as a custom _addressable list_ event using kind `31924`. A user can have multiple calendars. One may create a calendar to segment calendar events for specific purposes. e.g., personal, work, travel, meetups, and conferences.
-### Format
+Calendars can accept event requests from other users. When calendar events reference a calendar via an `a` tag, this represents a request for inclusion.
 The `.content` of these events should be a detailed description of the calendar. It is required but can be an empty string.
-The format uses a custom replaceable list of kind `31924` with a list of tags as described below:
 * `d` (required) universally unique identifier. Generated by the client creating the calendar.
 * `title` (required) calendar title
 * `a` (repeated) reference tag to kind `31922` or `31923` calendar event being responded to
-```json
+```yaml
 {
  "id": <32-bytes lowercase hex-encoded SHA-256 of the the serialized event data>,
  "pubkey": <32-bytes lowercase hex-encoded public key of the event creator>,
-  "created_at": <Unix timestamp in seconds>,
+  "created_at": <unix timestamp in seconds>,
  "kind": 31924,
  "content": "<description of calendar>",
  "tags": [
-    ["d", "<UUID>"],
+    ["d", "<random-identifier>"],
    ["title", "<calendar title>"],
    ["a", "<31922 or 31923>:<calendar event author pubkey>:<d-identifier of calendar event>", "<optional relay url>"],
    ["a", "<31922 or 31923>:<calendar event author pubkey>:<d-identifier of calendar event>", "<optional relay url>"]
@@ -191,13 +174,12 @@ The RSVP MUST have an `a` tag of the event coordinates to the calendar event, an
 The RSVP MAY tag the author of the calendar event it is in response to using a `p` tag so that clients can easily query all RSVPs that pertain to the author.
-### Format
+The RSVP is an _addressable event_ of `kind:31925`.
-The format uses an _addressable event_ kind `31925`.
 The `.content` of these events is optional and should be a free-form note that adds more context to this calendar event response.
-The list of tags are as follows:
+The list of tags is as follows:
 * `a` (required) coordinates to a kind `31922` or `31923` calendar event being responded to.
 * `e` (optional) event id of a kind `31922` or `31923` calendar event being responded to.
 * `d` (required) universally unique identifier. Generated by the client creating the calendar event RSVP.
@@ -205,17 +187,17 @@ The list of tags are as follows:
 * `fb` (optional) `free` or `busy`. Determines if the user would be free or busy for the duration of the calendar event. This tag must be omitted or ignored if the `status` label is set to `declined`.
 * `p` (optional) pubkey of the author of the calendar event being responded to.
-```json
+```yaml
 {
  "id": <32-bytes lowercase hex-encoded SHA-256 of the the serialized event data>,
  "pubkey": <32-bytes lowercase hex-encoded public key of the event creator>,
-  "created_at": <Unix timestamp in seconds>,
+  "created_at": <unix timestamp in seconds>,
  "kind": 31925,
  "content": "<note>",
  "tags": [
    ["e", "<kind 31922 or 31923 event id", "<optional recommended relay URL>"]
    ["a", "<31922 or 31923>:<calendar event author pubkey>:<d-identifier of calendar event>", "<optional recommended relay URL>"],
-    ["d", "<UUID>"],
+    ["d", "<random-identifier>"],
    ["status", "<accepted/declined/tentative>"],
    ["fb", "<free/busy>"],
    ["p", "<hex pubkey of kind 31922 or 31923 event>", "<optional recommended relay URL>"]
@@ -223,10 +205,6 @@ The list of tags are as follows:
 }
 ```
-## Unsolved Limitations
-* No private events
 ## Intentionally Unsupported Scenarios
 ### Recurring Calendar Events
diff --git a/53.md b/53.md
index 69d1c9f..a0270e5 100644
--- a/53.md
+++ b/53.md
@@ -6,13 +6,13 @@ Live Activities
 `draft` `optional`
-Service providers want to offer live activities to the Nostr network in such a way that participants can easily log and query by clients. This NIP describes a general framework to advertise the involvement of pubkeys in such live activities.
+This NIP introduces event kinds to advertise live spaces and the participation of pubkeys in them.
-## Concepts
+## Live Streaming
-### Live Event
+A special event with `kind:30311` "Live Streaming Event" is defined as an _addressable event_ whose tags advertise the content and participants of a live stream.
-A special event with `kind:30311` "Live Event" is defined as an _addressable event_ of public `p` tags. Each `p` tag SHOULD have a **displayable** marker name for the current role (e.g. `Host`, `Speaker`, `Participant`) of the user in the event and the relay information MAY be empty. This event will be constantly updated as participants join and leave the activity.
+Each `p` tag SHOULD have a **displayable** marker name for the current role (e.g. `Host`, `Speaker`, `Participant`) of the user in the event and the relay information MAY be empty. This event will be constantly updated as participants join and leave the activity.
 For example:
@@ -63,13 +63,13 @@ This feature is important to avoid malicious event owners adding large account h
 ### Live Chat Message
-Event `kind:1311` is live chat's channel message. Clients MUST include the `a` tag of the activity. An `e` tag denotes the direct parent message this post is replying to. 
+Event `kind:1311` is live chat's channel message. Clients MUST include the `a` tag of the activity. An `e` tag denotes the direct parent message this post is replying to.
 ```jsonc
 {
  "kind": 1311,
  "tags": [
-    ["a", "30311:<Community event author pubkey>:<d-identifier of the community>", "<Optional relay url>", "root"],
+    ["a", "30311:<Community event author pubkey>:<d-identifier of the community>", "<Optional relay url>"],
  ],
  "content": "Zaps to live streams is beautiful.",
  // other fields...
@@ -84,13 +84,9 @@ Event `kind:1311` is live chat's channel message. Clients MUST include the `a` t
 Hosts may choose to pin one or more live chat messages by updating the `pinned` tags in the live event kind `30311`.
-## Use Cases
+### Examples
-Common use cases include meeting rooms/workshops, watch-together activities, or event spaces, such as [zap.stream](https://zap.stream).
+#### Live Streaming
-## Example
-### Live Streaming
 ```json
 {
@@ -114,7 +110,7 @@ Common use cases include meeting rooms/workshops, watch-together activities, or
 }
 ```
-### Live Streaming chat message
+#### Live Streaming chat message
 ```json
 {
@@ -129,3 +125,143 @@ Common use cases include meeting rooms/workshops, watch-together activities, or
  "sig": "997f62ddfc0827c121043074d50cfce7a528e978c575722748629a4137c45b75bdbc84170bedc723ef0a5a4c3daebf1fef2e93f5e2ddb98e5d685d022c30b622"
 }
 ```
+## Meeting Spaces
+Meeting spaces contain one or more video/audio rooms where users can join and participate in the streaming.
+### Meeting Space Event (kind:30312)
+A special event with `kind:30312` "Space Host" defines the configuration and properties of a virtual interactive space. Each space has a unique identifier and can host multiple events/meetings.
+```jsonc
+{
+  "kind": 30312,
+  "tags": [
+    ["d", "<unique identifier>"],              // Required: Room identifier
+    ["room", "<name of the room>"],            // Required: Display name
+    ["summary", "<description>"],              // Optional: Room description
+    ["image", "<preview image url>"],          // Optional: Room image
+    ["status", "<open, private, closed>"],     // Required: Room accessibility
+    ["service", "<url>"],                      // Required: URL to access the room
+    ["endpoint", "<url>"],                     // Optional: API endpoint for status/info
+    ["t", "<hashtag>"],                        // Optional: Multiple hashtags allowed
+    ["p", "<pubkey>", "<url>", "<role>", "<proof>"],  // Required: At least one provider
+    ["relays", "<url>", "<url>", /*...*/]     // Optional: Preferred relays
+  ],
+  "content": ""  // Usually empty, may contain additional metadata
+}
+```
+Space properties:
+* MUST be either open, private or closed. Closed means the room is not in operation.
+* MAY specify access control policy for private rooms (e.g. invite-only, payment required)
+* MAY persist when not in use
+* MUST have at least one provider with "Host" role
+* MAY have multiple providers with different roles
+Provider roles (p tags):
+* Host: Full room management capabilities
+* Moderator: Room moderation capabilities
+* Speaker: Allowed to present/speak
+* Optional proof field for role verification
+### Meeting Room Events (kind:30313)
+A special event with kind:30313 represents a scheduled or ongoing meeting within a room. It MUST reference its parent room using the d tag.
+```jsonc
+{
+  "kind": 30313,
+  "tags": [
+    ["d", "<event-unique-identifier>"],        // Required: Event identifier
+    ["a", "30312:<pubkey>:<room-id>", "wss://nostr.example.com"], // Required: Reference to parent space, 'd' from 30312
+    ["title", "<meeting-title>"],              // Required: Meeting title
+    ["summary", "<description>"],              // Optional: Meeting description
+    ["image", "<preview image url>"],          // Optional: Meeting image
+    ["starts", "<unix timestamp>"],            // Required: Start time
+    ["ends", "<unix timestamp>"],              // Optional: End time
+    ["status", "<planned, live, ended>"],      // Required: Meeting status
+    ["total_participants", "<number>"],        // Optional: Total registered
+    ["current_participants", "<number>"],      // Optional: Currently active
+    ["p", "<pubkey>", "<url>", "<role>"],     // Optional: Participant with role
+  ],
+  "content": ""  // Usually empty, may contain additional metadata
+}
+```
+Event properties:
+* MUST reference parent room via d tag
+* MUST have a status (planned/live/ended)
+* MUST have a start time
+* MAY track participant counts
+* MAY include participant roles specific to the event
+Event management:
+* Clients SHOULD update event status regularly when live
+* Events without updates for 1 hour MAY be considered ended
+* starts and ends timestamps SHOULD be updated when status changes
+### Examples
+#### Meeting Space (kind:30312)
+```jsonc
+{
+  "kind": 30312,
+  "tags": [
+    ["d", "main-conference-room"],
+    ["room", "Main Conference Hall"],
+    ["summary", "Our primary conference space"],
+    ["image", "https://example.com/room.jpg"],
+    ["status", "open"],
+    ["service", "https://meet.example.com/room"],
+    ["endpoint", "https://api.example.com/room"],
+    ["t", "conference"],
+    ["p", "f7234bd4c1394dda46d09f35bd384dd30cc552ad5541990f98844fb06676e9ca", "wss://nostr.example.com/", "Owner"],
+    ["p", "14aeb..8dad4", "wss://provider2.com/", "Moderator"],
+    ["relays", "wss://relay1.com", "wss://relay2.com"]
+  ],
+  "content": ""
+}
+```
+#### Meeting room (kind:30313)
+```jsonc
+{
+  "kind": 30313,
+  "tags": [
+    ["d", "annual-meeting-2025"],
+    ["a", "30312:f7234bd4c1394dda46d09f35bd384dd30cc552ad5541990f98844fb06676e9ca:main-conference-room", "wss://nostr.example.com"]
+    ["title", "Annual Company Meeting 2025"],
+    ["summary", "Yearly company-wide meeting"],
+    ["image", "https://example.com/meeting.jpg"],
+    ["starts", "1676262123"],
+    ["ends", "1676269323"],
+    ["status", "live"],
+    ["total_participants", "180"],
+    ["current_participants", "175"],
+    ["p", "91cf9..4e5ca", "wss://provider1.com/", "Speaker"],
+  ],
+  "content": ""
+}
+```
+### Room Presence
+New `kind: 10312` provides an event which signals presence of a listener.
+The presence event SHOULD be updated at regular intervals and clients SHOULD filter presence events older than
+a given time window.
+**This kind `10312` is a regular replaceable event, as such presence can only be indicated in one room at a time.**
+```json
+{
+  "kind": 10312,
+  "tags": [
+    ["a" , "<room-a-tag>", "<relay-hint>", "root"],
+    ["hand", "1"] // hand raised flag
+  ]
+}
+```
diff --git a/54.md b/54.md
index 3a02150..ead362d 100644
--- a/54.md
+++ b/54.md
@@ -8,57 +8,115 @@ Wiki
 This NIP defines `kind:30818` (an _addressable event_) for descriptions (or encyclopedia entries) of particular subjects, and it's expected that multiple people will write articles about the exact same subjects, with either small variations or completely independent content.
-Articles are identified by lowercase, normalized ascii `d` tags.
+Articles are identified by lowercase, normalized `d` tags.
-### Articles
+## Articles
 ```json
 {
  "content": "A wiki is a hypertext publication collaboratively edited and managed by its own audience.",
  "tags": [
    ["d", "wiki"],
-    ["title", "Wiki"],
+    ["title", "Wiki"]
  ]
 }
 ```
-### `d` tag normalization rules
+## `d` tag normalization rules
- Any non-letter character MUST be converted to a `-`.
+- All letters with uppercase/lowercase variants MUST be converted to lowercase.
- All letters MUST be converted to lowercase.
+- Whitespace MUST be converted to `-`.
+- Punctuation and symbols SHOULD be removed.
+- Multiple consecutive `-` SHOULD be collapsed to a single `-`.
+- Leading and trailing `-` SHOULD be removed.
+- Non-ASCII letters (e.g., Japanese, Chinese, Arabic, Cyrillic) MUST be preserved as UTF-8.
+- Numbers MUST be preserved.
-### Content
+For example:
+- `"Wiki Article"` → `"wiki-article"`
+- `"What's Up?"` → `"whats-up"`
+- `"  Hello  World  "` → `"hello-world"`
+- `"Article 1"` → `"article-1"`
+- `"ウィキペディア"` → `"ウィキペディア"` (Japanese, no case change)
+- `"Ñoño"` → `"ñoño"` (Spanish, lowercased)
+- `"Москва"` → `"москва"` (Russian, lowercased)
+- `"日本語 Article"` → `"日本語-article"` (mixed scripts)
-The `content` should be Asciidoc with two extra functionalities: **wikilinks** and **nostr:...** links.
+## Content
-Unlike normal Asciidoc links `http://example.com[]` that link to external webpages, wikilinks `[[]]` link to other articles in the wiki. In this case, the wiki is the entirety of Nostr. Clicking on a wikilink should cause the client to ask relays for events with `d` tags equal to the target of that wikilink.
+The `content` should be [Djot](https://djot.net/) with two special functionalities:
-Wikilinks can take these two forms:
+1. Links can have target URIs in [NIP-21](21.md) format, like `[Bob](nostr:npub1...)`.
+2. When a reference can't be found for a reference-style link, it should link to the wiki article with that name instead (wikilink behavior). The target is normalized following the `d` tag normalization rules above.
-  1. `[[Target Page]]` -- in this case it will link to the page `target-page` (according to `d` tag normalization rules above) and be displayed as `Target Page`;
+For example:
-  2. `[[target page|see this]]` -- in this case it will link to the page `target-page`, but will be displayed as `see this`.
-`nostr:...` links, as per [NIP-21](21.md), should link to profiles or arbitrary Nostr events. Although it is not recommended to link to specific versions of articles -- instead the _wikilink_ syntax should be preferred, since it should be left to the reader and their client to decide what version of any given article they want to read.
+```djot
+Bitcoin is a [cryptocurrency][] invented by [Satoshi Nakamoto][].
-### Optional extra tags
+See also: [proof of work][] and [lightning network][Lightning Network].
+[Satoshi Nakamoto]: nostr:npub1satoshi...
+```
+In the article above:
+- `[cryptocurrency][]` links to the wiki article with `d` tag `"cryptocurrency"` (no reference defined, so it becomes a wikilink)
+- `[Satoshi Nakamoto][]` links to the npub (reference is defined)
+- `[proof of work][]` links to the article with `d` tag `"proof-of-work"`
+- `[lightning network][Lightning Network]` links to `"lightning-network"`, displays as "lightning network"
+Wikilinks also work with non-Latin scripts following the same normalization rules:
+- `[ビットコイン][]` → links to article with `d` tag `"ビットコイン"`
+- `[Japanese Article][日本語 記事]` → links to `"日本語-記事"`, displays as "Japanese Article"
+- `[Биткойн][]` → links to article with `d` tag `"биткойн"` (Cyrillic, lowercased)
+[NIP-21](21.md) `nostr:` links can also be used to link to profiles or arbitrary Nostr events. It is not recommended to link to specific versions of articles — the wikilink syntax should be preferred instead, since it should be left to the reader and their client to decide what version of any given article they want to read.
+## Optional extra tags
  - `title`: for when the display title should be different from the `d` tag.
  - `summary`: for display in lists.
  - `a` and `e`: for referencing the original event a wiki article was forked from.
-### Merge Requests
+## Merge Requests
 Event `kind:818` represents a request to merge from a forked article into the source. It is directed to a pubkey and references the original article and the modified event.
-[INSERT EVENT EXAMPLE]
+```json
+{
+  "content": "I added information about the block size limit",
+  "kind": 818,
+  "tags": [
+    ["a", "30818:<destination-pubkey>:bitcoin", "<relay-url>"],
+    ["e", "<version-against-which-the-modification-was-made>", "<relay-url>"],
+    ["p", "<destination-pubkey>"],
+    ["e", "<version-to-be-merged>", "<relay-url>", "source"]
+  ]
+}
+```
-### Redirects
+- `.content`: an optional explanation detailing why this merge is being requested.
+- `a` tag: tag of the article which should be modified (i.e. the target of this merge request).
+- `e` tag: optional version of the article on which this modification is based.
+- `e` tag with `source` marker: the ID of the event that should be merged. This event id MUST be of a `kind:30818` as defined in this NIP.
-Event `kind:30819` is also defined to stand for "wiki redirects", i.e. if one thinks `Shell structure` should redirect to `Thin-shell structure` they can issue one of these events instead of replicating the content. These events can be used for automatically redirecting between articles on a client, but also for generating crowdsourced "disambiguation" pages ([common in Wikipedia](https://en.wikipedia.org/wiki/Help:Disambiguation)).
+The destination pubkey can create [NIP-25](25.md) reactions that tag the `kind:818` event with `+` or `-` to accept or reject the merge request.
-[INSERT EVENT EXAMPLE]
+## Redirects
-How to decide what article to display
+Event `kind:30819` is also defined to stand for "wiki redirects", i.e. if one thinks "BTC" should redirect to "Bitcoin" they can issue one of these events instead of replicating the content. These events can be used for automatically redirecting between articles on a client, but also for generating crowdsourced "disambiguation" pages ([common in Wikipedia](https://en.wikipedia.org/wiki/Help:Disambiguation)).
-------------------------------------
+```json
+{
+  "kind": 30819,
+  "tags": [
+    ["d", "btc"],
+    ["a", "30818:<pubkey>:bitcoin", "<relay-url>"]
+  ],
+  "content": ""
+}
+```
+## How to decide what article to display
 As there could be many articles for each given name, some kind of prioritization must be done by clients. Criteria for this should vary between users and clients, but some means that can be used are described below:
@@ -78,44 +136,24 @@ As there could be many articles for each given name, some kind of prioritization
 [NIP-51](51.md) lists can also be used to create a list of users that are trusted only in the context of wiki authorship or wiki curationship.
-Forks
+## Forks
---------
 Wiki-events can tag other wiki-events with a `fork` marker to specify that this event came from a different version. Both `a` and `e` tags SHOULD be used and have the `fork` marker applied, to identify the exact version it was forked from.
-Deference
+## Deference
---------
 Wiki-events can tag other wiki-events with a `defer` marker to indicate that it considers someone else's entry as a "better" version of itself. If using a `defer` marker both `a` and `e` tags SHOULD be used.
 This is a stronger signal of trust than a `+` reaction.
-This marker is useful when a user edits someone else's entry; if the original author includes the editor's changes and the editor doesn't want to keep/maintain an independent version, the `link` tag could effectively be a considered a "deletion" of the editor's version and putting that pubkey's WoT weight behind the original author's version.
+This marker is useful when a user edits someone else's entry; if the original author includes the editor's changes and the editor doesn't want to keep/maintain an independent version, the `defer` tag could effectively be considered a "deletion" of the editor's version and putting that pubkey's WoT weight behind the original author's version.
-Why Asciidoc?
-------------
-Wikitext is [garbage](nostr:nevent1qqsqt0gcggry60n72uglhuhypdlmr2dm6swjj69jex5v530gcpazlzsprpmhxue69uhhyetvv9ujumn0wdmksetjv5hxxmmdqy28wumn8ghj7un9d3shjtnyv9kh2uewd9hsygpm7rrrljungc6q0tuh5hj7ue863q73qlheu4vywtzwhx42a7j9n5ueneex) and Markdown is not powerful enough (besides being too freeform and unspecified and prone to generate incompatibilities in the future).
-Asciidoc has a strict spec, multiple implementations in many languages, and support for features that are very much necessary in a wiki article, like _sidebars_, _tables_ (with rich markup inside cells), many levels of _headings_, _footnotes_, _superscript_ and _subscript_ markup and _description lists_. It is also arguably easier to read in its plaintext format than Markdown (and certainly much better than Wikitext).
-# Appendix 1: Merge requests
+## Why Djot?
-Users can request other users to get their entries merged into someone else's entry by creating a `kind:818` event.
-```json
-{
-  "content": "I added information about how to make hot ice-creams",
-  "kind": 818,
-  "tags": [
-    [ "a", "30818:<destination-pubkey>:hot-ice-creams", "<relay-url>" ],
-    [ "e", "<version-against-which-the-modification-was-made>", "<relay-url>" ],
-    [ "p", "<destination-pubkey>" ],
-    [ "e", "<version-to-be-merged>", "<relay-url>", "source" ]
-  ]
-}
-```
-`.content`: an optional explanation detailing why this merge is being requested.
+[Djot](https://djot.net/) is a markup language created by John MacFarlane (author of Pandoc and co-author of CommonMark). It was chosen for the following reasons:
-`a` tag: tag of the article which should be modified (i.e. the target of this merge request).
-`e` tag: optional version of the article in which this modifications is based
-`e` tag with `source` marker: the ID of the event that should be merged. This event id MUST be of a `kind:30818` as defined in this NIP.
-The destination-pubkey is the pubkey being requested to merge something into their article can create [[NIP-25]] reactions that tag the `kind:818` event with `+` or `-`
+- **Well-defined spec**: Unlike Markdown (many incompatible dialects) or Asciidoc (spec tied to Ruby implementation), Djot has a clear, standalone specification.
+- **Native implementations**: Available in JavaScript, Lua, Rust, Go, and other languages without transpilation.
+- **Rich features**: Supports superscript, subscript, footnotes, tables, definition lists, and math — features useful for encyclopedic content.
+- **Familiar syntax**: Similar to basic Markdown, making it easy to learn.
+- **Fast parsing**: Designed for efficient linear-time parsing.
diff --git a/55.md b/55.md
index 6d2b92a..72a844a 100644
--- a/55.md
+++ b/55.md
@@ -8,7 +8,7 @@ Android Signer Application
 This NIP describes a method for 2-way communication between an Android signer and any Nostr client on Android. The Android signer is an Android Application and the client can be a web client or an Android application.
-# Usage for Android applications
+## Usage for Android applications
 The Android signer uses Intents (to accept/reject permissions manually) and Content Resolvers (to accept/reject permissions automatically in background if the user allowed it) to communicate between applications.
@@ -38,7 +38,7 @@ fun isExternalSignerInstalled(context: Context): Boolean {
 }
 ```
-## Using Intents
+### Using Intents
 To get the result back from the Signer Application you should use `registerForActivityResult` or `rememberLauncherForActivityResult` in Kotlin. If you are using another framework check the documentation of your framework or a third party library to get the result.
@@ -91,7 +91,7 @@ Signer MUST answer multiple permissions with an array of results
 val results = listOf(
  Result(
    package = signerPackageName,
-    result = eventSignture,
+    result = eventSignature,
    id = intentId
  )
 )
@@ -107,7 +107,14 @@ Send the Intent:
 launcher.launch(intent)
 ```
-### Methods
+### Initiating a connection
+- Client send a get_public_key `Intent`
+- Signer responds with the user `pubkey` and it's `packageName`
+- Client saves the `pubkey` and `packageName` somewhere and NEVER calls `get_public_key` again
+- Client now can send `content resolvers` and `Intents` for the other methods
+#### Methods
 - **get_public_key**
  - params:
@@ -203,10 +210,10 @@ launcher.launch(intent)
    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")
      ```
@@ -242,7 +249,7 @@ launcher.launch(intent)
    ```kotlin
    val intent = Intent(Intent.ACTION_VIEW, Uri.parse("nostrsigner:$encryptedText"))
    intent.`package` = "com.example.signer"
-    intent.putExtra("type", "nip04_decrypt")
+    intent.putExtra("type", "nip44_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 pubkey
@@ -283,7 +290,7 @@ launcher.launch(intent)
      val id = intent.data?.getStringExtra("id")
      ```
-## Using Content Resolver
+### Using Content Resolver
 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.
@@ -295,34 +302,9 @@ 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
-### Methods
+Clients SHOULD save the user pubkey locally and avoid calling the `get_public_key` after the user is logged in to the Client
- **get_public_key**
+#### Methods
-  - params:
-    ```kotlin
-    val result = context.contentResolver.query(
-        Uri.parse("content://com.example.signer.GET_PUBLIC_KEY"),
-        listOf("login"),
-        null,
-        null,
-        null
-    )
-    ```
-  - result:
-    - Will return the **pubkey** in the result column
-      ```kotlin
-        if (result == null) return
-        if (it.getColumnIndex("rejected") > -1) return
-        if (result.moveToFirst()) {
-            val index = it.getColumnIndex("result")
-            if (index < 0) return
-            val pubkey = it.getString(index)
-        }
-      ```
 - **sign_event**
  - params:
@@ -482,7 +464,7 @@ If the user chose to always reject the event, signer application will return the
        }
      ```
-# Usage for Web Applications
+## Usage for Web Applications
 You should consider using [NIP-46: Nostr Connect](46.md) for a better experience for web applications. When using this approach, the web app can't call the signer in the background, so the user will see a popup for every event you try to sign.
@@ -496,7 +478,7 @@ You can configure the `returnType` to be **signature** or **event**.
 Android intents and browser urls have limitations, so if you are using the `returnType` of **event** consider using the parameter **compressionType=gzip** that will return "Signer1" + Base64 gzip encoded event json
-## Methods
+### Methods
 - **get_public_key**
  - params:
@@ -547,7 +529,7 @@ Android intents and browser urls have limitations, so if you are using the `retu
    window.href = `nostrsigner:${eventJson}?compressionType=none&returnType=signature&type=decrypt_zap_event&callbackUrl=https://example.com/?event=`;
    ```
-## Example
+### Example
 ```js
 <!DOCTYPE html>
diff --git a/57.md b/57.md
index c37126e..91eac30 100644
--- a/57.md
+++ b/57.md
@@ -12,7 +12,7 @@ Having lightning receipts on nostr allows clients to display lightning payments
 ## Protocol flow
-1. Client calculates a recipient's lnurl pay request url from the `zap` tag on the event being zapped (see Appendix G), or by decoding their lud06 or lud16 field on their profile according to the [lnurl specifications](https://github.com/lnurl/luds). The client MUST send a GET request to this url and parse the response. If `allowsNostr` exists and it is `true`, and if `nostrPubkey` exists and is a valid BIP 340 public key in hex, the client should associate this information with the user, along with the response's `callback`, `minSendable`, and `maxSendable` values.
+1. Client calculates a recipient's lnurl pay request url from the `zap` tag on the event being zapped (see Appendix G), or by decoding their lud16 field on their profile according to the [lnurl specifications](https://github.com/lnurl/luds). The client MUST send a GET request to this url and parse the response. If `allowsNostr` exists and it is `true`, and if `nostrPubkey` exists and is a valid BIP 340 public key in hex, the client should associate this information with the user, along with the response's `callback`, `minSendable`, and `maxSendable` values.
 2. Clients may choose to display a lightning zap button on each post or on a user's profile. If the user's lnurl pay request endpoint supports nostr, the client SHOULD use this NIP to request a `zap receipt` rather than a normal lnurl invoice.
 3. When a user (the "sender") indicates they want to send a zap to another user (the "recipient"), the client should create a `zap request` event as described in Appendix A of this NIP and sign it.
 4. Instead of publishing the `zap request`, the `9734` event should instead be sent to the `callback` url received from the lnurl pay endpoint for the recipient using a GET request. See Appendix B for details and an example.
@@ -37,6 +37,7 @@ In addition, the event MAY include the following tags:
 - `e` is an optional hex-encoded event id. Clients MUST include this if zapping an event rather than a person.
 - `a` is an optional event coordinate that allows tipping addressable events such as NIP-23 long-form notes.
+- `k` is the stringified kind of the target event.
 Example:
@@ -49,7 +50,8 @@ Example:
    ["amount", "21000"],
    ["lnurl", "lnurl1dp68gurn8ghj7um5v93kketj9ehx2amn9uh8wetvdskkkmn0wahz7mrww4excup0dajx2mrv92x9xp"],
    ["p", "04c915daefee38317fa734444acee390a8269fe5810b2241e5e6dd343dfbecc9"],
-    ["e", "9ae37aa68f48645127299e9453eb5d908a0cbb6058ff340d528ed4d37c8994fb"]
+    ["e", "9ae37aa68f48645127299e9453eb5d908a0cbb6058ff340d528ed4d37c8994fb"],
+    ["k", "1"]
  ],
  "pubkey": "97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322",
  "created_at": 1679673265,
@@ -151,6 +153,7 @@ Example `zap receipt`:
      ["p", "32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245"],
      ["P", "97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322"],
      ["e", "3624762a1274dd9636e0c552b53086d70bc88c165bc4dc0f9e836a1eaf86c3b8"],
+      ["k", "1"],
      ["bolt11", "lnbc10u1p3unwfusp5t9r3yymhpfqculx78u027lxspgxcr2n2987mx2j55nnfs95nxnzqpp5jmrh92pfld78spqs78v9euf2385t83uvpwk9ldrlvf6ch7tpascqhp5zvkrmemgth3tufcvflmzjzfvjt023nazlhljz2n9hattj4f8jq8qxqyjw5qcqpjrzjqtc4fc44feggv7065fqe5m4ytjarg3repr5j9el35xhmtfexc42yczarjuqqfzqqqqqqqqlgqqqqqqgq9q9qxpqysgq079nkq507a5tw7xgttmj4u990j7wfggtrasah5gd4ywfr2pjcn29383tphp4t48gquelz9z78p4cq7ml3nrrphw5w6eckhjwmhezhnqpy6gyf0"],
      ["description", "{\"pubkey\":\"97c70a44366a6535c145b333f973ea86dfdc2d7a99da618c40c64705ad98e322\",\"content\":\"\",\"id\":\"d9cc14d50fcb8c27539aacf776882942c1a11ea4472f8cdec1dea82fab66279d\",\"created_at\":1674164539,\"sig\":\"77127f636577e9029276be060332ea565deaf89ff215a494ccff16ae3f757065e2bc59b2e8c113dd407917a010b3abd36c8d7ad84c0e3ab7dab3a0b0caa9835d\",\"kind\":9734,\"tags\":[[\"e\",\"3624762a1274dd9636e0c552b53086d70bc88c165bc4dc0f9e836a1eaf86c3b8\"],[\"p\",\"32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245\"],[\"relays\",\"wss://relay.damus.io\",\"wss://nostr-relay.wlvs.space\",\"wss://nostr.fmt.wiz.biz\",\"wss://relay.nostr.bg\",\"wss://nostr.oxtr.dev\",\"wss://nostr.v0l.io\",\"wss://brb.io\",\"wss://nostr.bitcoiner.social\",\"ws://monad.jb55.com:8080\",\"wss://relay.snort.social\"]]}"],
      ["preimage", "5d006d2cf1e73c7148e7519a4c68adc81642ce0e25a432b2434c99f97344c15f"]
diff --git a/58.md b/58.md
index 23921bd..0011997 100644
--- a/58.md
+++ b/58.md
@@ -11,7 +11,7 @@ user profiles:
 1. A "Badge Definition" event is defined as an addressable event with kind `30009` having a `d` tag with a value that uniquely identifies the badge (e.g. `bravery`) published by the badge issuer. Badge definitions can be updated.
-2. A "Badge Award" event is a kind `8` event with a single `a` tag referencing a "Badge Definition" event and one or more `p` tags, one for each pubkey the badge issuer wishes to award. Awarded badges are immutable and non-transferrable.
+2. A "Badge Award" event is a kind `8` event with a single `a` tag referencing a "Badge Definition" event and one or more `p` tags, one for each pubkey the badge issuer wishes to award. Awarded badges are immutable and non-transferable.
 3. A "Profile Badges" event is defined as an _addressable event_ with kind `30008` with a `d` tag with the value `profile_badges`.
 Profile badges contain an ordered list of pairs of `a` and `e` tags referencing a `Badge Definition` and a `Badge Award` for each badge to be displayed.
diff --git a/59.md b/59.md
index ddeb83c..e570151 100644
--- a/59.md
+++ b/59.md
@@ -4,7 +4,7 @@ NIP-59
 Gift Wrap
 ---------
-`optional`
+`optional` `relay`
 This NIP defines a protocol for encapsulating any nostr event. This makes it possible to obscure most metadata
 for a given event, perform collaborative signing, and more.
@@ -13,7 +13,7 @@ This NIP *does not* define any messaging protocol. Applications of this NIP shou
 This NIP relies on [NIP-44](./44.md)'s versioned encryption algorithms.
-# Overview
+## Overview
 This protocol uses three main concepts to protect the transmission of a target event: `rumor`s, `seal`s, and `gift wrap`s.
@@ -29,13 +29,13 @@ This allows the isolation of concerns across layers:
 - A seal identifies the author without revealing the content or the recipient.
 - A gift wrap can add metadata (recipient, tags, a different author) without revealing the true author.
-# Protocol Description
+## Protocol Description
-## 1. The Rumor Event Kind
+### 1. The Rumor Event Kind
 A `rumor` is the same thing as an unsigned event. Any event kind can be made a `rumor` by removing the signature.
-## 2. The Seal Event Kind
+### 2. The Seal Event Kind
 A `seal` is a `kind:13` event that wraps a `rumor` with the sender's regular key. The `seal` is **always** encrypted
 to a receiver's pubkey but there is no `p` tag pointing to the receiver. There is no way to know who the rumor is for
@@ -55,7 +55,7 @@ without the receiver's or the sender's private key. The only public information
 Tags MUST always be empty in a `kind:13`. The inner event MUST always be unsigned.
-## 3. Gift Wrap Event Kind
+### 3. Gift Wrap Event Kind
 A `gift wrap` event is a `kind:1059` event that wraps any other event. `tags` SHOULD include any information
 needed to route the event to its intended recipient, including the recipient's `p` tag or [NIP-13](13.md) proof of work.
@@ -72,12 +72,12 @@ needed to route the event to its intended recipient, including the recipient's `
 }
 ```
-# Encrypting Payloads
+## Encrypting Payloads
 Encryption is done following [NIP-44](44.md) on the JSON-encoded event. Place the encryption payload in the `.content`
 of the wrapper event (either a `seal` or a `gift wrap`).
-# Other Considerations
+## Other Considerations
 If a `rumor` is intended for more than one party, or if the author wants to retain an encrypted copy, a single
 `rumor` may be wrapped and addressed for each recipient individually.
@@ -97,7 +97,12 @@ To protect recipient metadata, relays SHOULD only serve `kind 1059` events inten
 When possible, clients should only send wrapped events to `read` relays for the recipient that implement
 AUTH, and refuse to serve wrapped events to non-recipients.
-# An Example
+When adding expiration tags to both `seal` and `gift wrap` layers, implementations SHOULD use independent random timestamps for each layer. Using different `created_at` values increases timing variance and helps protect against metadata correlation attacks.
+Since signing keys are random, relays SHOULD delete `kind 1059` events whose p-tag matches the signer of
+[NIP-09](09.md) deletions or [NIP-62](62.md) vanish requests.
+## An Example
 Let's send a wrapped `kind 1` message between two parties asking "Are you going to the party tonight?"
@@ -108,7 +113,7 @@ Let's send a wrapped `kind 1` message between two parties asking "Are you going
 Note that this messaging protocol should not be used in practice, this is just an example. Refer to other
 NIPs for concrete messaging protocols that depend on gift wraps.
-## 1. Create an event
+### 1. Create an event
 Create a `kind 1` event with the message, the receivers, and any other tags you want, signed by the author.
 Do not sign the event.
@@ -124,7 +129,7 @@ Do not sign the event.
 }
 ```
-## 2. Seal the rumor
+### 2. Seal the rumor
 Encrypt the JSON-encoded `rumor` with a conversation key derived using the author's private key and
 the recipient's public key. Place the result in the `content` field of a `kind 13` `seal` event. Sign
@@ -142,7 +147,7 @@ it with the author's key.
 }
 ```
-## 3. Wrap the seal
+### 3. Wrap the seal
 Encrypt the JSON-encoded `kind 13` event with your ephemeral, single-use random key. Place the result
 in the `content` field of a `kind 1059`. Add a single `p` tag containing the recipient's public key.
@@ -160,13 +165,13 @@ Sign the `gift wrap` using the random key generated in the previous step.
 }
 ```
-## 4. Broadcast Selectively
+### 4. Broadcast Selectively
 Broadcast the `kind 1059` event to the recipient's relays only. Delete all the other events.
-# Code Samples
+## Code Samples
-## JavaScript
+### JavaScript
 ```javascript
 import {bytesToHex} from "@noble/hashes/utils"
diff --git a/60.md b/60.md
index 4d0c709..8c836ac 100644
--- a/60.md
+++ b/60.md
@@ -16,13 +16,13 @@ The purpose of this NIP is:
 This NIP doesn't deal with users' *receiving* money from someone else, it's just to keep state of the user's wallet.
-# High-level flow
+## High-level flow
 1. A user has a `kind:17375` event that represents a wallet.
 2. A user has `kind:7375` events that represent the unspent proofs of the wallet. -- The proofs are encrypted with the user's private key.
 3. A user has `kind:7376` events that represent the spending history of the wallet -- This history is for informational purposes only and is completely optional.
-## Wallet Event
+### Wallet Event
-```jsonc
+```javascript
 {
    "kind": 17375,
    "content": nip44_encrypt([
@@ -40,16 +40,17 @@ Tags:
 * `mint` - Mint(s) this wallet uses -- there MUST be one or more mint tags.
 * `privkey` - Private key used to unlock P2PK ecash. MUST be stored encrypted in the `.content` field. **This is a different private key exclusively used for the wallet, not associated in any way to the user's Nostr private key** -- This is only used for receiving [NIP-61](61.md) nutzaps.
-## Token Event
+### Token Event
 Token events are used to record unspent proofs.
 There can be multiple `kind:7375` events for the same mint, and multiple proofs inside each `kind:7375` event.
-```jsonc
+```javascript
 {
    "kind": 7375,
    "content": nip44_encrypt({
        "mint": "https://stablenut.umint.cash",
+        "unit": "sat",
        "proofs": [
            // one or more proofs in the default cashu format
            {
@@ -69,21 +70,23 @@ There can be multiple `kind:7375` events for the same mint, and multiple proofs
 * `.content` is a [NIP-44](44.md) encrypted payload:
   * `mint`: The mint the proofs belong to.
   * `proofs`: unencoded proofs
+   * `unit` the base unit the proofs are denominated in (eg: `sat`, `usd`, `eur`). Default: `sat` if omitted.
   * `del`: token-ids that were destroyed by the creation of this token. This assists with state transitions.
 When one or more proofs of a token are spent, the token event should be [NIP-09](09.md)-deleted and, if some proofs are unspent from the same token event, a new token event should be created rolling over the unspent proofs and adding any change outputs to the new token event (the change output should include a `del` field).
 The `kind:5` _delete event_ created in the [NIP-09](09.md) process MUST have a tag `["k", "7375"]` to allow easy filtering by clients interested in state transitions.
-## Spending History Event
+### Spending History Event
 Clients SHOULD publish `kind:7376` events to create a transaction history when their balance changes.
-```jsonc
+```javascript
 {
    "kind": 7376,
    "content": nip44_encrypt([
        [ "direction", "in" ], // in = received, out = sent
        [ "amount", "1" ],
+        [ "unit", "sat" ],
        [ "e", "<event-id-of-created-token>", "", "created" ]
    ]),
    "tags": [
@@ -93,6 +96,7 @@ Clients SHOULD publish `kind:7376` events to create a transaction history when t
 ```
 * `direction` - The direction of the transaction; `in` for received funds, `out` for sent funds.
+* `unit` the base unit of the amount (eg: `sat`, `usd`, `eur`). Default: `sat` if omitted.
 Clients MUST add `e` tags to create references of destroyed and created token events along with the marker of the meaning of the tag:
 * `created` - A new token event was created.
@@ -103,24 +107,25 @@ All tags can be [NIP-44](44.md) encrypted. Clients SHOULD leave `e` tags with a
 Multiple `e` tags can be added, and should be encrypted, except for tags with the `redeemed` marker.
-# Flow
+## Flow
 A client that wants to check for user's wallets information starts by fetching `kind:10019` events from the user's relays, if no event is found, it should fall back to using the user's [NIP-65](65.md) relays.
-## Fetch wallet and token list
+### Fetch wallet and token list
 From those relays, the client should fetch wallet and token events.
 `"kinds": [17375, 7375], "authors": ["<my-pubkey>"]`
-## Fetch proofs
+### Fetch proofs
-## Spending token
+### Spending token
 If Alice spends 4 sats from this token event
-```jsonc
+```javascript
 {
    "kind": 7375,
    "id": "event-id-1",
    "content": nip44_encrypt({
        "mint": "https://stablenut.umint.cash",
+        "unit": "sat",
        "proofs": [
            { "id": "1", "amount": 1 },
            { "id": "2", "amount": 2 },
@@ -134,12 +139,13 @@ If Alice spends 4 sats from this token event
 Her client:
 * MUST roll over the unspent proofs:
-```jsonc
+```javascript
 {
    "kind": 7375,
    "id": "event-id-2",
    "content": nip44_encrypt({
        "mint": "https://stablenut.umint.cash",
+        "unit": "sat",
        "proofs": [
            { "id": "1", "amount": 1 },
            { "id": "2", "amount": 2 },
@@ -153,12 +159,13 @@ Her client:
 * MUST delete event `event-id-1`
 * SHOULD add the `event-id-1` to the `del` array of deleted token-ids.
 * SHOULD create a `kind:7376` event to record the spend
-```jsonc
+```javascript
 {
    "kind": 7376,
    "content": nip44_encrypt([
        [ "direction", "out" ],
        [ "amount", "4" ],
+        [ "unit", "sat" ],
        [ "e", "<event-id-1>", "", "destroyed" ],
        [ "e", "<event-id-2>", "", "created" ],
    ]),
@@ -166,12 +173,12 @@ Her client:
 }
 ```
-## Redeeming a quote (optional)
+### Redeeming a quote (optional)
 When creating a quote at a mint, an event can be used to keep the state of the quote ID, which will be used to check when the quote has been paid. These events should be created with an expiration tag [NIP-40](40.md) of 2 weeks (which is around the maximum amount of time a Lightning payment may be in-flight).
 However, application developers SHOULD use local state when possible and only publish this event when it makes sense in the context of their application.
-```jsonc
+```javascript
 {
    "kind": 7374,
    "content": nip44_encrypt("quote-id"),
diff --git a/61.md b/61.md
index ebb8af3..5842d6b 100644
--- a/61.md
+++ b/61.md
@@ -8,19 +8,19 @@ Nutzaps
 A Nutzap is a P2PK Cashu token in which the payment itself is the receipt.
-# High-level flow
+## High-level flow
 Alice wants to nutzap 1 sat to Bob because of an event `event-id-1` she liked.
-## Alice nutzaps Bob
+### Alice nutzaps Bob
 1. Alice fetches event `kind:10019` from Bob to see the mints Bob trusts.
 2. She mints a token at that mint (or swaps some tokens she already had in that mint) P2PK-locked to the pubkey Bob has listed in his `kind:10019`.
 3. She publishes a `kind:9321` event to the relays Bob indicated with the proofs she minted.
-## Bob receives the nutzap
+### Bob receives the nutzap
 1. At some point, Bob's client fetches `kind:9321` events p-tagging him from his relays.
 2. Bob's client swaps the token into his wallet.
-# Nutzap informational event
+## Nutzap informational event
 ```jsonc
 {
    "kind": 10019,
@@ -39,7 +39,7 @@ Alice wants to nutzap 1 sat to Bob because of an event `event-id-1` she liked.
 * `mint`: mints the user is explicitly agreeing to use to receive funds on. Clients SHOULD not send money on mints not listed here or risk burning their money. Additional markers can be used to list the supported base units of the mint.
 * `pubkey`: Public key that MUST be used to P2PK-lock receiving nutzaps -- implementations MUST NOT use the target user's main Nostr public key. This public key corresponds to the `privkey` field encrypted in a user's [nip-60](60.md) _wallet event_.
-## Nutzap event
+### Nutzap event
 Event `kind:9321` is a nutzap event published by the sender, p-tagging the recipient. The outputs are P2PK-locked to the public key the recipient indicated in their `kind:10019` event.
 Clients MUST prefix the public key they P2PK-lock with `"02"` (for nostr<>cashu compatibility).
@@ -51,8 +51,10 @@ Clients MUST prefix the public key they P2PK-lock with `"02"` (for nostr<>cashu
    "pubkey": "<sender-pubkey>",
    "tags": [
        [ "proof", "{\"amount\":1,\"C\":\"02277c66191736eb72fce9d975d08e3191f8f96afb73ab1eec37e4465683066d3f\",\"id\":\"000a93d6f8a1d2c4\",\"secret\":\"[\\\"P2PK\\\",{\\\"nonce\\\":\\\"b00bdd0467b0090a25bdf2d2f0d45ac4e355c482c1418350f273a04fedaaee83\\\",\\\"data\\\":\\\"02eaee8939e3565e48cc62967e2fde9d8e2a4b3ec0081f29eceff5c64ef10ac1ed\\\"}]\"}" ],
+        [ "unit", "sat" ],
        [ "u", "https://stablenut.umint.cash" ],
        [ "e", "<nutzapped-event-id>", "<relay-hint>" ],
+        [ "k", "<nutzapped-kind>"],
        [ "p", "e9fbced3a42dcf551486650cc752ab354347dd413b307484e4fd1818ab53f991" ], // recipient of nutzap
    ]
 }
@@ -61,29 +63,30 @@ Clients MUST prefix the public key they P2PK-lock with `"02"` (for nostr<>cashu
 * `.content` is an optional comment for the nutzap
 * `.tags`:
  * `proof` is one or more proofs P2PK-locked to the public key the recipient specified in their `kind:10019` event and including a DLEQ proof.
+  * `unit` the base unit the proofs are denominated in (eg: `sat`, `usd`, `eur`). Default: `sat` if omitted.
  * `u` is the mint the URL of the mint EXACTLY as specified by the recipient's `kind:10019`.
  * `p` is the Nostr identity public key of nutzap recipient.
  * `e` is the event that is being nutzapped, if any.
-# Sending a nutzap
+## Sending a nutzap
 * The sender fetches the recipient's `kind:10019`.
 * The sender mints/swaps ecash on one of the recipient's listed mints.
 * The sender P2PK-locks to the recipient's specified public key in their `kind:10019`
-# Receiving nutzaps
+## Receiving nutzaps
 Clients should REQ for nutzaps:
 * Filtering with `#u` for mints they expect to receive ecash from.
  * this is to prevent even interacting with mints the user hasn't explicitly signaled.
 * Filtering with `since` of the most recent `kind:7376` event the same user has created.
-  * this can be used as a marker of the nutzaps that have already been swaped by the user -- clients might choose to use other kinds of markers, including internal state -- this is just a guidance of one possible approach.
+  * this can be used as a marker of the nutzaps that have already been swapped by the user -- clients might choose to use other kinds of markers, including internal state -- this is just a guidance of one possible approach.
 `{ "kinds": [9321], "#p": ["my-pubkey"], "#u": ["<mint-1>", "<mint-2>"], "since": <latest-created_at-of-kind-7376> }`.
 Upon receiving a new nutzap, the client should swap the tokens into a wallet the user controls, either a [NIP-60](60.md) wallet, their own LN wallet or anything else.
-## Updating nutzap-redemption history
+### Updating nutzap-redemption history
 When claiming a token the client SHOULD create a `kind:7376` event and `e` tag the original nutzap event. This is to record that this token has already been claimed (and shouldn't be attempted again) and as signaling to the recipient that the ecash has been redeemed.
 Multiple `kind:9321` events can be tagged in the same `kind:7376` event.
@@ -94,6 +97,7 @@ Multiple `kind:9321` events can be tagged in the same `kind:7376` event.
    "content": nip44_encrypt([
        [ "direction", "in" ], // in = received, out = sent
        [ "amount", "1" ],
+        [ "unit", "sat" ],
        [ "e", "<7375-event-id>", "<relay-hint>", "created" ] // new token event that was created
    ]),
    "tags": [
@@ -105,7 +109,7 @@ Multiple `kind:9321` events can be tagged in the same `kind:7376` event.
 Events that redeem a nutzap SHOULD be published to the sender's [NIP-65](65.md) "read" relays.
-## Verifying a Cashu Zap
+### Verifying a Cashu Zap
 When listing or counting zaps received by any given event, observer clients SHOULD:
 * check that the receiving user has issued a `kind:10019` tagging the mint where the cashu has been minted.
@@ -115,7 +119,7 @@ When listing or counting zaps received by any given event, observer clients SHOU
 All these checks can be done offline (as long as the observer has the receiver mints' keyset and their `kind:10019` event), so the process should be reasonably fast.
-## Final Considerations
+### Final Considerations
 1. Clients SHOULD guide their users to use NUT-11 (P2PK) and NUT-12 (DLEQ proofs) compatible-mints in their `kind:10019` event to avoid receiving nutzaps anyone can spend.
 2. Clients SHOULD normalize and deduplicate mint URLs as described in NIP-65.
 3. A nutzap event MUST include proofs in one of the mints the recipient has listed in their `kind:10019` and published to the NIP-65 relays of the recipient, failure to do so may result in the recipient donating the tokens to the mint since the recipient might never see the event.
diff --git a/62.md b/62.md
index a00ddfc..e0398d8 100644
--- a/62.md
+++ b/62.md
@@ -4,7 +4,7 @@ NIP-62
 Request to Vanish
 -----------------
-`draft` `optional`
+`draft` `optional` `relay`
 This NIP offers a Nostr-native way to request a complete reset of a key's fingerprint on the web. This procedure is legally binding in some jurisdictions, and thus, supporters of this NIP should truly delete events from their database. 
diff --git a/66.md b/66.md
index 7ab3786..9f06ff5 100644
--- a/66.md
+++ b/66.md
@@ -4,139 +4,46 @@ NIP-66
 Relay Discovery and Liveness Monitoring
 -------------------
-`draft` `optional`
+`draft` `optional` `relay`
-You want to find relays. You may want to discover relays based on criteria that's up to date. You may even want to ensure that you have a complete dataset. You probably want to filter relays based on their reported liveness.
+This NIP defines events for relay discovery and the announcement of relay monitors.
-In its purest form:
+## Relay Discovery Events
-```json
+`30166` relay discovery events document relay characteristics inferred either from a relay's [NIP 11](https://github.com/nostr-protocol/nips/blob/master/11.md) document, or via probing.
-{
-  "kind": 30166,
-  "created_at": 1722173222,  
-  "content": "{}",
-  "tags": [
-    [ "d", "wss://somerelay.abc/" ]
-  ],
-  "pubkey": "<pubkey>", 
-  "sig": "<signature>",
-  "id": "<eventid>"
-}
-```
-This event signals that the relay at `wss://somerelay.abc/` was reported "online" by `<pubkey>` at timestamp `1722173222`. This event **MAY** be extended upon to include more information.
-## Kinds
-`NIP-66` defines two (2) event kinds, `30166` and `10166`
-| kind  | name                       | description                                                                             |
-|-------|----------------------------|-----------------------------------------------------------------------------------------|
-| [30166](#k30166) | Relay Discovery      | An addressable event that is published by a monitor when a relay is online |
-| [10166](#k10166) | Relay Monitor Announcement | An RE that stores data that signals the intent of a pubkey to monitor relays and publish `30166` events at a regular _frequency_ |
-## Ontology
- `Relay Operator`: someone who operates a relay 
- `Monitor`: A pubkey that monitors relays and publishes `30166` events at the frequency specified in their `10166` event.
- `Ad-hoc Monitor`: A pubkey that monitors relays and publishes `30166` events at an irregular frequency.
- `Monitor Service`: A group or individual that monitors relays using one or more `Monitors`.
- `Check`: a specific data point that is tested or aggregated by a monitor.
-## `30166`: "Relay Discovery" <a id="k30166"></a>
-### Summary
-`30166` is a `NIP-33` addressable event, referred to as a "Relay Discovery" event. These events are optimized with a small footprint for protocol-level relay Discovery.
-### Purpose 
-Discovery of relays over nostr. 
-### Schema 
-#### Content 
-`30166` content fields **SHOULD** include the stringified JSON of the relay's NIP-11 informational document. This data **MAY** be provided for informational purposes only. 
-#### `created_at`
-The `created_at` field in a NIP-66 event should reflect the time when the relay liveness (and potentially other data points) was checked.
-#### `tags`
-##### Meta Tags (unindexed)
- `rtt-open` The relay's open **round-trip time** in milliseconds.
- `rtt-read` The relay's read **round-trip time** in milliseconds.
- `rtt-write` The relay's write **round-trip time** in milliseconds.
-_Other `rtt` values **MAY** be present. This NIP should be updated if there is value found in more `rtt` values._
-##### Single Letter Tags (indexed)
- `d` The relay URL/URI. The `#d` tag **must** be included in the `event.tags[]` array. Index position `1` **must** be the relay websocket URL/URI. If a URL it **SHOULD** be [normalized](https://datatracker.ietf.org/doc/html/rfc3986#section-6). For relays not accessible via conventional means but rather by an npub/pubkey, an npub/pubkey **MAY** be used in place of a URL.
-  ```json
-  [ "d", "wss://somerelay.abc/"]
-  ```
- `n`: Network
-  ```json
-  [ "n", "clearnet" ]
-  ```
- `T`: Relay Type. Enumerated [relay type](https://github.com/nostr-protocol/nips/issues/1282) formatted as `PascalCase`
-  ```json
-  ["T", "PrivateInbox" ]
-  ```
- `N`: Supported Nips _From NIP-11 "Informational Document" `nip11.supported_nips[]`_
-  ```json
-  [ "N", "42" ]
-  ```
- `R`: Requirements _NIP-11 "Informational Document" `nip11.limitations.payment_required`, `nip11.limitations.auth_required` and/or any other boolean value within `nip11.limitations[]` that is added in the future_
-  ```json
-  [ "R", "payment" ],
-  [ "R", "auth" ],
-  ```
-  Since the nostr protocol does not currently support filtering on whether an indexed tag **is** or **is not** set, to make "public" and "no auth" relays discoverable requires a `!` flag
-  ```json
+Information corresponding to field in a relay's NIP 11 document MAY contradict actual values if monitors find that a different policy is implemented than is advertised.
-  [ "R", "!payment" ], //no payment required, is public
-  [ "R", "!auth" ], //no authentication required
-  ```
- `t`: "Topics" _From NIP-11 "Informational Document" `nip11.tags[]`_
+`content` MAY include the stringified JSON of the relay's NIP-11 informational document.
-  ```json
-  [ "t", "nsfw" ]
-  ```
- `k`: Accepted/Blocked Kinds [`NIP-22`]
+The only required tag is the `d` tag, which MUST be set to the relay's [normalized](https://datatracker.ietf.org/doc/html/rfc3986#section-6) URL. For relays not accessible via URL, a hex-encoded pubkey MAY be used instead.
-  ```json
-  [ "k", "0" ],
-  [ "k", "3" ],
-  [ "k", "10002" ]
-  ```
-  or for blocked kinds
+Other tags include:
-  ```json
+- `rtt-open` - The relay's open round-trip time in milliseconds.
-  [ "k", "!0" ]
+- `rtt-read` - The relay's read round-trip time in milliseconds.
-  [ "k", "!3" ],
+- `rtt-write` - The relay's write round-trip time in milliseconds.
-  [ "k", "!10002" ]
+- `n` - The relay's network type. SHOULD be one of `clearnet`, `tor`, `i2p`, `loki`
-  ```
+- `T` - The relay type. Enumerated [relay type](https://github.com/nostr-protocol/nips/issues/1282) formatted as `PascalCase`, e.g. `PrivateInbox`
+- `N` - NIPs supported by the relay
+- `R` - Keys corresponding to requirements per [NIP 11](https://github.com/nostr-protocol/nips/blob/master/11.md)'s `limitations` array, including `auth`, `writes`, `pow`, and `payment`. False values should be specified using a `!` prefix, for example `!auth`.
+- `t` - A topic associated with this relay
+- `k` - Accepted and unaccepted kinds (false values prepended by `!`) 
+- `g` - A [NIP-52](https://github.com/nostr-protocol/nips/blob/master/52.md) geohash
- `g`: `NIP-52` `g` tags (geohash)
+Tags with more than one value should be repeated, rather than putting all values in a single tag, for example `[["t", "cats"], ["t", "dogs"]]`, rather than `[["t", "cats", "dogs"]]`.
-  ```json
-  [ "g", "9r1652whz" ]
-  ```
- `30166` **MAY** be extended with global tags defined by other NIPs that do no collide with locally defined indices, including but not limited to: `p`, `t`, `e`, `a`, `i` and `l/L`. 
+Example:
-#### Robust Example of a `30166` Event
-_Relay was online, and you can filter on a number of different tags_
 ```json
 {
  "id": "<eventid>",
  "pubkey": "<monitor's pubkey>",
  "created_at": "<created_at  [some recent date ...]>",
  "signature": "<signature>",
-  "content": "{}",
+  "content": "<optional nip 11 document>",
  "kind": 30166,
-  "tags": [  
+  "tags": [
    ["d","wss://some.relay/"],
    ["n", "clearnet"],
    ["N", "40"],
@@ -144,64 +51,28 @@ _Relay was online, and you can filter on a number of different tags_
    ["R", "!payment"],
    ["R", "auth"],
    ["g", "ww8p1r4t8"],
-    ["p", "somehexkey..."],
    ["l", "en", "ISO-639-1"],
    ["t", "nsfw" ],
-    ["rtt-open", 234 ]
+    ["rtt-open", "234" ]
  ]
-} 
+}
 ```
-## `10166`: "Relay Monitor Announcement" Events <a id="k10166"></a>
+## Relay Monitor Announcements
-### Summary 
-`10166` is a replacable event herein referred to as "Relay Monitor Announcement" events. These events contain information about a publisher's intent to monitor and publish data as `30166` events. This event is optional and is intended for monitors who intend to provide monitoring services at a regular and predictable frequency.
-### Purpose 
-To provide a directory of monitors, their intent to publish, their criteria and parameters of monitoring activities. Absence of this event implies the monitor is ad-hoc and does not publish events at a predictable frequency, and relies on mechanisms to infer data integrity, such as web-of-trust.
-### Schema
-#### Standard Tags
- `frequency` The frequency **in seconds** at which the monitor publishes events. A string-integer at index `1` represents the expected frequency the monitor will publish `30166` events. There should only be `1` frequency per monitor. 
+Kind `10166` relay monitor announcements advertise the author's intent to publish `30166` events. This event is optional and is intended for monitors who intend to provide monitoring services at a regular and predictable frequency.
-  ```json
+Tags include:
-  [ "frequency", "3600" ]
-  ```
- `timeout` (optional) The timeout values for various checks conducted by a monitor. Index `1` is the monitor's timeout in milliseconds. Index `2` describes what test the timeout is used for. If no index `2` is provided, it is inferred that the timeout provided applies to all tests. These values can assist relay operators in understanding data signaled by the monitor in _Relay Discovery Events_. 
+- `frequency` - The frequency in seconds at which the monitor publishes events.
-  ```json
+- `timeout` (optional) - The timeout values for various checks conducted by a monitor. Index `1` is the monitor's timeout in milliseconds. Index `2` describes what test the timeout is used for. If no index `2` is provided, it is inferred that the timeout provided applies to all tests.
-  [ "timeout", "2000", "open" ],
+- `c` - a lowercase string describing the checks conducted by a monitor. Examples include `open`, `read`, `write`, `auth`, `nip11`, `dns`, and `geo`.
-  [ "timeout", "2000", "read" ],
+- `g` - [NIP-52](https://github.com/nostr-protocol/nips/blob/master/52.md) geohash tag
-  [ "timeout", "3000", "write" ],
-  [ "timeout", "2000", "nip11" ],
-  [ "timeout", "4000", "ssl" ]
-  ```
-#### Indexed Tags
+Monitors SHOULD also publish a `kind 0` profile and a `kind 10002` relay selections event.
- `c`  "Checks" **SHOULD** be a lowercase string describing the check(s) conducted by a monitor. Due to the rapidly evolving nature of relays, enumeration is organic and not strictly defined. But examples of some checks could be websocket `open/read/write/auth`, `nip11` checks, `dns` and `geo` checks, and and any other checks the monitor may deem useful.. Other checks **MAY** be included. New types of checks **SHOULD** be added to this NIP as they are needed.
-  ```json
-  [ "c", "ws" ],
-  [ "c", "nip11" ],
-  [ "c", "dns" ],
-  [ "c", "geo" ],
-  [ "c", "ssl" ],
-  ```
- `g`: `NIP-52` `g` tags (geohash)
+Example:
-  ```json
-  [ "g", "9r1652whz" ]
-  ```
- Any other globally defined indexable tags **MAY** be included as found necessary.
-### Other Requirements
-Monitors **SHOULD** have the following 
- A published `0` (NIP-1) event
- A published `10002` (NIP-65) event that defines the relays the monitor publishes to.
-### Robust Example of a `10166` Event
 ```json
 {
  "id": "<eventid>",
@@ -209,46 +80,24 @@ Monitors **SHOULD** have the following
  "created_at": "<created_at  [some recent date ...]>",
  "signature": "<signature>",
  "content": "",
-  "tags": [  
+  "tags": [
    [ "timeout", "open", "5000"  ],
    [ "timeout", "read", "3000"  ],
    [ "timeout", "write", "3000" ],
    [ "timeout", "nip11", "3000" ],
    [ "frequency", "3600" ],
    [ "c", "ws" ],
    [ "c", "nip11" ],
    [ "c", "ssl" ],
    [ "c", "dns" ],
    [ "c", "geo" ]
    [ "g", "ww8p1r4t8" ]
  ]
-} 
+}
 ```
-## Methodology 
+ ## Risk Mitigation                                                                                                                                                 
+                                                                                                                                                                   
-### Monitors
+  - Clients MUST NOT require `30166` events to function. Absence of monitoring data MUST NOT prevent relay connections.
-1. A _Relay Monitor_ checks the liveness and potentially other attributes of a relay. 
+  - A monitor may publish erroneous `30166` events, either by misconfiguration or malicious intent.
+  - Clients SHOULD NOT trust a single source. Defenses include: web-of-trust filtering, querying multiple monitors, and discarding filter results if they would remove an unreasonable proportion of relays.
-2. _Relay Monitor_ publishes a kind `30166` note when a relay it is monitoring is online. If the monitor has a `10166` event, events should be published at the frequency defined in their `10166` note. 
-_Any pubkey that publishes `30166` events **SHOULD** at a minimum be checking that the relay is available by websocket and behaves like a relay_
-### Clients
-1. In most cases, a client **SHOULD** filter on `30166` events using either a statically or dynamically defined monitor's `pubkey` and a `created_at` value respective of the monitor's published `frequency`. If the monitor has no stated frequency, other mechanisms should be employed to determine data integrity.
-2. _Relay Liveness_ is subjectively determined by the client, starting with the `frequency` value of a monitor. 
-3. The liveness of a _Relay Monitor_ can be subjectively determined by detecting whether the _Relay Monitor_ has published events with respect to `frequency` value of any particular monitor.
-4. The reliability and trustworthiness of a _Relay Monitor_ could be established via web-of-trust, reviews or similar mechanisms. 
-## Risk Mitigation
- When a client implements `NIP-66` events, the client should have a fallback if `NIP-66` events cannot be located.
- A `Monitor` or `Ad-hoc Monitor` may publish erroneous `30166` events, intentionally or otherwise. Therefor, it's important to program defensively to limit the impact of such events. This can be achieved with web-of-trust, reviews, fallbacks and/or data-aggregation for example.
diff --git a/69.md b/69.md
index 603016e..997cac6 100644
--- a/69.md
+++ b/69.md
@@ -41,7 +41,8 @@ Events are [addressable events](01.md#kinds) and use `38383` as event kind, a p2
    ["name", "Nakamoto"],
    ["g", "<geohash>"],
    ["bond", "0"],
-    ["expiration", "1719391096"],
+    ["expires_at", "1719391096"],
+    ["expiration", "1719995896"],
    ["y", "lnp2pbot"],
    ["z", "order"]
  ],
@@ -55,7 +56,7 @@ Events are [addressable events](01.md#kinds) and use `38383` as event kind, a p2
 - `d` < Order ID >: A unique identifier for the order.
 - `k` < Order type >: `sell` or `buy`.
 - `f` < Currency >: The asset being traded, using the [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) standard.
- `s` < Status >: `pending`, `canceled`, `in-progress`, `success`.
+- `s` < Status >: `pending`, `canceled`, `in-progress`, `success`, `expired`.
 - `amt` < Amount >: The amount of Bitcoin to be traded, the amount is defined in satoshis, if `0` means that the amount of satoshis will be obtained from a public API after the taker accepts the order.
 - `fa` < Fiat amount >: The fiat amount being traded, for range orders two values are expected, the minimum and maximum amount.
 - `pm` < Payment method >: The payment method used for the trade, if the order has multiple payment methods, they should be separated by a comma.
@@ -67,7 +68,8 @@ Events are [addressable events](01.md#kinds) and use `38383` as event kind, a p2
 - `name` [Name]: The name of the maker.
 - `g` [Geohash]: The geohash of the operation, it can be useful in a face to face trade.
 - `bond` [Bond]: The bond amount, the bond is a security deposit that both parties must pay.
- `expiration` < Expiration\>: The expiration date of the order ([NIP-40](40.md)).
+- `expires_at` < Expires At\>: The expiration date of the event being published in `pending` status, after this time the event status SHOULD be changed to `expired`.
+- `expiration` < Expiration\>: The expiration date of the event, after this time the relay SHOULD delete it ([NIP-40](40.md)).
 - `y` < Platform >: The platform that created the order.
 - `z` < Document >: `order`.
@@ -80,6 +82,7 @@ Currently implemented on the following platforms:
 - [Mostro](https://github.com/MostroP2P/mostro)
 - [@lnp2pBot](https://github.com/lnp2pBot/bot)
 - [Robosats](https://github.com/RoboSats/robosats/pull/1362)
+- [Peach Bitcoin](https://github.com/Peach2Peach/peach-nostr-announcer-bot)
 ## References
diff --git a/70.md b/70.md
index 043d5fb..32853d3 100644
--- a/70.md
+++ b/70.md
@@ -4,7 +4,7 @@ NIP-70
 Protected Events
 ----------------
-`draft` `optional`
+`draft` `optional` `relay`
 When the `"-"` tag is present, that means the event is "protected".
diff --git a/71.md b/71.md
index d3b0925..0124edd 100644
--- a/71.md
+++ b/71.md
@@ -20,12 +20,31 @@ Nothing except cavaliership and common sense prevents a _short_ video from being
 The format uses a _regular event_ kind `21` for _normal_ videos and `22` for _short_ videos.
+## Addressable Video Events
+For content that may need updates after publication (such as correcting metadata, descriptions, or handling URL migrations), addressable versions are available:
+- Kind `34235` for _addressable normal videos_
+- Kind `34236` for _addressable short videos_
+These addressable events follow the same format as their regular counterparts but include a `d` tag as a unique identifier and can be updated while maintaining the same addressable reference. This is particularly useful for:
+- Metadata corrections (descriptions, titles, tags) without republishing
+- Preservation of imported content IDs from legacy platforms
+- URL migration when hosting changes
+- Platform migration tracking
 The `.content` of these events is a summary or description on the video content.
 The primary source of video information is the `imeta` tags which is defined in [NIP-92](92.md)
 Each `imeta` tag can be used to specify a variant of the video by the `dim` & `m` properties.
+This NIP defines the following additional `imeta` properties aside from those listed in [NIP-92](92.md) & [NIP-94](94.md):
+* `duration` (recommended) the duration of the video/audio in seconds (floating point number)
+* `bitrate` (recommended) the average bitrate of the video/audio in bits/sec
 Example:
 ```json
 [
@@ -39,6 +58,8 @@ Example:
    "fallback https://myotherserver.com/1080/12345.mp4",
    "fallback https://andanotherserver.com/1080/12345.mp4",
    "service nip96",
+    "bitrate 3000000",
+    "duration 29.223"
  ],
  ["imeta",
    "dim 1280x720",
@@ -50,6 +71,8 @@ Example:
    "fallback https://myotherserver.com/720/12345.mp4",
    "fallback https://andanotherserver.com/720/12345.mp4",
    "service nip96",
+    "bitrate 2000000",
+    "duration 29.24"
  ],
  ["imeta",
    "dim 1280x720",
@@ -61,6 +84,7 @@ Example:
    "fallback https://myotherserver.com/720/12345.m3u8",
    "fallback https://andanotherserver.com/720/12345.m3u8",
    "service nip96",
+    "duration 29.21"
  ],
 ]
 ```
@@ -71,10 +95,12 @@ The `image` tag contains a preview image (at the same resolution). Multiple `ima
 Additionally `service nip96` may be included to allow clients to search the authors NIP-96 server list to find the file using the hash.
+### Required tags for addressable events:
+* `d` - Unique identifier for this video (user-chosen string, required for kinds 34235, 34236)
 ### Other tags:
 * `title` (required) title of the video
 * `published_at`, for the timestamp in unix seconds (stringified) of the first time the video was published
-* `duration` (optional) video duration in seconds
 * `text-track` (optional, repeated) link to WebVTT file for video, type of supplementary information (captions/subtitles/chapters/metadata), optional language code
 * `content-warning` (optional) warning about content of NSFW video
 * `alt` (optional) description for accessibility
@@ -83,17 +109,20 @@ Additionally `service nip96` may be included to allow clients to search the auth
 * `p` (optional, repeated) 32-bytes hex pubkey of a participant in the video, optional recommended relay URL
 * `r` (optional, repeated) references / links to web pages
+### Optional tags for imported content:
+* `origin` - Track original platform and ID: `["origin", "<platform>", "<external-id>", "<original-url>", "<optional-metadata>"]`
 ```jsonc
 {
-  "id": <32-bytes lowercase hex-encoded SHA-256 of the the serialized event data>,
+  "id": "<32-bytes lowercase hex-encoded SHA-256 of the the serialized event data>",
-  "pubkey": <32-bytes lowercase hex-encoded public key of the event creator>,
+  "pubkey": "<32-bytes lowercase hex-encoded public key of the event creator>",
  "created_at": <Unix timestamp in seconds>,
  "kind": 21 | 22,
  "content": "<summary / description of video>",
  "tags": [
    ["title", "<title of video>"],
    ["published_at", "<unix timestamp>"],
-    ["alt", <description>],
+    ["alt", "<description>"],
    // video Data
    ["imeta",
@@ -108,7 +137,6 @@ Additionally `service nip96` may be included to allow clients to search the auth
      "service nip96",
    ],
-    ["duration", <duration of video in seconds>],
    ["text-track", "<encoded `kind 6000` event>", "<recommended relay urls>"],
    ["content-warning", "<reason>"],
    ["segment", <start>, <end>, "<title>", "<thumbnail URL>"],
@@ -127,3 +155,56 @@ Additionally `service nip96` may be included to allow clients to search the auth
  ]
 }
 ```
+## Addressable Event Example
+```jsonc
+{
+  "id": <32-bytes lowercase hex-encoded SHA-256 of the the serialized event data>,
+  "pubkey": <32-bytes lowercase hex-encoded public key of the event creator>,
+  "created_at": <Unix timestamp in seconds>,
+  "kind": 34235 | 34236,
+  "content": "<summary / description of video>",
+  "tags": [
+    ["d", "<unique-identifier>"],
+    ["title", "<title of video>"],
+    ["published_at", "<unix timestamp>"],
+    ["alt", "<description for accessibility>"],
+    // video data
+    ["imeta",
+      "url https://example.com/media.mp4",
+      "m video/mp4",
+      "dim 480x480",
+      "blurhash eVF$^OI:${M{%LRjWBoLoLaeR*",
+      "image https://example.com/thumb.jpg",
+      "x 3093509d1e0bc604ff60cb9286f4cd7c781553bc8991937befaacfdc28ec5cdc"
+    ],
+    ["duration", <duration in seconds>],
+    ["content-warning", "<reason>"],
+    // origin tracking for imported content
+    ["origin", "<platform>", "<external-id>", "<original-url>", "<optional-metadata>"],
+    // participants
+    ["p", "<32-bytes hex of a pubkey>", "<optional recommended relay URL>"],
+    // hashtags
+    ["t", "<tag>"],
+    ["t", "<tag>"],
+    // reference links
+    ["r", "<url>"]
+  ]
+}
+```
+## Referencing Addressable Events
+To reference an addressable video:
+```
+["a", "34235:<pubkey>:<d-tag-value>", "<relay-url>"]  // for normal videos
+["a", "34236:<pubkey>:<d-tag-value>", "<relay-url>"]  // for short videos
+```
diff --git a/72.md b/72.md
index 582410a..210376e 100644
--- a/72.md
+++ b/72.md
@@ -8,7 +8,7 @@ Moderated Communities (Reddit Style)
 The goal of this NIP is to enable public communities. It defines the replaceable event `kind:34550` to define the community and the current list of moderators/administrators. Users that want to post into the community, simply tag any Nostr event with the community's `a` tag. Moderators may issue an approval event `kind:4550`.
-# Community Definition
+## Community Definition
 `Kind:34550` SHOULD include any field that helps define the community and the set of moderators. `relay` tags MAY be used to describe the preferred relay to download requests and approvals. A community definition event's `d` tag MAY double as its name, but if a `name` tag is provided, it SHOULD be displayed instead of the `d` tag.
@@ -39,22 +39,58 @@ The goal of this NIP is to enable public communities. It defines the replaceable
 }
 ```
-# Posting to a community
+## Posting to a community
-Any Nostr event can be posted to a community. Clients MUST add one or more community `a` tags, each with a recommended relay.
+[NIP-22](22.md) kind 1111 events SHOULD be used for text notes posted to a community, with the `A` tag always scoped to the community definition.
+### Top-level posts
+For top-level posts, the uppercase and lowercase NIP-22 tags should both refer to the community definition itself.
+```jsonc
+{
+  "kind": 1111,
+  "tags": [
+    ["A", "34550:<community-author-pubkey>:<community-d-identifier>", "<optional-relay-url>"],
+    ["a", "34550:<community-author-pubkey>:<community-d-identifier>", "<optional-relay-url>"],
+    ["P", "<community-author-pubkey>", "<optional-relay-url>"],
+    ["p", "<community-author-pubkey>", "<optional-relay-url>"],
+    ["K", "34550"],
+    ["k", "34550"],
+  ],
+  "content": "Hi everyone. It's great to be here!",
+  // other fields...
+}
+```
+### Nested replies
+For nested replies, the uppercase tags should still refer to the community definition, while the lowercase tags should refer to the parent post or reply.
 ```jsonc
 {
-  "kind": 1,
+  "kind": 1111,
  "tags": [
-    ["a", "34550:<community event author pubkey>:<community-d-identifier>", "<optional-relay-url>"],
+    // community definition itself
+    ["A", "34550:<community-author-pubkey>:<community-d-identifier>", "<optional-relay-url>"],
+    ["P", "<community-author-pubkey>", "<optional-relay-url>"],
+    ["K", "34550"],
+    // parent post or reply
+    ["e", "<parent-event-id>", "<optional-relay-url>"],
+    ["p", "<parent-event-author-pubkey>", "<optional-relay-url>"],
+    ["k", "<parent-event-kind>"] // most likely "1111"
  ],
-  "content": "hello world",
+  "content": "Agreed! Welcome everyone!",
  // other fields...
 }
 ```
-# Moderation
+### Backwards compatibility note
+Previously kind 1 events were used for posts in communities, with an "a" tag pointing to the community. For backwards compatibility, clients MAY still query for kind 1 events, but SHOULD NOT use them for new posts. Instead, clients SHOULD use kind 1111 events with the `A` and `a` tags as described above.
+## Moderation
 Anyone may issue an approval event to express their opinion that a post is appropriate for a community. Clients MAY choose which approval events to honor, but SHOULD at least use ones published by the group's defined moderators.
@@ -91,6 +127,6 @@ Since relays are instructed to delete old versions of a replaceable event, the `
 Clients SHOULD evaluate any non-`34550:*` `a` tag as posts to be approved for all `34550:*` `a` tags.
-# Cross-posting
+## Cross-posting
 Clients MAY support cross-posting between communities by posting a NIP 18 `kind 6` or `kind 16` repost to one or more communities using `a` tags as described above. The `content` of the repost MUST be the original event, not the approval event.
diff --git a/73.md b/73.md
index d883e79..3e975ae 100644
--- a/73.md
+++ b/73.md
@@ -6,7 +6,7 @@ External Content IDs
 `draft` `optional`
-There are certain established global content identifiers such as [Book ISBNs](https://en.wikipedia.org/wiki/ISBN), [Podcast GUIDs](https://podcastnamespace.org/tag/guid), and [Movie ISANs](https://en.wikipedia.org/wiki/International_Standard_Audiovisual_Number) that are useful to reference in nostr events so that clients can query all the events assosiated with these ids.
+There are certain established global content identifiers such as [Book ISBNs](https://en.wikipedia.org/wiki/ISBN), [Podcast GUIDs](https://podcastnamespace.org/tag/guid), and [Movie ISANs](https://en.wikipedia.org/wiki/International_Standard_Audiovisual_Number) that are useful to reference in nostr events so that clients can query all the events associated with these ids.
 `i` tags are used for referencing these external content ids, with `k` tags representing the external content id kind so that clients can query all the events for a specific kind.
@@ -18,6 +18,7 @@ There are certain established global content identifiers such as [Book ISBNs](ht
 | URLs                   | "`<URL, normalized, no fragment>`"                         | "web"                    |
 | Books                  | "isbn:`<id, without hyphens>`"                             | "isbn"                   |
 | Geohashes              | "geo:`<geohash, lowercase>`"                               | "geo"                    |
+| Countries              | "iso3166:`<code, uppercase>`"                              | "iso3166"                |
 | Movies                 | "isan:`<id, without version part>`"                        | "isan"                   |
 | Papers                 | "doi:`<id, lowercase>`"                                    | "doi"                    |
 | Hashtags               | "#`<topic, lowercase>`"                                    | "#"                      |
@@ -43,11 +44,26 @@ For the webpage "https://myblog.example.com/post/2012-03-27/hello-world" the "i"
 ]
 ```
+### Geohashes:
+- Geohash: `["i", "geo:ezs42e44yx96"]` - https://www.movable-type.co.uk/scripts/geohash.html
+Geohashes are a geocoding system that encodes geographic locations into short strings of letters and digits. They MUST be lowercase.
+### Countries:
+ISO 3166 codes can reference countries (ISO 3166-1 alpha-2) or subdivisions like states/provinces (ISO 3166-2).
+- Country (Venezuela): `["i", "iso3166:VE"]`
+- Subdivision (California, USA): `["i", "iso3166:US-CA"]`
+ISO 3166 codes MUST be uppercase. More info: https://en.wikipedia.org/wiki/ISO_3166
 ### Books:
 - Book ISBN: `["i", "isbn:9780765382030"]` - https://isbnsearch.org/isbn/9780765382030
-Book ISBNs MUST be referenced _**without hyphens**_ as many book search APIs return the ISBNs without hyphens. Removing hypens from ISBNs is trivial, whereas adding the hyphens back in is non-trivial requiring a library.
+Book ISBNs MUST be referenced _**without hyphens**_ as many book search APIs return the ISBNs without hyphens. Removing hyphens from ISBNs is trivial, whereas adding the hyphens back in is non-trivial requiring a library.
 ### Podcasts:
diff --git a/77.md b/77.md
new file mode 100644
index 0000000..ff4eba7
--- /dev/null
+++ b/77.md
@@ -0,0 +1,175 @@
+NIP-77
+======
+Negentropy Syncing
+------------------
+`draft` `optional` `relay`
+This document describes a protocol extension for syncing events. It works for both client-relay and relay-relay scenarios. If both sides of the sync have events in common, then this protocol will use less bandwidth than transferring the full set of events (or even just their IDs).
+It is a Nostr-friendly wrapper around the [Negentropy](https://github.com/hoytech/negentropy) protocol, which uses a technique called [Range-Based Set Reconciliation](https://logperiodic.com/rbsr.html).
+Since Negentropy is a binary protocol, this wrapper hex-encodes its messages. The specification for Negentropy Protocol V1 is attached as an appendix to this NIP below.
+## High-Level Protocol Description
+We're going to call the two sides engaged in the sync the client and the relay (even though the initiator could be another relay instead of a client).
+* (1) Client (initiator) chooses a filter, and retrieves the set of events that it has locally that match this filter (or uses a cache), and constructs an initial message.
+* (2) Client sends a `NEG-OPEN` message to the relay, which includes the filter and the initial message.
+* (3) Relay selects the set of events that it has locally that match the filter (or uses a cache).
+* (4) Relay constructs a response and returns it to the client in a `NEG-MSG` message.
+* (5) Client parses the message to learn about IDs it has (and relay needs) and IDs it needs (and relay has).
+  * If client wishes to continue, then it constructs a new message and sends it to the relay in a `NEG-MSG` message. Goto step 4.
+  * If client wishes to stop, then it sends a `NEG-CLOSE` message or disconnects the websocket.
+The above protocol only results in the client learning about IDs it has/needs, and does not actually transfer events. Given these IDs, the client can upload events it has with `EVENT`, and/or download events it needs with `REQ`. This can be performed over the same websocket connection in parallel with subsequent `NEG-MSG` messages. If a client is only interested in determining the number of unique events (ie, reaction counts), it may choose to not download/upload at all.
+## Nostr Messages
+### Initial message (client to relay):
+```jsonc
+[
+    "NEG-OPEN",
+    <subscription ID string>,
+    <filter>,
+    <initialMessage, hex-encoded>
+]
+```
+* The subscription ID is used by each side to identify which query a message refers to. It only needs to be long enough to distinguish it from any other concurrent subscriptions on this websocket connection (an integer that increments once per `NEG-OPEN` is fine). Subscription IDs are in a separate namespace from `REQ` subscription IDs. If a `NEG-OPEN` is issued for a currently open subscription ID, the existing subscription is first closed.
+* The filter is as described in [NIP-01](01.md).
+* `initialMessage` is the initial Negentropy binary message, hex-encoded. See appendix.
+### Error message (relay to client):
+If a request cannot be serviced by the relay, an error is returned to the client:
+```jsonc
+[
+    "NEG-ERR",
+    <subscription ID string>,
+    <reason code string>
+]
+```
+Error reasons are the same format as in NIP-01. They should begin with a machine-readable single-word prefix, followed by a `:` and then a human-readable message with more information.
+The current suggested error reasons are
+* `blocked`
+  * Relays can optionally reject queries that would require them to process too many records, or records that are too old
+  * The maximum number of records that can be processed can optionally be returned as the 4th element in the response
+  * Example: `blocked: this query is too big`
+* `closed`
+  * Because the `NEG-OPEN` queries may be stateful, relays may choose to time-out inactive queries to recover memory resources
+  * Example: `closed: you took too long to respond!`
+After a `NEG-ERR` is issued, the subscription is considered to be closed.
+### Subsequent messages (bidirectional):
+Relay and client alternate sending each other `NEG-MSG`s:
+```jsonc
+[
+    "NEG-MSG",
+    <subscription ID string>,
+    <message, hex-encoded>
+]
+```
+* `message` is a Negentropy binary message, hex-encoded. Both message directions use the same format. See appendix.
+### Close message (client to relay):
+When finished, the client should tell the relay it can release its resources with a `NEG-CLOSE`:
+```jsonc
+[
+    "NEG-CLOSE",
+    <subscription ID string>
+]
+```
+## Appendix: Negentropy Protocol V1
+### Preparation
+There are two protocol participants: Client and server. The client creates an initial message and transmits it to the server, which replies with its own message in response. The client continues querying the server until it is satisfied, and then terminates the protocol. Messages in either direction have the same format.
+Each participant has a collection of records. A records consists of a 64-bit numeric timestamp and a 256-bit ID. Each participant starts by sorting their items according to timestamp, ascending. If two timestamps are equal then items are sorted lexically by ID, ascending by first differing byte. Items may not use the max uint64 value (`2**64 - 1`) as a timestamp since this is reserved as a special "infinity" value.
+The goal of the protocol is for the client to learn the set of IDs that it has and the server does not, and the set of items that the server has and it does not.
+### `Varint`
+Varints (variable-sized unsigned integers) are represented as base-128 digits, most significant digit first, with as few digits as possible. Bit eight (the high bit) is set on each byte except the last.
+    Varint := <Digit+128>* <Digit>
+### `Id`
+IDs are represented as byte-strings of length `32`:
+    Id := Byte{32}
+### `Message`
+A reconciliation message is a protocol version byte followed by an ordered list of ranges:
+    Message := <protocolVersion (Byte)> <Range>*
+The current protocol version is 1, represented by the byte `0x61`. Protocol version 2 will be `0x62`, and so forth. If a server receives a message with a protocol version that it cannot handle, it should reply with a single byte containing the highest protocol version it supports, allowing the client to downgrade and retry its message.
+Each Range corresponds to a contiguous section of the timestamp/ID space. The first Range starts at timestamp 0 and an ID of 0 bytes. Ranges are always adjacent (no gaps). If the last Range doesn't end at the special infinity value, an implicit `Skip` to infinity Range is appended. This means that the list of Ranges always covers the full timestamp/ID space.
+### `Range`
+A Range consists of an upper bound, a mode, and a payload:
+    Range := <upperBound (Bound)> <mode (Varint)> <payload (Skip | Fingerprint | IdList)>
+The contents of the payload is determined by mode:
+* If `mode = 0`, then payload is `Skip`, meaning the sender does not wish to process this Range further. This payload is empty:
+      Skip :=
+* If `mode = 1`, then payload is a `Fingerprint`, which is a [digest](#fingerprint-algorithm) of all the IDs the sender has within the Range:
+      Fingerprint := Byte{16}
+* If `mode = 2`, the payload is `IdList`, a variable-length list of all IDs the sender has within the Range:
+      IdList := <length (Varint)> <ids (Id)>*
+### `Bound`
+Each Range is specified by an *inclusive* lower bound and an *exclusive* upper bound. As defined above, each Range only includes an upper bound: the lower bound of a Range is the upper bound of the previous Range, or 0 timestamp/0 ID for the first Range.
+A Bound consists of an encoded timestamp and a variable-length disambiguating prefix of an ID (in case multiple items have the same timestamp):
+    Bound := <encodedTimestamp (Varint)> <length (Varint)> <idPrefix (Byte)>*
+* The timestamp is encoded specially. The infinity timestamp is encoded as `0`. All other values are encoded as `1 + offset`, where offset is the difference between this timestamp and the previously encoded timestamp. The initial offset starts at `0` and resets at the beginning of each message.
+  Offsets are always non-negative since the upper bound's timestamp is greater than or equal to the lower bound's timestamp, ranges in a message are always encoded in ascending order, and ranges never overlap.
+* The size of `idPrefix` is encoded in `length`, and can be between `0` and `32` bytes, inclusive. This allows implementations to use the shortest possible prefix to separate the first record of this Range from the last record of the previous Range. If these records' timestamps differ, then the length should be 0, otherwise it should be the byte-length of their common ID-prefix plus 1.
+  If the `idPrefix` length is less than `32` then the omitted trailing bytes are implicitly 0 bytes.
+### Fingerprint Algorithm
+The fingerprint of a Range is computed with the following algorithm:
+* Compute the addition mod 2<sup>256</sup> of the element IDs (interpreted as 32-byte little-endian unsigned integers)
+* Concatenate with the number of elements in the Range, encoded as a [Varint](#varint)
+* Hash with SHA-256
+* Take the first 16 bytes
diff --git a/84.md b/84.md
index ee416a5..1094f55 100644
--- a/84.md
+++ b/84.md
@@ -23,7 +23,7 @@ or obvious non-useful information from the query string.
 ### Attribution
 Clients MAY include one or more `p` tags, tagging the original authors of the material being highlighted; this is particularly
 useful when highlighting non-nostr content for which the client might be able to get a nostr pubkey somehow
-(e.g. prompting the user or reading a `<meta name="nostr:nprofile1..." />` tag on the document). A role MAY be included as the
+(e.g. prompting the user or reading a `<link rel="me" href="nostr:nprofile1..." />` tag on the document). A role MAY be included as the
 last value of the tag.
 ```jsonc
diff --git a/85.md b/85.md
new file mode 100644
index 0000000..587095d
--- /dev/null
+++ b/85.md
@@ -0,0 +1,166 @@
+NIP-85
+======
+Trusted Assertions
+------------------
+`draft` `optional`
+Certain Webs of Trust calculations require access to a large volume of events and/or computing power, making it virtually impossible to perform them directly on clients. This NIP allows users to offload such calculations to declared trusted service providers, and for these providers to publish signed "Trusted Assertion" events for the user client's consumption.
+## Assertion Events
+Trusted Assertions are always addressable (replaceable) events with the `d` tag pointing to the "subject" of the assertion. This NIP currently recognizes four distinct target "subjects" on which such calculations can be performed: *pubkeys*, *regular events*, *addressable events*, and *nip73 identifiers*. Each subject type is mapped to an event kind: 
+| Subject            | Event Kind     | `d` tag value     |
+| ------------------ | -------------- | ----------------- |
+| User               | 30382          | `<pubkey>`        |
+| Event              | 30383          | `<event_id>`      |
+| Addressable Event  | 30384          | `<event_address>` |
+| NIP-73 Identifier  | 30385          | `<i-tag>`         | 
+Calculation results are saved in pre-defined tags whose syntax and semantics are agreed upon by providers and clients. 
+Example of ranking a pubkey with a web of trust score of `89`: 
+```jsonc
+{
+  "kind": 30382,
+  "pubkey": "<service pubkey>",
+  "tags": [
+    ["d", "e88a691e98d9987c964521dff60025f60700378a4879180dcbbb4a5027850411"], // target user's public key
+    ["rank", "89"],
+  ],
+  "content": "",
+  //...
+}
+```
+Service providers MUST use different service keys for distinct algorithms, including a key per user when the algorithm is personalized to that user's point of view or settings.
+## Kind 30382: Users as Subject: 
+The following result types have been declared:
+| Result type             | Tag name               | Tag value format  |
+| ----------------------- | ---------------------- | ----------------- |
+| Follower Count          | `followers`            | int               |
+| User Rank               | `rank`                 | int, norm 0-100   |
+| First Post Time         | `first_created_at`     | unix timestamp    | 
+| Post Count              | `post_cnt`             | int               | 
+| Reply Count             | `reply_cnt`            | int               | 
+| Reactions Count         | `reactions_cnt`        | int               |
+| Zap Amount Received     | `zap_amt_recd`         | int, sats         |
+| Zap Amount Sent         | `zap_amt_sent`         | int, sats         | 
+| Zap Number Received     | `zap_cnt_recd`         | int               |
+| Zap Number Sent         | `zap_cnt_sent`         | int               |
+| Avg Zap Amount/day recd | `zap_avg_amt_day_recd` | int, sats         |
+| Avg Zap Amount/day sent | `zap_avg_amt_day_sent` | int, sats         |
+| Reports Received        | `reports_cnt_recd`     | int               |
+| Reports Sent            | `reports_cnt_sent`     | int               |
+| Common Topics           | `t`                    | string            |
+| Generally active start  | `active_hours_start`   | int, 0-24, UTC    |
+| Generally active end    | `active_hours_end`     | int, 0-24, UTC    |
+Each provider can offer their own ways to calculate such values. For instance, the Follower Count of one trust provider might remove the user's muted public keys while another provider keeps them. Users can then choose how they want to see this information in their preferred client by picking a provider that aligns with their view. 
+## Kind 30383: Events as Subject
+Providers can rate individual events with the following tags:  
+| Result type             | Tag name               | Tag value format  |
+| ----------------------- | ---------------------- | ----------------- |
+| Event Rank              | `rank`                 | int, norm 0-100   | 
+| Event Comment Count     | `comment_cnt`          | int               |
+| Event Quote Count       | `quote_cnt`            | int               |
+| Event Repost Count      | `repost_cnt`           | int               |
+| Event Reaction Count    | `reaction_cnt`         | int               |
+| Event Zap Count         | `zap_cnt`              | int               |     
+| Event Zap Amount        | `zap_amount`           | int, sats         |
+## Kind 30384: Addressables as Subject
+Providers can rate all versions of addressable events using the following tags: 
+| Result type               | Tag name               | Tag value format  |
+| ------------------------- | ---------------------- | ----------------- |
+| Address Rank              | `rank`                 | int, norm 0-100   | 
+| Address Comment Count     | `comment_cnt`          | int               |
+| Address Quote Count       | `quote_cnt`            | int               |
+| Address Repost Count      | `repost_cnt`           | int               |
+| Address Reaction Count    | `reaction_cnt`         | int               |
+| Address Zap Count         | `zap_cnt`              | int               |     
+| Address Zap Amount        | `zap_amount`           | int, sats         |
+## Kind 30385: External identifier as Subject
+Providers can rate books, locations, movies, websites, and hashtags using [NIP-73](73.md) identifiers. 
+| Result type       | Tag name               | Tag value format  |
+| ----------------- | ---------------------- | ----------------- |
+| Rank              | `rank`                 | int, norm 0-100   | 
+| Comment Count     | `comment_cnt`          | int               |
+| Reaction Count    | `reaction_cnt`         | int               |
+NIP-73 `k` tags should be added to the event as well.
+## Declaring Trusted Service Providers
+Kind `10040` lists the user's authorized providers for each result. Each `kind:tag` is followed by the `pubkey` of the service and the relay where the results are published. Users can specify these publicly or privately by JSON-stringifying and encrypting the tag list in the `.content` using NIP-44. 
+```js
+{
+  "kind": 10040,
+  "tags": [
+    ["<kind:tag>", "<service key>", "<relay hint>"],
+    // examples
+    ["30382:rank", "4fd5e210530e4f6b2cb083795834bfe5108324f1ed9f00ab73b9e8fcfe5f12fe", "wss://nip85.nostr.band"],
+    ["30382:rank", "3d842afecd5e293f28b6627933704a3fb8ce153aa91d790ab11f6a752d44a42d", "wss://nostr.wine"],
+    ["30382:zap_amt_sent", "4fd5e210530e4f6b2cb083795834bfe5108324f1ed9f00ab73b9e8fcfe5f12fe", "wss://nip85.nostr.band"],
+  ],
+  "content": nip44Encrypt(JSON.stringify([
+    ["<kind:tag>", "<service key>", "<relay hint>"],
+     // examples
+    ["30383:rank", "4fd5e210530e4f6b2cb083795834bfe5108324f1ed9f00ab73b9e8fcfe5f12fe", "wss://nip85.nostr.band"],
+    ["30384:rank", "4fd5e210530e4f6b2cb083795834bfe5108324f1ed9f00ab73b9e8fcfe5f12fe", "wss://nip85.nostr.band"],
+  ]),
+  //...
+}
+```
+If the provider offers several algorithms or multiple points of view of an algorithm, the key listed in each tag SHOULD point to the key created for each algorithm or point of view. 
+## Final Considerations
+Service providers SHOULD update Trusted Assertions as fast as new information arrives, but only if the contents of each event actually change to avoid re-downloading the same information.
+Service providers MAY limit access to the results by using paid relays.
+In TAs, `p`, `e`, and `a` tags with the same value as the `d` tag MAY be used to add a relay hint to the home relay of that user or event.
+## Appendix 1: Service provider discoverability
+Service Providers SHOULD sign a kind `0` of each service key that explains who controls the key and what the current version of the algorithm is about.
+```jsonc
+{
+  "kind": 0,
+  "pubkey": "<service pubkey>",
+  "tags": [],
+  "content": "{
+   \"name\" = \"Vitor's Brainstormer\", 
+   \"about\" = \"A Web of Trust algorithm from Vitor's point of view that considers Follows and Mutes, but no reports, and gives extra score points for anyone around Boston\",
+   \"picture\" = \"https://brainstorm.com/logo.png\",
+   \"website\" = \"https://brainstorm.com\"
+  }",
+  // other fields...
+}
+```
+Clients wishing to offer a list of Service Providers to their users SHOULD:
+1. Download kind `10040` events of the user's follow list
+2. Connect to each of the listed relays and download the kind `0` of the respective service keys
+3. Parse the kind `0` and collect the `website` property
+4. Load the OpenGraph tags of that website and display them as clickable items
diff --git a/86.md b/86.md
index 6f64eee..b9a8cc2 100644
--- a/86.md
+++ b/86.md
@@ -34,12 +34,18 @@ This is the list of **methods** that may be supported:
 * `banpubkey`:
  - params: `["<32-byte-hex-public-key>", "<optional-reason>"]`
  - result: `true` (a boolean always set to `true`)
+* `unbanpubkey`:
+  - params: `["<32-byte-hex-public-key>", "<optional-reason>"]`
+  - result: `true` (a boolean always set to `true`)
 * `listbannedpubkeys`:
  - params: `[]`
  - result: `[{"pubkey": "<32-byte-hex>", "reason": "<optional-reason>"}, ...]`, an array of objects
 * `allowpubkey`:
  - params: `["<32-byte-hex-public-key>", "<optional-reason>"]`
  - result: `true` (a boolean always set to `true`)
+* `unallowpubkey`:
+  - params: `["<32-byte-hex-public-key>", "<optional-reason>"]`
+  - result: `true` (a boolean always set to `true`)
 * `listallowedpubkeys`:
  - params: `[]`
  - result: `[{"pubkey": "<32-byte-hex>", "reason": "<optional-reason>"}, ...]`, an array of objects
diff --git a/87.md b/87.md
new file mode 100644
index 0000000..0010038
--- /dev/null
+++ b/87.md
@@ -0,0 +1,142 @@
+NIP-87
+======
+Ecash Mint Discoverability
+--------------------------------
+`draft` `optional`
+This NIP describes `kind:38173`, `kind:38172` and `kind:38000`: a way to discover ecash mints, their capabilities, and people who recommend them.
+## Rationale
+Nostr's discoverability and transparent event interaction is one of its most interesting/novel mechanics.
+This NIP provides a simple way for users to discover ecash mints recommended by other users and to interact with them.
+### Parties involved
+There are three actors to this workflow:
+* An ecash mint operator, announces their mint and its capabilities.
+    * Publishes `kind:38173` or `kind:38172`, detailing how to connect to it and its capabilities.
+* user A, who recommends an ecash mint
+    * Publishes `kind:38000`
+* user B, who seeks a recommendation for an ecash mint
+    * Queries for `kind:38000` and, based on results, queries for `kind:38173`/`kind:38172`
+## Events
+### Recommendation event
+```json
+{
+  "kind": 38000,
+  "pubkey": <recommender-user-pubkey>,
+  "tags": [
+    ["k", "38173"],
+    ["d", "<d-identifier>"],
+    ["u", <recommended-fedimint-invite-code>],
+    ["a", "38173:fedimint-pubkey:<d-identifier>", "wss://relay1"]
+  ],
+  "content": "I trust this mint with my life"
+}
+```
+The recommendation event is a parameterized-replaceable event so that a user can change edit their recommendation without creating a new event.
+The `d` tag in `kind:38000` is the `kind:38173`/`kind:38172` event identifier this event is recommending, if no event exists, the `d` tag can still be calculated from the mint's pubkey/id.
+The `k` tag is the kind number that corresponds to the event kind that the user is recommending, in this case `kind:38173` for fedimints and `kind:38172` for cashu mints.
+Optional `u` tags can be added to give a recommend way to connect to the mint.
+The value of the tag is the URL or invite code of the ecash mint.
+Multiple `u` tags can appear on the same `kind:38000`.
+`a` tags are used to point to the `kind:38173`/`kind:38172` event of the ecash mint.
+The first value of the tag is the `kind:38173`/`kind:38172` event identifier, the second value of the tag is a relay hint.
+This is used to correctly point to the mint's `kind:38173`/`kind:38172` event in case there are duplicates claiming to be the same mint.
+The content can be used to give a review.
+## Ecash Mint Information
+Cashu mints SHOULD publish `kind:38172` events to announce their capabilities and how to connect to them.
+For cashu mints, the `u` tag SHOULD be the URL to the cashu mint and it should list the nuts that the cashu mint supports.
+The `d` tag SHOULD be the mint's pubkey (found when querying `/v1/info`), this way users can query by pubkey and find the mint announcement.
+An `n` tag SHOULD be added to signify the network the cashu mint is on (either `mainnet`, `testnet`, `signet`, or `regtest`)
+```json
+{
+  "kind": 38172,
+  "pubkey": "<application-pubkey>",
+  "content": "<optional-kind:0-style-metadata>",
+  "tags": [
+    ["d", <cashu mint pubkey>],
+    ["u", "https://cashu.example.com"],
+    ["nuts", "1,2,3,4,5,6,7"],
+    ["n", "mainnet"]
+  ]
+}
+```
+Fedimints SHOULD publish `kind:38173` events to announce their capabilities and how to connect to them.
+For fedimints, it should list all known fedimint invite codes in `u` tags and it should list the modules it supports.
+The `d` tag SHOULD be the federation id, this way users can query by federation id and find the fedimint announcement.
+An `n` tag SHOULD be added to signify the network the fedimint is on (either `mainnet`, `testnet`, `signet`, or `regtest`)
+```json
+{
+  "kind": 38173,
+  "pubkey": "<application-pubkey>",
+  "content": "<optional-kind:0-style-metadata>",
+  "tags": [
+    ["d", <federation-id>],
+    ["u", "fed11abc.."],
+    ["u", "fed11xyz.."],
+    ["modules", "lightning,wallet,mint"],
+    ["n", "signet"]
+  ]
+}
+```
+* `content` is an optional `metadata`-like stringified JSON object, as described in NIP-01. This content is useful when the pubkey creating the `kind:38173` is not a normal user. If `content` is empty, the `kind:0` of the pubkey should be used to display mint information (e.g. name, picture, web, LUD16, etc.)
+## Example
+### User A recommends some mints
+User A might be a user of a cashu mint. Using a client, user A publishes an event recommending the cashu mint they use.
+```json
+{
+  "kind": 38000,
+  "tags": [
+    ["u", "fed11abc..", "fedimint"],
+    ["u", "https://cashu.example.com", "cashu"],
+    ["a", "38173:fedimint-pubkey:<d-identifier>", "wss://relay1", "fedimint"],
+    ["a", "38172:cashu-mint-pubkey:<d-identifier>", "wss://relay2", "cashu"]
+  ],
+  ...
+}
+```
+### User B finds a mint
+User B wants to use an ecash wallet, they need to find a mint.
+User B's wallet client queries for `kind:38000` events, looking for recommendations for ecash mints.
+```json
+["REQ", <id>, [{ "kinds": [38000], "authors": [<user>, <users-contact-list>], "#k": ["38173"] }]]
+```
+User B, who follows User A, sees that `kind:38000` event and tries to connect to the corresponding mints.
+### Alternative query bypassing `kind:38000`
+Alternatively, users might choose to query directly for `kind:38173` for an event kind. Clients SHOULD be careful doing this and use spam-prevention mechanisms or querying high-quality restricted relays to avoid directing users to malicious handlers.
+```json
+["REQ", <id>, [{ "kinds": [38173], "authors": [...] }]]
+```
diff --git a/88.md b/88.md
index 331cd27..9971623 100644
--- a/88.md
+++ b/88.md
@@ -48,7 +48,7 @@ Example Event
 The response event is a `kind:1018` event. It contains an e tag with the poll event it is referencing, followed by one or more response tags.
- **response** : The tag contains "response" as it's first positional argument followed by the option Id selected.
+- **response** : The tag contains "response" as its first positional argument followed by the option Id selected.
 The responses are meant to be published to the relays specified in the poll event.
diff --git a/89.md b/89.md
index 24aa3c5..dff4ea1 100644
--- a/89.md
+++ b/89.md
@@ -47,7 +47,7 @@ Multiple `a` tags can appear on the same `kind:31989`.
 The second value of the tag SHOULD be a relay hint.
 The third value of the tag SHOULD be the platform where this recommendation might apply.
-## Handler information
+### Handler information
 ```jsonc
 {
  "kind": 31990,
@@ -76,7 +76,7 @@ Multiple tags might be registered by the app, following NIP-19 nomenclature as t
 A tag without a second value in the array SHOULD be considered a generic handler for any NIP-19 entity that is not handled by a different tag.
-# Client tag
+## Client tag
 When publishing events, clients MAY include a `client` tag. Identifying the client that published the note. This tag is a tuple of `name`, `address` identifying a handler event and, a relay `hint` for finding the handler event. This has privacy implications for users, so clients SHOULD allow users to opt-out of using this tag.
 ```jsonc
diff --git a/90.md b/90.md
index 785b539..a33d90a 100644
--- a/90.md
+++ b/90.md
@@ -58,7 +58,7 @@ All tags are optional.
    * `<input-type>`: The way this argument should be interpreted. MUST be one of:
        * `url`: A URL to be fetched of the data that should be processed.
        * `event`: A Nostr event ID.
-        * `job`: The output of a previous job with the specified event ID. The dermination of which output to build upon is up to the service provider to decide (e.g. waiting for a signaling from the customer, waiting for a payment, etc.)
+        * `job`: The output of a previous job with the specified event ID. The determination of which output to build upon is up to the service provider to decide (e.g. waiting for a signaling from the customer, waiting for a payment, etc.)
        * `text`: `<data>` is the value of the input, no resolution is needed
    * `<relay>`: If `event` or `job` input-type, the relay where the event/job was published, otherwise optional or empty string
    * `<marker>`: An optional field indicating how this input should be used within the context of the job
@@ -68,7 +68,7 @@ All tags are optional.
 * `relays`: List of relays where Service Providers SHOULD publish responses to
 * `p`: Service Providers the customer is interested in. Other SPs MIGHT still choose to process the job
-## Encrypted Params
+### Encrypted Params
 If the user wants to keep the input parameters a secret, they can encrypt the `i` and `param` tags with the service provider's 'p' tag and add it to the content field. Add a tag `encrypted` as tags. Encryption for private tags will use [NIP-04 - Encrypted Direct Message encryption](04.md), using the user's private and service provider's public key for the shared secret
@@ -122,7 +122,7 @@ Service providers publish job results, providing the output of the job result. T
 * `amount`: millisats that the Service Provider is requesting to be paid. An optional third value can be a bolt11 invoice.
 * `i`: The original input(s) specified in the request.
-## Encrypted Output
+### Encrypted Output
 If the request has encrypted params, then output should be encrypted and placed in  `content` field. If the output is encrypted, then avoid including `i` tag with input-data as clear text.
 Add a tag encrypted to mark the output content as `encrypted`
@@ -180,7 +180,7 @@ Service providers can give feedback about a job back to the customer.
 Any job feedback event MIGHT include results in the `.content` field, as described in the [Job Result](#job-result-kind6000-6999) section. This is useful for service providers to provide a sample of the results that have been processed so far.
-# Protocol Flow
+## Protocol Flow
 * Customer publishes a job request (e.g. `kind:5000` speech-to-text).
 * Service Providers MAY submit `kind:7000` job-feedback events (e.g. `payment-required`, `processing`, `error`, etc.).
@@ -191,24 +191,24 @@ Job feedback (`kind:7000`) and Job Results (`kind:6000-6999`) events MAY include
 Customers can always either pay the included `bolt11` invoice or zap the event requesting the payment and service providers should monitor for both if they choose to include a bolt11 invoice.
-## Notes about the protocol flow
+### Notes about the protocol flow
 The flow is deliberately ambiguous, allowing vast flexibility for the interaction between customers and service providers so that service providers can model their behavior based on their own decisions/perceptions of risk.
 Some service providers might choose to submit a `payment-required` as the first reaction before sending a `processing` or before delivering results, some might choose to serve partial results for the job (e.g. a sample), send a `payment-required` to deliver the rest of the results, and some service providers might choose to assess likelihood of payment based on an npub's past behavior and thus serve the job results before requesting payment for the best possible UX.
 It's not up to this NIP to define how individual vending machines should choose to run their business.
-# Cancellation
+## Cancellation
 A job request might be canceled by publishing a `kind:5` delete request event tagging the job request event.
-# Appendix 1: Job chaining
+## Appendix 1: Job chaining
 A Customer MAY request multiple jobs to be processed as a chain, where the output of a job is the input of another job. (e.g. podcast transcription -> summarization of the transcription). This is done by specifying as input an event id of a different job with the `job` type.
 Service Providers MAY begin processing a subsequent job the moment they see the prior job's result, but they will likely wait for a zap to be published first. This introduces a risk that Service Provider of job #1 might delay publishing the zap event in order to have an advantage. This risk is up to Service Providers to mitigate or to decide whether the service provider of job #1 tends to have good-enough results so as to not wait for an explicit zap to assume the job was accepted.
 This gives a higher level of flexibility to service providers (which sophisticated service providers would take anyway).
-# Appendix 2: Service provider discoverability
+## Appendix 2: Service provider discoverability
 Service Providers MAY use NIP-89 announcements to advertise their support for job kinds:
 ```jsonc
diff --git a/96.md b/96.md
index 3828e76..28bc8a8 100644
--- a/96.md
+++ b/96.md
@@ -1,3 +1,5 @@
+> __Warning__  `unrecommended`: deprecated in favor of [NIP-B7](B7.md)
 NIP-96
 ======
diff --git a/99.md b/99.md
index 724ce5f..2b6a97a 100644
--- a/99.md
+++ b/99.md
@@ -8,7 +8,7 @@ Classified Listings
 This NIP defines `kind:30402`: an addressable event to describe classified listings that list any arbitrary product, service, or other thing for sale or offer and includes enough structured metadata to make them useful.
-The category of classifieds includes a very broad range of physical goods, services, work opportunities, rentals, free giveaways, personals, etc. and is distinct from the more strictly structured marketplaces defined in [NIP-15](15.md) that often sell many units of specific products through very specific channels.
+The specification supports a broad range of use cases physical goods, services, work opportunities, rentals, free giveaways, personals, etc. To promote interoperability between clients implementing NIP-99 for e-commerce, you can find the extension proposal [here](https://github.com/GammaMarkets/market-spec/blob/main/spec.md) which standardizes the e-commerce use case while maintaining the specification's lightweight and flexible nature. While [NIP-15](15.md) provides a strictly structured marketplace specification, NIP-99 has emerged as a simpler and more flexible alternative.
 The structure of these events is very similar to [NIP-23](23.md) long-form content events.
@@ -40,7 +40,7 @@ The following tags, used for structured metadata, are standardized and SHOULD be
  - `"<number>"` is the amount in numeric format (but included in the tag as a string)
  - `"<currency>"` is the currency unit in 3-character ISO 4217 format or ISO 4217-like currency code (e.g. `"btc"`, `"eth"`).
  - `"<frequency>"` is optional and can be used to describe recurring payments. SHOULD be in noun format (hour, day, week, month, year, etc.)
- - `"status"` (optional), the status of the listing. SHOULD be either "active" or "sold".
+- `"status"` (optional), the status of the listing. SHOULD be either "active" or "sold".
 #### `price` examples
@@ -48,7 +48,7 @@ The following tags, used for structured metadata, are standardized and SHOULD be
 - €15 per month `["price", "15", "EUR", "month"]`
 - £50,000 per year `["price", "50000", "GBP", "year"]`
-Other standard tags that might be useful.
+Other common tags that might be useful.
 - `"g"`, a geohash for more precise location
diff --git a/A0.md b/A0.md
new file mode 100644
index 0000000..884bf2a
--- /dev/null
+++ b/A0.md
@@ -0,0 +1,60 @@
+NIP-A0
+======
+Voice Messages
+-----------
+**Status:** Draft
+This NIP defines new events `kind: 1222` for root messages and `kind: 1244` for reply messages to be used for short voice messages, typically up to 60 seconds in length.
+## Specification
+### Event Kind `1222` and Kind `1244`
+The `kind: 1222` event is defined as follows:
+-   `content`: MUST be a URL pointing directly to an audio file.
+    -   The audio file SHOULD be in `audio/mp4` (.m4a) format using AAC or Opus encoding. Clients MAY support other common audio formats like `audio/ogg`, `audio/webm`, or `audio/mpeg` (mp3), but `audio/mp4` is recommended for broad compatibility and efficiency.
+    -   The audio duration SHOULD be no longer than 60 seconds. Clients publishing `kind: 1222` events SHOULD enforce this limit or provide a clear warning to the user if exceeded.
+-   `tags`:
+    -   Tags MAY be included as per other NIPs (e.g., `t` for hashtags, `g` for geohash, etc.).
+  The `kind: 1244` event is defined as follows:
+  
+-    To be used for replies, `kind: 1244` events MUST follow the structure of `NIP-22`.
+-   `content`: MUST be a URL pointing directly to an audio file.
+    -   The audio file SHOULD be in `audio/mp4` (.m4a) format using AAC or Opus encoding. Clients MAY support other common audio formats like `audio/ogg`, `audio/webm`, or `audio/mpeg` (mp3), but `audio/mp4` is recommended for broad compatibility and efficiency.
+    -   The audio duration SHOULD be no longer than 60 seconds. Clients publishing `kind: 1222` events SHOULD enforce this limit or provide a clear warning to the user if exceeded.
+-   `tags`:
+    -   Tags MAY be included as per other NIPs (e.g., `t` for hashtags, `g` for geohash, etc.).
+## Visual representation with `imeta` (NIP-92) tag (optional)
+The following imeta (NIP-92) tags MAY be included so clients can render a visual preview without having to download the audio file first:
+- `waveform`: amplitude values over time, space separated full integers, less than 100 values should be enough to render a nice visual
+- `duration`: audio length in seconds
+## Examples
+### Root Voice Message Example
+```json
+{
+  "content": "https://blossom.primal.net/5fe7df0e46ee6b14b5a8b8b92939e84e3ca5e3950eb630299742325d5ed9891b.mp4",
+  "created_at": 1752501052,
+  "id": "...",
+  "kind": 1222,
+  "pubkey": "...",
+  "sig": "...",
+  "tags": [
+    [
+      "imeta",
+      "url https://blossom.primal.net/5fe7df0e46ee6b14b5a8b8b92939e84e3ca5e3950eb630299742325d5ed9891b.mp4",
+      "waveform 0 7 35 8 100 100 49 8 4 16 8 10 7 2 20 10 100 100 100 100 100 100 15 100 100 100 25 60 5 4 3 1 0 100 100 15 100 29 88 0 33 11 39 100 100 19 4 100 42 35 5 0 1 5 0 0 11 38 100 94 17 11 44 58 5 100 100 100 55 14 72 100 100 57 6 1 14 2 16 100 100 40 16 100 100 6 32 14 13 41 36 16 14 6 3 0 1 2 1 6 0",
+      "duration 8"
+    ]
+  ]
+}
+\ No newline at end of file
diff --git a/A4.md b/A4.md
new file mode 100644
index 0000000..36751c1
--- /dev/null
+++ b/A4.md
@@ -0,0 +1,56 @@
+NIP-A4
+======
+Public Messages
+---------------
+`draft` `optional`
+This NIP defines kind `24` as a simple plaintext message to one or more Nostr users. 
+The `.content` contains the message. `p` tags identify one or more receivers.
+```jsonc
+{
+  "pubkey": "<sender-pubkey>",
+  "kind": 24,
+  "tags": [
+    ["p", "<receiver>", "<relay-url>"],
+  ],
+  "content": "<message-in-plain-text>",
+}
+```
+Messages MUST be sent to the [NIP-65](65.md) inbox relays of each receiver and the outbox relay of the sender.
+Kind `24` is designed to be shown and replied to from notification screens. The goal is to allow clients to 
+support this feature without having to worry about chat history. There are no message chains. The concept of a 
+"thread", a "thread root", or a "chatroom" does not exist in this system, as messages can start and continue 
+without any syntactic connection to each other. `e` tags must not be used.
+This kind is not designed to be displayed on feeds, but anyone can see and reply to messages that may not be for them.
+## Advanced Support
+[NIP-40](40.md) `expiration` tags are recommended. Since there is no concept of a chatroom, it is unlikely that these messages will 
+make sense as time goes on.
+[NIP-18](18.md) quote repost `q` tags MAY be used when citing events in the `.content` with [NIP-21](21.md).
+```json
+["q", "<event-id> or <event-address>", "<relay-url>", "<pubkey-if-a-regular-event>"]
+```
+[NIP-25](25.md) reactions MUST add a `k` tag to `24`. 
+[NIP-57](57.md) zaps MUST include the `k` tag to `24`
+[NIP-21](21.md) links that use [NIP-19](19.md)'s `nevent1` MUST include a `kind` of `24`. Links that are not `kind:24` are not expected to be rendered natively by the client.
+[NIP-92](92.md) `imeta` tags SHOULD be added for image and video links.
+## Warnings
+There MUST be no expectation of privacy in this kind. It is just a public reply, but without a root note.
+Avoid confusing this kind with Kind `14` rumors in [NIP-17](17.md) DMs. This kind is signed and designed for public consumption.
diff --git a/B0.md b/B0.md
index 0dcefa7..22ed910 100644
--- a/B0.md
+++ b/B0.md
@@ -6,31 +6,23 @@ Web Bookmarking
 `draft` `optional`
-This NIP defines `kind:39701` (an _addressable event_) for a URI as a web bookmark which uses the HTTP (Hypertext transfer protocol) scheme.
+This NIP defines `kind:39701` for a URI as editable web bookmark which uses the HTTP scheme.
-These web bookmark events are _addressable_ and deletable per [NIP-09](09.md).
-### Editability
-Web bookmarks are meant to be editable, so they should include a `d` tag with an identifier for the bookmark. Clients should take care to only publish and read these events from relays that implement that. If they don't do that they should also take care to hide old versions of the same bookmark they may receive.
 ### Format
-The format uses an _addressable event_ of `kind:39701`.
+The format uses `kind:39701`.
-The `.content` of these events should be a detailed description of the web bookmark. It is required but can be an empty string.
+The `.content` should be a detailed description of the web bookmark. It can be an empty string.
-The `d` tag is required.
+The `d` tag is just their URL without the scheme, which is always and everywhere assumed to be `https://` or `http://`.
-In this way web bookmarks events can be queried by the `d` tag by clients, which is just their URL without the scheme, which is always and everywhere assumed to be `https://` or `http://`.
+In this way web bookmarks events can be queried by the `d` tag by clients.
-The querystring and the hash must be removed entirely, unless their requirement is explicitly stated either by the user or by some hardcoded list of URLs that rely on querystrings for basic routing provided by the client.
 ### Metadata
-For the date of the last update the `.created_at` field should be used. For "tags"/"hashtags" (i.e. topics about which the event might be of relevance) the `t` tag should be used.
+Metadata fields can be added as tags to the event as necessary.
-Other metadata fields can be added as tags to the event as necessary.
+* `"t"`, for "tags"/"hashtags" (i.e. topics about which the event might be of relevance)
 * `"published_at"`, for the timestamp in unix seconds (stringified) of the first time the bookmark was published
 * `"title"`, title about bookmark and can be used as a attribute for the HTML link element
diff --git a/BE.md b/BE.md
new file mode 100644
index 0000000..50062d9
--- /dev/null
+++ b/BE.md
@@ -0,0 +1,137 @@
+NIP-BE
+======
+Nostr BLE Communications Protocol
+---------------------------------
+`draft` `optional`
+This NIP specifies how Nostr apps can use BLE to communicate and synchronize with each other. The BLE protocol follows a client-server pattern, so this NIP emulates the WS structure in a similar way, but with some adaptations to its limitations.
+## Device advertisement
+A device advertises itself with:
+- Service UUID: `0000180f-0000-1000-8000-00805f9b34fb`
+- Data: Device UUID in ByteArray format
+## GATT service
+The device exposes a Nordic UART Service with the following characteristics:
+1. Write Characteristic
+   - UUID: `87654321-0000-1000-8000-00805f9b34fb`
+   - Properties: Write
+2. Read Characteristic
+   - UUID: `12345678-0000-1000-8000-00805f9b34fb`
+   - Properties: Notify, Read
+## Role assignment
+When one device initially finds another advertising the service, it will read the service's data to get the device UUID and compare it with its own advertised device UUID. For this communication, the device with the highest ID will take the role of GATT Server (Relay), the other will be considered the GATT Client (Client) and will proceed to establish the connection.
+For devices whose purpose will require a single role, its device UUID will always be:
+- GATT Server: `FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF`
+- GATT Client: `00000000-0000-0000-0000-000000000000`
+## Messages
+All messages will follow [NIP-01](/01.md) message structure. For a given message, a compression stream (DEFLATE) is applied to the message to generate a byte array. Depending on the BLE version, the byte array can be too large for a single message (20-23 bytes in BLE 4.2, 256 bytes in BLE > 4.2). In that case, this byte array is split into any number of batches following the structure:
+```
+[batch index (first 2 bytes)][batch n][is last batch (last byte)]
+```
+After reception of all batches, the other device can then join them and decompress. To ensure reliability, only 1 message will be read/written at a time. MTU can be negotiated in advance. The maximum size for a message is 64KB; bigger messages will be rejected.
+## Examples
+This example implements a function to split and compress a byte array into chunks, as well as another function to join and decompress them in order to obtain the initial result:
+```kotlin
+fun splitInChunks(message: ByteArray): Array<ByteArray> {
+   val chunkSize = 500 // define the chunk size
+   var byteArray = compressByteArray(message)
+   val numChunks = (byteArray.size + chunkSize - 1) / chunkSize // calculate the number of chunks
+   var chunkIndex = 0
+   val chunks = Array(numChunks) { ByteArray(0) }
+   for (i in 0 until numChunks) {
+         val start = i * chunkSize
+         val end = minOf((i + 1) * chunkSize, byteArray.size)
+         val chunk = byteArray.copyOfRange(start, end)
+         // add chunk index to the first 2 bytes and last chunk flag to the last byte
+         val chunkWithIndex = ByteArray(chunk.size + 2)
+         chunkWithIndex[0] = chunkIndex.toByte() // chunk index
+         chunk.copyInto(chunkWithIndex, 1)
+         chunkWithIndex[chunkWithIndex.size - 1] = numChunks.toByte()
+         // store the chunk in the array
+         chunks[i] = chunkWithIndex
+         chunkIndex++
+   }
+   return chunks
+}
+fun joinChunks(chunks: Array<ByteArray>): ByteArray {
+   val sortedChunks = chunks.sortedBy { it[0] }
+   var reassembledByteArray = ByteArray(0)
+   for (chunk in sortedChunks) {
+         val chunkData = chunk.copyOfRange(1, chunk.size - 1)
+         reassembledByteArray = reassembledByteArray.copyOf(reassembledByteArray.size + chunkData.size)
+         chunkData.copyInto(reassembledByteArray, reassembledByteArray.size - chunkData.size)
+   }
+   return decompressByteArray(reassembledByteArray)
+}
+```
+## Workflows
+### Client to relay
+- Any message the client wants to send to a relay will be a write message.
+- Any message the client receives from a relay will be a read message.
+### Relay to client
+The relay should notify the client about any new event matching subscription's filters by using the Notify action of the Read Characteristic. After that, the client can proceed to read messages from the relay.
+### Device synchronization
+Given the nature of BLE, it is expected that the direct connection between two devices might be extremely intermittent, with gaps of hours or even days. That's why it's crucial to define a synchronization process by following [NIP-77](./77.md) but with an adaptation to the limitations of the technology.
+After two devices have successfully connected and established the Client-Server roles, the devices will use half-duplex communication to intermittently send and receive messages.
+#### Half-duplex synchronization
+Right after the 2 devices connect, the Client starts the workflow by sending the first message.
+1. Client - Writes ["NEG-OPEN"](/77.md#initial-message-client-to-relay) message.
+2. Server - Sends `write-success`.
+3. Client - Sends `read-message`.
+4. Server - Responds with ["NEG-MSG"](./77.md#subsequent-messages-bidirectional) message.
+5. Client -
+   1. If the Client has messages missing on the Server, it writes one `EVENT`.
+   2. If the Client doesn't have any messages missing on the Server, it writes `EOSE`. In this case, subsequent messages to the Server will be empty while the Server claims to have more notes for the Client.
+6. Server - Sends `write-success`.
+7. Client - Sends `read-message`.
+8. Server -
+   1. If the Server has messages missing on the Client, it responds with one `EVENT`.
+   2. If the Client doesn't have any messages missing on the Server, it responds with `EOSE`. In this case, subsequent responses to the Client will be empty.
+9. If the Client detects that the devices are not synchronized yet, jump to step 5.
+10. After the two devices detect that there are no more missing events on both ends, the workflow will pause at this point.
+#### Half-duplex event spread
+While two devices are connected and synchronized, it might happen that one of them receives a new message from another connected peer. Devices MUST keep track of which notes have been sent to its peers while they are connected. If the newly received event is detected as missing in one of the connected and synchronized peers:
+1. If the peer is a Server:
+   1. Client - It writes the `EVENT`.
+   2. Server - Sends `write-success`.
+2. If the peer is a Client:
+   1. Server - It will send an empty notification to the Client.
+   2. Client - Sends `read-message`.
+   3. Server - Responds with the `EVENT`.
diff --git a/BREAKING.md b/BREAKING.md
deleted file mode 100644
index c620a3f..0000000
--- a/BREAKING.md
+++ /dev/null
@@ -1,68 +0,0 @@
-# Breaking Changes
-This is a history of NIP changes that potentially break pre-existing implementations, in
-reverse chronological order.
-| Date        | Commit    | NIP      | Change |
-| ----------- | --------- | -------- | ------ |
-| 2025-02-14  | [81908b6e](https://github.com/nostr-protocol/nips/commit/81908b6e) | [07](07.md), [46](46.md), [55](55.md) | `getRelays` and `get_relays` were removed |
-| 2025-02-07  | [0023ca81](https://github.com/nostr-protocol/nips/commit/0023ca81) | [10](10.md) | `"mention"` marker was removed |
-| 2025-01-31  | [6a4b125a](https://github.com/nostr-protocol/nips/commit/6a4b125a) | [71](71.md) | video events were changed to regular |
-| 2024-12-05  | [6d16019e](https://github.com/nostr-protocol/nips/commit/6d16019e) | [46](46.md) | message encryption was changed to NIP-44 |
-| 2024-11-12  | [2838e3bd](https://github.com/nostr-protocol/nips/commit/2838e3bd) | [29](29.md) | `kind: 12` and `kind: 10` were removed (use `kind: 1111` instead) |
-| 2024-11-12  | [926a51e7](https://github.com/nostr-protocol/nips/commit/926a51e7) | [46](46.md) | NIP-05 login was removed |
-| 2024-11-12  | [926a51e7](https://github.com/nostr-protocol/nips/commit/926a51e7) | [46](46.md) | `create_account` method was removed |
-| 2024-11-12  | [926a51e7](https://github.com/nostr-protocol/nips/commit/926a51e7) | [46](46.md) | `connect` params and result were changed |
-| 2024-10-29  | [f1e8d2c4](https://github.com/nostr-protocol/nips/commit/f1e8d2c4) | [46](46.md) | bunker URL should use `remote-signer-key` |
-| 2024-10-15  | [1cda2dcc](https://github.com/nostr-protocol/nips/commit/1cda2dcc) | [71](71.md) | some tags were replaced with `imeta` tag |
-| 2024-10-15  | [1cda2dcc](https://github.com/nostr-protocol/nips/commit/1cda2dcc) | [71](71.md) | `kind: 34237` was dropped |
-| 2024-10-07  | [7bb8997b](https://github.com/nostr-protocol/nips/commit/7bb8997b) | [55](55.md) | some fields and passing data were changed |
-| 2024-08-18  | [3aff37bd](https://github.com/nostr-protocol/nips/commit/3aff37bd) | [54](54.md) | content should be Asciidoc |
-| 2024-07-31  | [3ea2f1a4](https://github.com/nostr-protocol/nips/commit/3ea2f1a4) | [45](45.md) | [444ad28d](https://github.com/nostr-protocol/nips/commit/444ad28d) was reverted |
-| 2024-07-30  | [444ad28d](https://github.com/nostr-protocol/nips/commit/444ad28d) | [45](45.md) | NIP-45 was deprecated |
-| 2024-07-26  | [ecee40df](https://github.com/nostr-protocol/nips/commit/ecee40df) | [19](19.md) | `nrelay` was deprecated |
-| 2024-07-23  | [0227a2cd](https://github.com/nostr-protocol/nips/commit/0227a2cd) | [01](01.md) | events should be sorted by id after created_at |
-| 2024-06-06  | [58e94b20](https://github.com/nostr-protocol/nips/commit/58e94b20) | [25](25.md) | [8073c848](https://github.com/nostr-protocol/nips/commit/8073c848) was reverted |
-| 2024-06-06  | [a6dfc7b5](https://github.com/nostr-protocol/nips/commit/a6dfc7b5) | [55](55.md) | NIP number was changed |
-| 2024-05-25  | [5d1d1c17](https://github.com/nostr-protocol/nips/commit/5d1d1c17) | [71](71.md) | `aes-256-gcm` tag was removed |
-| 2024-05-07  | [8073c848](https://github.com/nostr-protocol/nips/commit/8073c848) | [25](25.md) | e-tags were changed to not include entire thread |
-| 2024-04-30  | [bad88262](https://github.com/nostr-protocol/nips/commit/bad88262) | [34](34.md) | `earliest-unique-commit` tag was removed (use `r` tag instead) |
-| 2024-02-25  | [4a171cb0](https://github.com/nostr-protocol/nips/commit/4a171cb0) | [18](18.md) | quote repost should use `q` tag |
-| 2024-02-21  | [c6cd655c](https://github.com/nostr-protocol/nips/commit/c6cd655c) | [46](46.md) | Params were stringified |
-| 2024-02-16  | [cbec02ab](https://github.com/nostr-protocol/nips/commit/cbec02ab) | [49](49.md) | Password first normalized to NFKC |
-| 2024-02-15  | [afbb8dd0](https://github.com/nostr-protocol/nips/commit/afbb8dd0) | [39](39.md) | PGP identity was removed |
-| 2024-02-07  | [d3dad114](https://github.com/nostr-protocol/nips/commit/d3dad114) | [46](46.md) | Connection token format was changed |
-| 2024-01-30  | [1a2b21b6](https://github.com/nostr-protocol/nips/commit/1a2b21b6) | [59](59.md) | `p` tag became optional |
-| 2023-01-27  | [c2f34817](https://github.com/nostr-protocol/nips/commit/c2f34817) | [47](47.md) | optional expiration tag should be honored |
-| 2024-01-10  | [3d8652ea](https://github.com/nostr-protocol/nips/commit/3d8652ea) | [02](02.md), [51](51.md) | list entries should be chronological |
-| 2023-12-30  | [29869821](https://github.com/nostr-protocol/nips/commit/29869821) | [52](52.md) | `name` tag was removed (use `title` tag instead) |
-| 2023-12-27  | [17c67ef5](https://github.com/nostr-protocol/nips/commit/17c67ef5) | [94](94.md) | `aes-256-gcm` tag was removed |
-| 2023-12-03  | [0ba45895](https://github.com/nostr-protocol/nips/commit/0ba45895) | [01](01.md) | WebSocket status code `4000` was replaced by `CLOSED` message |
-| 2023-11-28  | [6de35f9e](https://github.com/nostr-protocol/nips/commit/6de35f9e) | [89](89.md) | `client` tag value was changed |
-| 2023-11-20  | [7822a8b1](https://github.com/nostr-protocol/nips/commit/7822a8b1) | [51](51.md) | `kind: 30001` was deprecated |
-| 2023-11-20  | [7822a8b1](https://github.com/nostr-protocol/nips/commit/7822a8b1) | [51](51.md) | the meaning of `kind: 30000` was changed |
-| 2023-11-11  | [cbdca1e9](https://github.com/nostr-protocol/nips/commit/cbdca1e9) | [84](84.md) | `range` tag was removed |
-| 2023-11-10  | [c945d8bd](https://github.com/nostr-protocol/nips/commit/c945d8bd) | [32](32.md) | `l` tag annotations was removed |
-| 2023-11-07  | [108b7f16](https://github.com/nostr-protocol/nips/commit/108b7f16) | [01](01.md) | `OK` message must have 4 items |
-| 2023-10-17  | [cf672b76](https://github.com/nostr-protocol/nips/commit/cf672b76) | [03](03.md) | `block` tag was removed |
-| 2023-09-29  | [7dc6385f](https://github.com/nostr-protocol/nips/commit/7dc6385f) | [57](57.md) | optional `a` tag was included in `zap receipt` |
-| 2023-08-21  | [89915e02](https://github.com/nostr-protocol/nips/commit/89915e02) | [11](11.md) | `min_prefix` was removed |
-| 2023-08-20  | [37c4375e](https://github.com/nostr-protocol/nips/commit/37c4375e) | [01](01.md) | replaceable events with same timestamp should be retained event with lowest id |
-| 2023-08-15  | [88ee873c](https://github.com/nostr-protocol/nips/commit/88ee873c) | [15](15.md) | `countries` tag was renamed to `regions` |
-| 2023-08-14  | [72bb8a12](https://github.com/nostr-protocol/nips/commit/72bb8a12) | [12](12.md), [16](16.md), [20](20.md), [33](33.md) | NIP-12, 16, 20 and 33 were merged into NIP-01 |
-| 2023-08-11  | [d87f8617](https://github.com/nostr-protocol/nips/commit/d87f8617) | [25](25.md) | empty `content` should be considered as "+" |
-| 2023-08-01  | [5d63b157](https://github.com/nostr-protocol/nips/commit/5d63b157) | [57](57.md) | `zap` tag was changed |
-| 2023-07-15  | [d1814405](https://github.com/nostr-protocol/nips/commit/d1814405) | [01](01.md) | `since` and `until` filters should be `since <= created_at <= until` |
-| 2023-07-12  | [a1cd2bd8](https://github.com/nostr-protocol/nips/commit/a1cd2bd8) | [25](25.md) | custom emoji was supported |
-| 2023-06-18  | [83cbd3e1](https://github.com/nostr-protocol/nips/commit/83cbd3e1) | [11](11.md) | `image` was renamed to `icon` |
-| 2023-04-13  | [bf0a0da6](https://github.com/nostr-protocol/nips/commit/bf0a0da6) | [15](15.md) | different NIP was re-added as NIP-15 |
-| 2023-04-09  | [fb5b7c73](https://github.com/nostr-protocol/nips/commit/fb5b7c73) | [15](15.md) | NIP-15 was merged into NIP-01 |
-| 2023-03-29  | [599e1313](https://github.com/nostr-protocol/nips/commit/599e1313) | [18](18.md) | NIP-18 was bring back |
-| 2023-03-15  | [e1004d3d](https://github.com/nostr-protocol/nips/commit/e1004d3d) | [19](19.md) | `1: relay` was changed to optionally |
-Breaking changes prior to 2023-03-01 are not yet documented.
-## NOTES
- If it isn't clear that a change is breaking or not, we list it.
- The date is the date it was merged, not necessarily the date of the commit.
diff --git a/C0.md b/C0.md
index c88e145..de78fe8 100644
--- a/C0.md
+++ b/C0.md
@@ -23,9 +23,9 @@ The `.content` field contains the actual code snippet text.
 - `extension` - File extension (without the dot). Examples: "js", "py", "rs"
 - `description` - Brief description of what the code does
 - `runtime` - Runtime or environment specification (e.g., "node v18.15.0", "python 3.11")
- `license` - License under which the code is shared (e.g., "MIT", "GPL-3.0", "Apache-2.0")
+- `license` - License under which the code (along with any related data contained within the event, when available, such as the description) is shared. This MUST be a standard [SPDX](https://spdx.org/licenses/) short identifier (e.g., "MIT", "GPL-3.0-or-later", "Apache-2.0") when available. An additional parameter containing a reference to the actual text of the license MAY be provided. This tag can be repeated, to indicate multi-licensing, allowing recipients to use the code under any license of choosing among the referenced ones
 - `dep` - Dependency required for the code to run (can be repeated)
- `repo` - Reference to a repository where this code originates
+- `repo` - Reference to a repository where this code originates. This MUST be either a standard URL or, alternatively, the address of a [NIP-34](34.md) Git repository announcement event in the form `"30617:<32-bytes hex a pubkey>:<d tag value>"`. If a repository announcement is referenced, a recommended relay URL where to find the event should be provided as an additional parameter
 ## Format
diff --git a/EE.md b/EE.md
new file mode 100644
index 0000000..dacb152
--- /dev/null
+++ b/EE.md
@@ -0,0 +1,292 @@
+> __Warning__  `unrecommended`: superseded by the [Marmot Protocol](https://github.com/marmot-protocol/marmot)
+NIP-EE
+======
+E2EE Messaging using the Messaging Layer Security (MLS) Protocol
+----------------------------------------------------------------
+`final` `unrecommended` `optional`
+This NIP standardizes how to use the [MLS Protocol](https://www.rfc-editor.org/rfc/rfc9420.html) with Nostr for efficient and E2EE (end-to-end encrypted) direct and group messaging.
+## Context
+Originally, one-to-one direct messages (DMs) in Nostr happened via the scheme defined in [NIP-04](04.md). This NIP is not recommended because, while it encrypts the content of the message (provides decent confidentiality), it leaks significant amounts of metadata about the parties involved in the conversation (completely lacks privacy).
+With the addition of [NIP-44](44.md), we have an updated encryption scheme that improves confidentiality guarantees but stops short of defining a new scheme for doing direct messages using this encryption scheme. Hence, makes little to no difference to privacy.
+Most recently, [NIP-17](17.md) combines [NIP-44](44.md) encryption with [NIP-59](59.md) gift-wrapping to hide the encrypted direct message inside another set of events to ensure that it's impossible to see who is talking to who and when messages passed between the users. This largely solves the metadata leakage problem; while it's still possible to see that a user is receiving gift-wrapped events, you can't tell from whom and what kind of events are within the gift-wrap outer event. This gives some degree of deniability/repudiation but doesn't solve forward secrecy or post compromise security. That is to say, if a user's private key (or the calculated conversation key shared between two users used to encrypt messages) is compromised, the attacker will have full access to all past and future DMs sent between those users.
+In addition, neither [NIP-04](04.md) or [NIP-17](17.md) attempt to solve the problem of group messages.
+### Why is this important?
+Without proper E2EE, Nostr cannot be used as the protocol for secure messaging clients. While clients like Signal do a fantastic job with E2EE, they still rely on centralized servers and as a result can be shut down by a powerful (i.e. state-level) actor. The goal of Nostr is not only to protect against centralized entities censoring you and your communications, but also protect against the ability of a state-level actor to stop these sorts of services from existing in the first place. By replacing centralized servers with decentralized relays, we make it nearly impossible for a centralized actor to completely stop communications between individual users.
+### Goals of this NIP
+1. Private _and_ Confidential DMs and Group messages
+   1. **Private** means that an observer cannot tell that Alice and Bob are talking to one another, or that Alice is part of a specific group. This necessarily requires protecting metadata.
+   2. **Confidential** means that the contents of conversations can only be viewed by the intended recipients.
+2. Forward secrecy and Post-compromise security
+   1. **Forward secrecy** means that encrypted content in the past remains encrypted even if a key material is leaked.
+   2. **Post compromise security** means that leaking key material doesn't allow an attacker to continue to read messages indefinitely into the future.
+3. Scales efficiently for large groups
+4. Allows for the use of multiple device/clients in a single conversation/group.
+### Why MLS?
+This scheme adapts the Message Layer Security (MLS) protocol for use with Nostr. You can think of MLS as an evolution of the Signal Protocol. However, it significantly improves the scalability of encryption operations for large group messaging significantly (linear -> log), is built to accommodate federated environments, and also allows for graceful updating of ciphersuites and versions over time. In addition, it's very flexible and agnostic about the message content that is sent.
+It's beyond the scope of this NIP to explain the MLS protocol but you can read more about it in it's [Architectural Overview](https://www.ietf.org/archive/id/draft-ietf-mls-architecture-13.html) or the [RFC](https://www.rfc-editor.org/rfc/rfc9420). MLS is on track to become an internet standard under the IETF so the protocol itself is extremely well vetted and researched. This also means there is the potential for cross network messaging interoperability in the future as MLS gains more adoption.
+## Core MLS Concepts
+From the [MLS Architectural Overview](https://www.ietf.org/archive/id/draft-ietf-mls-architecture-13.html):
+> MLS provides a way for clients to form groups within which they can communicate securely. For example, a set of users might use clients on their phones or laptops to join a group and communicate with each other. A group may be as small as two clients (e.g., for simple person to person messaging) or as large as hundreds of thousands. A client that is part of a group is a member of that group. As groups change membership and group or member properties, they advance from one epoch to another and the cryptographic state of the group evolves.
+>
+> The group is represented as a tree, which represents the members as the leaves of a tree. It is used to efficiently encrypt to subsets of the members. Each member has a state called a LeafNode object holding the client's identity, credentials, and capabilities.
+The MLS protocol's job is to manage and evolve the cryptographic state of a group. This includes managing the membership of a group, the cryptographic state of a group (ratchet tree, keys, and encryption/decryption/authentication of messages), and managing the evolution of the group over time.
+### Groups
+Groups are created by their first member, who then invites one or more other members. Groups evolve over time in blocks called `Epochs`. New epochs are proposed via one ore more `Proposal` messages and then committed to via a `Commit` message.
+### Clients
+The device/client pair (e.g. Primal on iOS or Coracle on web) with which a user joins the group is represented as a `LeafNode` in the tree. The terms `Client` and `Member` are interchangeable in this regard. It is not possible to share group state across multiple `Clients`. If a user joins a group from 2 separate devices, their state is separate and they will be tracked as 2 separate members of the group.
+### Messages
+There are several different types of messages sent within a group. Some of these are control messages that are used to update the group state over time. These include `Welcome`, `Proposal`, and `Commit` messages. Others are the actual messages that are sent between members in a group. These include `Application` messages.
+Messages in MLS are "framed". Meaning that they are wrapped in a data structure that includes information about the sender, the epoch, the message index within the epoch and the message content. This framing makes it possible to authenticate and decrypt messages correctly, even if they arrive out of order.
+MLS is agnostic to the "content" of the messages that are sent. This is a key feature of MLS that allows for the use of MLS for a wide variety of applications.
+MLS is also agnostic to the transport protocol that is used to send messages. Obviously for us, we'll be using websockets, Nostr events and relays.
+## The focus of this NIP
+This NIP focuses on how to use Nostr to perform the Authentication Service and Delivery Service functions required by the MLS protocol. Most clients will choose to use an MLS implementation to handle keys, ratcheting, group state management, and other aspects of the MLS protocol itself. [OpenMLS](https://github.com/openmls/openmls) is the most actively developed library that implements MLS.
+This NIP specifies the following:
+1. A standardized way that Nostr clients should [create MLS groups](#creating-groups).
+2. The required format of the MLS [`Credential`](#mls-credentials) that Nostr clients should use to represent a Nostr user in a group.
+3. The structure of [KeyPackage Events](#keypackage-event-and-signing-keys) published to relays that allow Nostr users to be added to a group asynchronously.
+4. The structure of [Group Events](#group-events) published to relays that represent the evolution of a group's state and the contents of the messages sent in the group.
+## Security Considerations
+This is a concise overview of the security trade-offs and considerations of this NIP in various scenarios. The NIP strives to fully maintain MLS security guarantees.
+### Forward Secrecy and Post-compromise Security
+- As per the MLS spec, keys are deleted as soon as they are used to encrypt or decrypt a message. This is usually handled by the MLS implementation library itself but attention needs to be paid by clients to ensure they're not storing secrets (especially the [exporter secret](#group-events)) for longer than absolutely necessary.
+- This NIP maintains MLS forward secrecy and post-compromise security guarantees. You can read more about those in the MLS Architectural Overview section on [Forward Secrecy and Post-compromise Security](https://www.ietf.org/archive/id/draft-ietf-mls-architecture-15.html#name-forward-and-post-compromise).
+### Leakage of various keys
+- This NIP does not depend on a user's Nostr identity key for any aspect of the MLS messaging protocol. Compromise of a user's Nostr identity key does not give access to past or future messages in any MLS-based group.
+- For a complete discussion of MLS key leakage, please see the Endpoint Compromise section of the [MLS Architectural Overview](https://www.ietf.org/archive/id/draft-ietf-mls-architecture-15.html#name-endpoint-compromise).
+### Metadata
+- The only group specific metadata published to relays is the Nostr group ID value. This value is used to identify the group in the `h` tag of the Group Message Event (`kind: 445`). These events are published ephemerally and this Nostr group ID value can be updated over the lifetime of the group by group admins. This is a tradeoff to ensure that group participants and group size are obfuscated but still makes it possible to efficiently fan out group messages to all participants. The content field of this event is a value encrypted in two separate ways (using NIP-44 and MLS) with MLS group state/keys. Only group members with up-to-date group state can decrypt and read these messages.
+- A user's key package events can be used one or more times to be added to groups. There is a tradeoff inherent here: Reusing key packages (initial signing keys) carries some degree of risk but this risk is mitigated as long as a user rotates their signing key immediately upon joining a group. This step also improves the forward secrecy of the entire group.
+### Device Compromise
+Clients implementing this NIP should take every precaution to ensure that data is stored in a secure way on the device and is protected against unwanted access in the case that a device is compromised (e.g. encryption at rest, biometric authentication, etc.). That said, full device compromise should be viewed as a catastrophic event and any group the compromised device was a part of should be considered compromised until they can remove that member and update their group's state. Some suggestions:
+- Clients should support and encourage self-destructing messages (ensuring that full transcript history isn't available on a device forever).
+- Clients should regularly suggest to group admins that inactive users be removed.
+- Clients should regularly suggest (or automatically) rotate a user's signing key in each of their groups.
+- Clients should encrypt group state and keys on the device using a secret value that isn't part of the group state or the user's Nostr identity key.
+- Clients should use secure enclave storage where possible.
+For a full discussion of the security considerations of MLS, please see the Security Considerations section of the [MLS RFC](https://www.rfc-editor.org/rfc/rfc9420.html#name-security-considerations).
+## Creating groups
+MLS Groups are created with a random 32-byte ID value that is effectively permanent. This ID should be treated as private to the group and MUST not be published to relays in any form.
+Clients must also ensure that the ciphersuite, capabilities, and extensions they use when creating the group are compatible with those advertised by the users they'd like to invite to the group. They can check this info via the user's published KeyPackage Events.
+When creating a new group, the following MLS extensions MUST be used.
+- [`required_capabilities`](https://docs.rs/openmls/latest/openmls/extensions/struct.RequiredCapabilitiesExtension.html)
+- [`ratchet_tree`](https://docs.rs/openmls/latest/openmls/extensions/struct.RatchetTreeExtension.html)
+- [`nostr_group_data`](https://github.com/rust-nostr/nostr/blob/master/mls/nostr-mls/src/extension.rs)
+And the following MLS extension is highly recommended (more [here](#keypackage-event-and-signing-keys)):
+- [`last_resort`](https://docs.rs/openmls/latest/openmls/extensions/struct.LastResortExtension.html)
+Changes to an MLS group are affected by first creating one or more `Proposal` events and then committing to a set of proposals in a `Commit` event. These are MLS events, not Nostr events. However, for the group state to properly evolve the Commit events (which represent a specific set of proposals - like adding a new user to the group) must be published to relays for the other group members to see. See [Group Messages](#group-events) for more information.
+## MLS Credentials
+A `Credential` in MLS is an assertion of who the user is coupled with a signing key. When constructing `Credentials` for MLS, clients MUST use the `BasicCredential` type and set the `identity` value as the 32-byte hex-encoded public key of the user's Nostr identity key. Clients MUST not allow users to change the identity field and MUST validate that all `Proposal` messages do not attempt to change the identity field on any credential in the group.
+A `Credential` also has an associated signing key. The initial signing key for a user is included in the KeyPackage event. The signing key MUST be different from the user's Nostr identity key. This signing key SHOULD be rotated over time to provide improved post-compromise security.
+## Nostr Group Data Extension
+As mentioned above, the `nostr_group_data` extension is a required MLS extension used to associate Nostr-specific data with an MLS group in a cryptographically secure and proveable way. This extension MUST be included as a required capability when creating a new group.
+The extension stores the following data about the group:
+- `nostr_group_id`: A 32-byte ID for the group. This is a different value from the group ID used by MLS and CAN be changed over time. This value is the group ID value used in the `h` tags when sending group message events.
+- `name`: The name of the group.
+- `description`: A short description of the group.
+- `admin_pubkeys`: An array of the hex-encoded public keys of the group admins. The MLS protocol itself does not have a concept of group admins. Clients MUST check the list of `admin_pubkeys` before making any change to the group data (anything in this extension), or before changing group membership (add/remove members), or updating any other aspect of the group itself (e.g. ciphersuite, etc.). Note, all members of the group can send `Proposal` and `Commits` messages for changes to their own credentials (e.g. updating their signing key).
+- `relays`: An array of the Nostr relay URLs that the group uses to publish and receive messages.
+All of these values can be updated over time using MLS `Proposal` and `Commit` events (by group admins).
+## KeyPackage Event and Signing Keys
+Each user that wishes to be reachable via MLS-based messaging MUST first publish at least one KeyPackage event. The KeyPackage Event is used to authenticate users and create the necessary `Credential` to add members to groups in an asynchronous way. Users can publish multiple KeyPackage Events with different parameters (supporting different ciphersuites or MLS extensions, for example). KeyPackages include a signing key that is used for signing MLS messages within a group. This signing key MUST not be the same as the user's Nostr identity key.
+KeyPackage reuse SHOULD be minimized. However, in normal MLS use, KeyPackages are consumed when joining a group. In order to reduce race conditions between invites for multiple groups using the same Key Package, Nostr clients SHOULD use "Last resort" KeyPackages. This requires the inclusion of the `last_resort` extension on the KeyPackage's capabilities (same as with the Group).
+It's important that clients immediately rotate a user's signing key after joining a group via a last resort key package to improve post-compromise security. The signing key (the public key included in the KeyPackage Event) is used for signing within the group. Therefore, clients implementing this NIP MUST ensure that they retain access to the private key material of the signing key for each group they are a member of.
+In most cases, it's assumed that clients implementing this NIP will manage the creation and rotation of KeyPackage Events.
+### Example KeyPackage Event
+```json
+  {
+    "id": <id>,
+    "kind": 443,
+    "created_at": <unix timestamp in seconds>,
+    "pubkey": <main identity pubkey>,
+    "content": "",
+    "tags": [
+        ["mls_protocol_version", "1.0"],
+        ["ciphersuite", <MLS CipherSuite ID value e.g. "0x0001">],
+        ["extensions", <An array of MLS Extension ID values e.g. "0x0001, 0x0002">],
+        ["client", <client name>, <handler event id>, <optional relay url>],
+        ["relays", <array of relay urls>],
+        ["-"]
+    ],
+    "sig": <signed with main identity key>
+}
+```
+- The `content` hex encoded serialized `KeyPackageBundle` from MLS.
+- The `mls_protocol_version` tag is required and MUST be the version number of the MLS protocol version being used. For now, this is `1.0`.
+- The `ciphersuite` tag is the value of the MLS ciphersuite that this KeyPackage Event supports. [Read more about ciphersuites in MLS](https://www.rfc-editor.org/rfc/rfc9420.html#name-mls-cipher-suites).
+- The `extensions` tag is an array of MLS extension IDs that this KeyPackage Event supports. [Read more about MLS extensions](https://www.rfc-editor.org/rfc/rfc9420.html#name-extensions).
+- (optional) The `client` tag helps other clients manage the user experience when they receive group invites but don't have access to the signing key.
+- The `relays` tag identifies each of the relays that the client will attempt to publish this KeyPackage event. This allows for deletion of KeyPackage Events at a later date.
+- (optional) The `-` tag can be used to ensure that KeyPackage Events are only published by their authenticated author. Read more in [NIP-70](70.md)
+### Deleting KeyPackage Events
+Clients SHOULD delete the KeyPackage Event on all the listed relays any time they successfully process a group request event for a given KeyPackage Event. Clients MAY also create a new KeyPackage Event at the same time.
+If clients cannot process a Welcome message (e.g. because the signing key was generated on another client), clients MUST not delete the KeyPackage Event and SHOULD show a human-understandable error to the user.
+### Rotating Signing Keys
+Clients MUST regularly rotate the user's signing key in each group that they are a part of. The more often the signing key is rotated the stronger the post-compromise security. This rotation is done via `Proposal` and `Commit` events and broadcast to the group via a Group Event. [Read more about forward secrecy and post-compromise security inherent in MLS](https://www.rfc-editor.org/rfc/rfc9420.html#name-forward-secrecy-and-post-co).
+### KeyPackage Relays List Event
+A `kind: 10051` event indicates the relays that a user will publish their KeyPackage Events to. The event MUST include a list of relay tags with relay URIs. These relays SHOULD be readable by anyone the user wants to be able to contact them.
+```json
+{
+  "kind": 10051,
+  "tags": [
+    ["relay", "wss://inbox.nostr.wine"],
+    ["relay", "wss://myrelay.nostr1.com"],
+  ],
+  "content": "",
+  //...other fields
+}
+```
+### Welcome Event
+When a new user is added to a group via an MLS `Commit` message. The member who sends the `Commit` message to the group is responsible for sending the user being added to the group a Welcome Event. This Welcome Event is sent to the user as a [NIP-59](59.md) gift-wrapped event. The Welcome Event gives the new member the context they need to join the group and start sending messages.
+Clients creating the Welcome Event SHOULD wait until they have received acknowledgement from relays that their Group Event with the `Commit` has been received before publishing the Welcome Event.
+```json
+{
+   "id": <id>,
+   "kind": 444,
+   "created_at": <unix timestamp in seconds>,
+   "pubkey": <nostr identity pubkey of sender>,
+   "content": <serialized Welcome object>,
+   "tags": [
+      ["e", <ID of the KeyPackage Event used to add the user to the group>],
+      ["relays", <array of relay urls>],
+   ],
+   "sig": <NOT SIGNED>
+}
+```
+- The `content` field is required and is a serialized MLSMessage object containing the MLS `Welcome` object.
+- The `e` tag is required and is the ID of the KeyPackage Event used to add the user to the group.
+- The `relays` tag is required and is a list of relays clients should query for Group Events.
+Welcome Events are then sealed and gift-wrapped as detailed in [NIP-59](59.md) before being published. Like all events that are sealed and gift-wrapped, `kind: 444` events MUST never be signed. This ensures that if they were ever leaked they would not be publishable to relays.
+#### Large Groups
+For groups above ~150 participants, welcome messages will become larger than the maximum event size allowed by Nostr. There is currently work underway on the MLS protocol to support "light" client welcomes that don't require the full Ratchet Tree state to be sent to the new member. This section will be updated with recommendations for how to handle large groups.
+## Group Events
+Group Events are all the messages that are sent within a group. This includes all "control" events that update the shared group state over time (`Proposal`, `Commit`) and messages sent between members of the group (`Application` messages).
+Group Events are published using an ephemeral Nostr keypair to obfuscate the number and identity of group participants. Clients MUST use a new Nostr keypair for each Group Event they publish.
+```json
+{
+   "id": <id>,
+   "kind": 445,
+   "created_at": <unix timestamp in seconds>,
+   "pubkey": <ephemeral sender pubkey>,
+   "content": <NIP-44 encrypted serialized MLSMessage object>,
+   "tags": [
+      ["h", <group id>]
+   ],
+   "sig": <signed with ephemeral sender key>
+}
+```
+- The `content` field is a [tls-style](https://www.rfc-editor.org/rfc/rfc9420.html#name-the-message-mls-media-type) serialized [`MLSMessage`](https://www.rfc-editor.org/rfc/rfc9420.html#section-6-4) object which is then encrypted according to [NIP-44](44.md). However, instead of using the sender and receivers keys to derive a `conversation_key`, the NIP-44 encryption is done using a Nostr keypair generated from the MLS [`exporter_secret`](https://www.rfc-editor.org/rfc/rfc9420.html#section-8.5) to calculate the `conversation_key` value. Essentially, you use the hex-encoded `exporter_secret` value as the private key (used as the sender key), calculate the public key for that private key (used as the receiver key), and then proceed with the standard NIP-44 scheme to encrypt and decrypt messages.
+- The `exporter_secret` value should be generated with a 32-byte length and labeled `nostr`. This `exporter_secret` value is rotated on each new epoch in the group. Clients should generate a new 32-byte value each time they process a valid `Commit` message.
+- The `pubkey` is the hex-encoded public key of the ephemeral sender.
+- The `h` tag is the nostr group ID value (from the Nostr Group Data Extension).
+### Application Messages
+Application messages are the messages that are sent within the group by members. These are contained within the `MLSMessage` object. The format of these messages should be unsigned Nostr events of the appropriate kind. For normal DM or group messages, clents SHOULD use `kind: 9` chat message events. If the user reacts to a message, it would be a `kind: 7` event, and so on.
+This means that once the application message has been decrypted and deserialized, clients can store those events and treat them as any other Nostr event, effectively creating a private Nostr feed of the group's activity and taking advantage of all the features of Nostr.
+These inner unsigned Nostr events MUST use the member's Nostr identity key for the `pubkey` field and clients MUST check that the identity of them member who sent the message matches the pubkey of the inner Nostr event.
+These Nostr events MUST remain **unsigned** to ensure that if they were to leak to relays they would not be published publicly. These Nostr events MUST not include any "h" tags or other tags that would identify the group that they belong to.
+### `Commit` Message race conditions
+The MLS protocol is resilient to almost all messages arriving out of order. However, the order of `Commit` messages is important for the group state to move forward from one epoch to the next correctly. Given Nostr's nature as a decentralized network, it is possible for a client to receive 2 or more `Commit` messages all attempting to update to a new epoch at the same time.
+Clients sending commit messages MUST wait until they receive acknowledgement from at least one relay that their Group Message Event with the `Commit` has been received before applying the commit to their own group state.
+If a client receives 2 or more `Commit` messages attempting to change same epoch, they MUST apply only one of the `Commit` messages they receive, determined by the following:
+1. Using the `created_at` timestamp on the kind `445` event. The `Commit` with the lowest value for `created_at` is the message to be applied. The other `Commit` message is discarded.
+2. If the `created_at` timestamp is the same for two or more `Commit` messages, the `Commit` message with the lowest value for `id` field is the message to be applied.
+Clients SHOULD retain previous group state for a short period of time in order to recover from forked group state.
diff --git a/README.md b/README.md
index b665f70..e533ff4 100644
--- a/README.md
+++ b/README.md
@@ -11,11 +11,10 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 - [Message Types](#message-types)
  - [Client to Relay](#client-to-relay)
  - [Relay to Client](#relay-to-client)
- [Standardized Tags](#standardized-tags)
+- [Common Tags](#common-tags)
 - [Criteria for acceptance of NIPs](#criteria-for-acceptance-of-nips)
 - [Is this repository a centralizing factor?](#is-this-repository-a-centralizing-factor)
 - [How this repository works](#how-this-repository-works)
- [Breaking Changes](#breaking-changes)
 - [License](#license)
 ---
@@ -44,7 +43,7 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 - [NIP-23: Long-form Content](23.md)
 - [NIP-24: Extra metadata fields and tags](24.md)
 - [NIP-25: Reactions](25.md)
- [NIP-26: Delegated Event Signing](26.md) --- **unrecommended**: adds unecessary burden for little gain
+- [NIP-26: Delegated Event Signing](26.md) --- **unrecommended**: adds unnecessary burden for little gain
 - [NIP-27: Text Note References](27.md)
 - [NIP-28: Public Chat](28.md)
 - [NIP-29: Relay-based Groups](29.md)
@@ -59,6 +58,7 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 - [NIP-39: External Identities in Profiles](39.md)
 - [NIP-40: Expiration Timestamp](40.md)
 - [NIP-42: Authentication of clients to relays](42.md)
+- [NIP-43: Relay Access Metadata and Requests](43.md)
 - [NIP-44: Encrypted Payloads (Versioned)](44.md)
 - [NIP-45: Counting results](45.md)
 - [NIP-46: Nostr Remote Signing](46.md)
@@ -88,25 +88,31 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 - [NIP-72: Moderated Communities](72.md)
 - [NIP-73: External Content IDs](73.md)
 - [NIP-75: Zap Goals](75.md)
+- [NIP-77: Negentropy Syncing](77.md)
 - [NIP-78: Application-specific data](78.md)
 - [NIP-7D: Threads](7D.md)
 - [NIP-84: Highlights](84.md)
+- [NIP-85: Trusted Assertions](85.md)
 - [NIP-86: Relay Management API](86.md)
+- [NIP-87: Ecash Mint Discoverability](87.md)
 - [NIP-88: Polls](88.md)
 - [NIP-89: Recommended Application Handlers](89.md)
 - [NIP-90: Data Vending Machines](90.md)
 - [NIP-92: Media Attachments](92.md)
 - [NIP-94: File Metadata](94.md)
- [NIP-96: HTTP File Storage Integration](96.md)
+- [NIP-96: HTTP File Storage Integration](96.md) --- **unrecommended**: replaced by blossom APIs
 - [NIP-98: HTTP Auth](98.md)
 - [NIP-99: Classified Listings](99.md)
+- [NIP-A0: Voice Messages](A0.md)
+- [NIP-A4: Public Messages](A4.md)
 - [NIP-B0: Web Bookmarks](B0.md)
 - [NIP-B7: Blossom](B7.md)
+- [NIP-BE: Nostr BLE Communications Protocol](BE.md)
 - [NIP-C0: Code Snippets](C0.md)
 - [NIP-C7: Chats](C7.md)
+- [NIP-EE: E2EE Messaging using MLS Protocol](EE.md) --- **unrecommended**: superseded by the [Marmot Protocol](https://github.com/marmot-protocol/marmot)
 ## Event Kinds
 | kind          | description                     | NIP                                    |
 | ------------- | ------------------------------- | -------------------------------------- |
 | `0`           | User Metadata                   | [01](01.md)                            |
@@ -130,10 +136,11 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `20`          | Picture                         | [68](68.md)                            |
 | `21`          | Video Event                     | [71](71.md)                            |
 | `22`          | Short-form Portrait Video Event | [71](71.md)                            |
+| `24`          | Public Message                  | [A4](A4.md)                            |
 | `30`          | internal reference              | [NKBIP-03]                             |
-| `31`          | external web reference          | [NKBIP-03]                            |
+| `31`          | external web reference          | [NKBIP-03]                             |
-| `32`          | hardcopy reference              | [NKBIP-03]                            |
+| `32`          | hardcopy reference              | [NKBIP-03]                             |
-| `33`          | prompt reference                | [NKBIP-03]                            |
+| `33`          | prompt reference                | [NKBIP-03]                             |
 | `40`          | Channel Creation                | [28](28.md)                            |
 | `41`          | Channel Metadata                | [28](28.md)                            |
 | `42`          | Channel Message                 | [28](28.md)                            |
@@ -141,6 +148,9 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `44`          | Channel Mute User               | [28](28.md)                            |
 | `62`          | Request to Vanish               | [62](62.md)                            |
 | `64`          | Chess (PGN)                     | [64](64.md)                            |
+| `443`         | KeyPackage                      | [Marmot](marmot)                       |
+| `444`         | Welcome Message                 | [Marmot](marmot)                       |
+| `445`         | Group Event                     | [Marmot](marmot)                       |
 | `818`         | Merge Requests                  | [54](54.md)                            |
 | `1018`        | Poll Response                   | [88](88.md)                            |
 | `1021`        | Bid                             | [15](15.md)                            |
@@ -150,9 +160,13 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `1063`        | File Metadata                   | [94](94.md)                            |
 | `1068`        | Poll                            | [88](88.md)                            |
 | `1111`        | Comment                         | [22](22.md)                            |
+| `1222`        | Voice Message                   | [A0](A0.md)                            |
+| `1244`        | Voice Message Comment           | [A0](A0.md)                            |
 | `1311`        | Live Chat Message               | [53](53.md)                            |
 | `1337`        | Code Snippet                    | [C0](C0.md)                            |
 | `1617`        | Patches                         | [34](34.md)                            |
+| `1618`        | Pull Requests                   | [34](34.md)                            |
+| `1619`        | Pull Request Updates            | [34](34.md)                            |
 | `1621`        | Issues                          | [34](34.md)                            |
 | `1622`        | Git Replies (deprecated)        | [34](34.md)                            |
 | `1630`-`1633` | Status                          | [34](34.md)                            |
@@ -171,6 +185,10 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `7374`        | Reserved Cashu Wallet Tokens    | [60](60.md)                            |
 | `7375`        | Cashu Wallet Tokens             | [60](60.md)                            |
 | `7376`        | Cashu Wallet History            | [60](60.md)                            |
+| `7516`        | Geocache log                    | [geocaching][geocaching]               |
+| `7517`        | Geocache proof of find          | [geocaching][geocaching]               |
+| `8000`        | Add User                        | [43](43.md)                            |
+| `8001`        | Remove User                     | [43](43.md)                            |
 | `9000`-`9030` | Group Control Events            | [29](29.md)                            |
 | `9041`        | Zap Goal                        | [75](75.md)                            |
 | `9321`        | Nutzap                          | [61](61.md)                            |
@@ -187,15 +205,24 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `10006`       | Blocked relays list             | [51](51.md)                            |
 | `10007`       | Search relays list              | [51](51.md)                            |
 | `10009`       | User groups                     | [51](51.md), [29](29.md)               |
+| `10011`       | External Identities             | [39](39.md)                            |
+| `10012`       | Favorite relays list            | [51](51.md)                            |
 | `10013`       | Private event relay list        | [37](37.md)                            |
 | `10015`       | Interests list                  | [51](51.md)                            |
 | `10019`       | Nutzap Mint Recommendation      | [61](61.md)                            |
+| `10020`       | Media follows                   | [51](51.md)                            |
 | `10030`       | User emoji list                 | [51](51.md)                            |
 | `10050`       | Relay list to receive DMs       | [51](51.md), [17](17.md)               |
+| `10051`       | KeyPackage Relays List          | [Marmot](marmot)                       |
 | `10063`       | User server list                | [Blossom][blossom]                     |
-| `10096`       | File storage server list        | [96](96.md)                            |
+| `10096`       | File storage server list        | [96](96.md) (deprecated)               |
 | `10166`       | Relay Monitor Announcement      | [66](66.md)                            |
+| `10312`       | Room Presence                   | [53](53.md)                            |
+| `10377`       | Proxy Announcement              | [Nostr Epoxy][nostr-epoxy]             |
+| `11111`       | Transport Method Announcement   | [Nostr Epoxy][nostr-epoxy]             |
 | `13194`       | Wallet Info                     | [47](47.md)                            |
+| `13534`       | Membership Lists                | [43](43.md)                            |
+| `14388`       | User Sound Effect Lists         | [Corny Chat][cornychat-usersoundlist]  |
 | `17375`       | Cashu Wallet Event              | [60](60.md)                            |
 | `21000`       | Lightning Pub RPC               | [Lightning.Pub][lnpub]                 |
 | `22242`       | Client Authentication           | [42](42.md)                            |
@@ -204,12 +231,16 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `24133`       | Nostr Connect                   | [46](46.md)                            |
 | `24242`       | Blobs stored on mediaservers    | [Blossom][blossom]                     |
 | `27235`       | HTTP Auth                       | [98](98.md)                            |
+| `28934`       | Join Request                    | [43](43.md)                            |
+| `28935`       | Invite Request                  | [43](43.md)                            |
+| `28936`       | Leave Request                   | [43](43.md)                            |
 | `30000`       | Follow sets                     | [51](51.md)                            |
 | `30001`       | Generic lists                   | 51 (deprecated)                        |
 | `30002`       | Relay sets                      | [51](51.md)                            |
 | `30003`       | Bookmark sets                   | [51](51.md)                            |
 | `30004`       | Curation sets                   | [51](51.md)                            |
 | `30005`       | Video sets                      | [51](51.md)                            |
+| `30006`       | Picture sets                    | [51](51.md)                            |
 | `30007`       | Kind mute sets                  | [51](51.md)                            |
 | `30008`       | Profile Badges                  | [58](58.md)                            |
 | `30009`       | Badge Definition                | [58](58.md)                            |
@@ -228,7 +259,12 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `30166`       | Relay Discovery                 | [66](66.md)                            |
 | `30267`       | App curation sets               | [51](51.md)                            |
 | `30311`       | Live Event                      | [53](53.md)                            |
+| `30312`       | Interactive Room                | [53](53.md)                            |
+| `30313`       | Conference Event                | [53](53.md)                            |
 | `30315`       | User Statuses                   | [38](38.md)                            |
+| `30382`       | User Trusted Assertion          | [85](85.md)                            |
+| `30383`       | Event Trusted Assertion         | [85](85.md)                            |
+| `30384`       | Addressable Trusted Assertion   | [85](85.md)                            |
 | `30388`       | Slide Set                       | [Corny Chat][cornychat-slideset]       |
 | `30402`       | Classified Listing              | [99](99.md)                            |
 | `30403`       | Draft Classified Listing        | [99](99.md)                            |
@@ -244,24 +280,42 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `31924`       | Calendar                        | [52](52.md)                            |
 | `31925`       | Calendar Event RSVP             | [52](52.md)                            |
 | `31989`       | Handler recommendation          | [89](89.md)                            |
-| `31990`       | Handler information             | [89](89.md)                            |                         |
+| `31990`       | Handler information             | [89](89.md)                            |
-| `32267`       | Software Application            |                                        |                        |
+| `32267`       | Software Application            |                                        |
+| `32388`       | User Room Favorites             | [Corny Chat][cornychat-roomfavorites]  |
+| `33388`       | High Scores                     | [Corny Chat][cornychat-highscores]     |
+| `34235`       | Addressable Video Event         | [71](71.md)                            |
+| `34236`       | Addressable Short Video Event   | [71](71.md)                            |
+| `34388`       | Sound Effects                   | [Corny Chat][cornychat-soundeffects]   |
 | `34550`       | Community Definition            | [72](72.md)                            |
+| `38172`       | Cashu Mint Announcement         | [87](87.md)                            |
+| `38173`       | Fedimint Announcement           | [87](87.md)                            |
+| `37516`       | Geocache listing                | [geocaching](geocaching)               |
 | `38383`       | Peer-to-peer Order events       | [69](69.md)                            |
 | `39000-9`     | Group metadata events           | [29](29.md)                            |
+| `39089`       | Starter packs                   | [51](51.md)                            |
+| `39092`       | Media starter packs             | [51](51.md)                            |
 | `39701`       | Web bookmarks                   | [B0](B0.md)                            |
 [NUD: Custom Feeds]: https://wikifreedia.xyz/cip-01/
 [nostrocket]: https://github.com/nostrocket/NIPS/blob/main/Problems.md
 [lnpub]: https://github.com/shocknet/Lightning.Pub/blob/master/proto/autogenerated/client.md
+[cornychat-usersoundlist]: https://cornychat.com/datatypes#kind14388usersoundeffectslist
 [cornychat-slideset]: https://cornychat.com/datatypes#kind30388slideset
 [cornychat-linkset]: https://cornychat.com/datatypes#kind31388linkset
+[cornychat-roomfavorites]: https://cornychat.com/datatypes#kind32388roomfavorites
+[cornychat-highscores]: https://cornychat.com/datatypes#kind33388highscores
+[cornychat-soundeffects]: https://cornychat.com/datatypes#kind34388soundeffectsets
 [joinstr]: https://gitlab.com/1440000bytes/joinstr/-/blob/main/NIP.md
 [NKBIP-01]: https://wikistr.com/nkbip-01*fd208ee8c8f283780a9552896e4823cc9dc6bfd442063889577106940fd927c1
 [NKBIP-02]: https://wikistr.com/nkbip-02*fd208ee8c8f283780a9552896e4823cc9dc6bfd442063889577106940fd927c1
 [NKBIP-03]: https://wikistr.com/nkbip-03*fd208ee8c8f283780a9552896e4823cc9dc6bfd442063889577106940fd927c1
 [blossom]: https://github.com/hzrd149/blossom
 [Tidal-nostr]: https://wikistr.com/tidal-nostr
+[geocaching]: https://nostrhub.io/naddr1qvzqqqrcvypzppscgyy746fhmrt0nq955z6xmf80pkvrat0yq0hpknqtd00z8z68qqgkwet0vdskx6rfdenj6etkv4h8guc6gs5y5
+[nostr-epoxy]: https://github.com/Origami74/nostr-epoxy-reverse-proxy
+[marmot]: https://github.com/marmot-protocol/marmot
 ## Message types
@@ -287,13 +341,15 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `AUTH`   | used to send authentication challenges                  | [42](42.md) |
 | `COUNT`  | used to send requested event counts to clients          | [45](45.md) |
-## Standardized Tags
+## Common Tags
 | name              | value                                | other parameters                | NIP                                                |
 | ----------------- | ------------------------------------ | ------------------------------- | -------------------------------------------------- |
 | `a`               | coordinates to an event              | relay URL                       | [01](01.md)                                        |
 | `A`               | root address                         | relay URL                       | [22](22.md)                                        |
+| `c`               | commit id                            |                                 | [34](34.md)                                       |
 | `d`               | identifier                           | --                              | [01](01.md)                                        |
+| `D`               | day                                  | --                              | [52](52.md)                                        |
 | `e`               | event id (hex)                       | relay URL, marker, pubkey (hex) | [01](01.md), [10](10.md)                           |
 | `E`               | root event id                        | relay URL                       | [22](22.md)                                        |
 | `f`               | currency code                        | --                              | [69](69.md)                                        |
@@ -321,6 +377,7 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `alt`             | summary                              | --                              | [31](31.md)                                        |
 | `amount`          | millisatoshis, stringified           | --                              | [57](57.md)                                        |
 | `bolt11`          | `bolt11` invoice                     | --                              | [57](57.md)                                        |
+| `branch-name`     | branch name suggestion               | --                              | [34](34.md)                                        |
 | `challenge`       | challenge string                     | --                              | [42](42.md)                                        |
 | `client`          | name, address                        | relay URL                       | [89](89.md)                                        |
 | `clone`           | git clone URL                        | --                              | [34](34.md)                                        |
@@ -334,6 +391,8 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `expiration`      | unix timestamp (string)              | --                              | [40](40.md)                                        |
 | `file`            | full path (string)                   | --                              | [35](35.md)                                        |
 | `goal`            | event id (hex)                       | relay URL                       | [75](75.md)                                        |
+| `merge-base`      | commit id                            |                                 | [34](34.md)                                        |
+| `HEAD`            | `ref: refs/heads/<branch-name>`      |                                 | [34](34.md)                                        |
 | `image`           | image URL                            | dimensions in pixels            | [23](23.md), [52](52.md), [58](58.md)              |
 | `imeta`           | inline metadata                      | --                              | [92](92.md)                                        |
 | `license`         | License of the shared content        | --                              | [C0](C0.md)                                        |
@@ -350,6 +409,7 @@ They exist to document what may be implemented by [Nostr](https://github.com/nos
 | `repo`            | Reference to the origin repository   | --                              | [C0](C0.md)                                        |
 | `runtime`         | Runtime or environment specification | --                              | [C0](C0.md)                                        |
 | `server`          | file storage server url              | --                              | [96](96.md)                                        |
+| `sound`           | shortcode, sound url, image url      | --                              | [51](51.md)                                        |
 | `subject`         | subject                              | --                              | [14](14.md), [17](17.md), [34](34.md)              |
 | `summary`         | summary                              | --                              | [23](23.md), [52](52.md)                           |
 | `thumb`           | badge thumbnail                      | dimensions in pixels            | [58](58.md)                                        |
@@ -382,10 +442,6 @@ Standards may emerge in two ways: the first way is that someone starts doing som
 These two ways of standardizing things are supported by this repository. Although the second is preferred, an effort will be made to codify standards emerged outside this repository into NIPs that can be later referenced and easily understood and implemented by others -- but obviously as in any human system discretion may be applied when standards are considered harmful.
-## Breaking Changes
-[Breaking Changes](BREAKING.md)
 ## License
 All NIPs are public domain.